fix(skill): enforce visibility review and distribution boundaries

Signed-off-by: XiaoSeS <87064762+XiaoSeS@users.noreply.github.com>
This commit is contained in:
XiaoSeS 2026-10-15 19:50:13 +08:00
parent 980fa29d81
commit 6927ecf592
39 changed files with 796 additions and 35 deletions

View file

@ -223,6 +223,10 @@ Public API 的可见性规则:
| PUT | `/api/v1/skills/{namespace}/{slug}/tags/{tagName}` | 创建/移动自定义标签(`latest` 为系统保留标签,不可通过此接口操作) |
| DELETE | `/api/v1/skills/{namespace}/{slug}/tags/{tagName}` | 删除自定义标签(`latest` 不可删) |
### 技能可见范围
已发布技能可独立调整范围,不上传新 ZIP、不创建内容版本。`GET/POST /api/v1/skills/{namespace}/{slug}/visibility`(Web 同时支持 `/api/web`)提供当前范围及申请提交;Token 写入需 `skill:publish`,仍需维护权限。扩大范围走统一技能审核,缩小立即生效。请求、响应、扫描和冲突说明见[可见范围使用指南](./skill-visibility.md)。
### 技能生命周期管理
| 方法 | 路径 | 说明 |

View file

@ -127,6 +127,10 @@ Status: current code-aligned reference
- 若仍有其他 `PUBLISHED` 版本,则指向最新一个
- 若已无任何 `PUBLISHED` 版本,则 `latestVersionId = null`
### 4.9 独立调整已发布技能的可见范围
可见范围属于 Skill 容器,不需要新建 SkillVersion。缩小立即生效;扩大创建 `SKILL_METADATA` 范围申请,与内容待审互斥。原范围、目标范围和发布版本快照保存在 ReviewTask,审核通过才更新范围;旧审批不能覆盖新版本。未扫描的已发布包复用存量 bundle 扫描,保持 PUBLISHED,申请绑定扫描 taskId;未通过不得批准。头像按目标受众复用同一审核申请。范围事件仅刷新搜索,不发送“新内容版本发布”通知。操作和接口详见[使用指南](./skill-visibility.md)。
## 5. 对外协议约束
### 5.1 Public / Search / Compat

45
docs/skill-visibility.md Normal file
View file

@ -0,0 +1,45 @@
# 修改已发布技能的可见范围
适用于已发布技能。这个操作保留原技能的标识、ZIP 内容、版本号、评分和下载统计,不需要重新上传包。
## 在哪里操作
1. 打开「我的技能」。
2. 找到已发布且正常的技能,点击「可见范围」。空间管理员也可在有维护权限的技能详情页「生命周期管理」中操作。
3. 选择目标范围,阅读页面提示后保存或提交审核。
技能所有者、所在空间 OWNER/ADMIN 和超级管理员可以操作。普通成员不能调整他人的技能。冻结、归档空间中的技能和隐藏、归档或没有已发布版本的技能不支持此操作。
| 当前范围 | 目标范围 | 处理方式 |
|---|---|---|
| 公开 | 空间成员可见、私有 | 立即生效 |
| 空间成员可见 | 私有 | 立即生效 |
| 私有 | 空间成员可见、公开 | 提交审核 |
| 空间成员可见 | 公开 | 提交审核 |
私有并不代表平台无法治理:技能所有者、拥有相应空间权限的管理员以及现有超级管理员访问规则仍然适用。
## 扩大范围后的审核
- 批准前仍按原范围访问;不提前出现在目标受众的搜索或下载结果中。
- 使用现有「我的审核进度」和空间/平台「技能审核」入口,不增加第二套审核队列。审核详情会显示原范围、目标范围和扫描状态。
- 如果发布包已有可复用的安全通过结果,复用该结果;否则直接扫描已存储的发布包,不要求上传新的版本。扫描进行中、失败或未通过时不能批准,原范围不变。
- 需要扫描而部署方未开启安全扫描器时,本次提交失败,原范围不变。头像机器审核开关不是技能包扫描器开关。
- 有自定义头像时,按目标受众重新执行现有头像规则,并绑定同一技能审核申请。
- 审核拒绝不改变原范围。申请人可在「我的审核进度」撤回;扫描失败后可撤回重试,内容有问题时应上传修复版本。
- 当前技能内容审核没有可关闭的全员直发配置;独立扩大范围沿用该审核行为。头像人工审核开关不会关闭技能范围审核。
存在待审内容版本、正在扫描的待发布版本、待审头像或待审范围申请时,应先完成或撤回,再提交另一项操作。上传接口同样会检查待审范围申请。待审范围期间也不能另提交头像,避免覆盖已绑定的审核内容;单改头像之间仍按原规则允许新申请替换旧申请。
## API 接入
Web 使用 `/api/web`;外部客户端使用 `/api/v1`。两者支持相同的路径:
- `GET /skills/{namespace}/{slug}/visibility`:维护者读取当前范围及待审核目标。
- `POST /skills/{namespace}/{slug}/visibility`:提交 `{"visibility":"PUBLIC"}`、`NAMESPACE_ONLY` 或 `PRIVATE`。
响应 `data` 包含 `visibility`(当前生效范围)、`requestedVisibility`(待审核范围,无则为 null)和 `reviewTaskId`(申请编号,无则为 null)。不能把 `requestedVisibility` 当作已生效范围。
会话调用继续遵守 CSRF;API Token 写入需要 `skill:publish`,服务端仍检查技能维护权限。重复申请和过期审批返回业务冲突。已有统一审核接口负责批准、拒绝和撤回,不新增 CLI 命令。
已下载到用户电脑的文件无法通过缩小范围收回;后续详情和下载接口的新请求按新范围检查。已签发的对象存储预签下载地址在原有效期内仍可能可用(当前 `SkillDownloadService.buildDownloadResult` 使用 `Duration.ofMinutes(10)`);改变范围不会撤销已签发地址。搜索索引在事务提交后异步重建,服务端仍以当前技能权限为准。

View file

@ -1,27 +1,27 @@
## ADDED Requirements
### Requirement: 独立调整范围 SHALL 保持技能身份和内容版本
### Requirement: REQ-VIS-01 独立调整范围 SHALL 保持技能身份和内容版本
现有合法维护者 SHALL 能为已发布、正常技能选择 PUBLIC、NAMESPACE_ONLY 或 PRIVATE,而无需上传 ZIP 或新建版本。技能 ID、坐标、内容版本和统计 SHALL 保留。冻结、归档命名空间或不可维护的技能 SHALL 拒绝操作。
#### Scenario: 缩小访问范围
- **WHEN** 维护者将 PUBLIC 改为 NAMESPACE_ONLY 或 PRIVATE,或将 NAMESPACE_ONLY 改为 PRIVATE
- **THEN** 新范围立即生效,详情、搜索、下载使用同一访问规则,并保留操作审计
- **THEN** 新范围立即生效,详情、搜索、下载的新请求使用同一访问规则(搜索不得依赖陈旧索引的范围授权),并保留操作审计;已签发的对象存储预签地址在原有效期内可能继续有效,已下载文件不能收回
### Requirement: 扩大范围 SHALL 使用现有统一技能审核
扩大范围 SHALL 创建现有技能审核中的元数据申请,记录原范围、目标范围和已发布版本。批准前原范围 SHALL 保持有效;拒绝或撤回 SHALL 不改变范围。审核页 SHALL 清楚显示变更前后范围,不伪装成头像变更。
### Requirement: REQ-VIS-02 扩大范围 SHALL 使用现有统一技能审核
扩大范围 SHALL 创建现有技能审核中的元数据申请,记录原范围、目标范围和已发布版本。批准前原范围 SHALL 保持有效;拒绝或撤回 SHALL 不改变范围。审核页 SHALL 清楚显示变更前后范围,不伪装成头像变更;审核员 SHALL 能通过已授权的审核详情、文件和下载接口检查绑定的已发布内容,不依赖公开详情权限。
#### Scenario: 私有转公开待审
- **WHEN** PRIVATE 技能提交扩大范围申请
- **THEN** 非维护者仍不能读取或下载;审核批准后才允许目标受众访问
### Requirement: 内容审核和范围申请 SHALL 互斥
存在待审内容版本或待审范围申请时 SHALL 先完成或撤回当前申请,再提交另一项。并发上传、范围提交、审核与撤回 SHALL 在同一技能上协调,不能绕过互斥。
### Requirement: REQ-VIS-03 内容审核和范围申请 SHALL 互斥
存在待审内容版本或待审范围申请时 SHALL 先完成或撤回当前申请,再提交另一项。并发上传、范围提交、审核与撤回 SHALL 在同一技能上协调,不能绕过互斥。已有待审头像时 SHALL 拒绝新范围申请并提示先完成或撤回;已有待审范围时 SHALL 拒绝单改头像,不能被头像替换逻辑静默撤销范围申请。单改头像之间的新申请替换旧申请行为不变。
#### Scenario: 待审范围期间上传版本
- **WHEN** 维护者在已有待审范围申请时上传新版本或提交内容审核
- **THEN** 请求被拒绝,现有申请和内容不变
### Requirement: 扩大范围 SHALL 不绕过安全和头像审核
### Requirement: REQ-VIS-04 扩大范围 SHALL 不绕过安全和头像审核
沿用当前技能内容审核规则及目标受众头像规则。现有 PRIVATE 发布可能未执行安全扫描;实现 SHALL 核对扩大范围的扫描前置条件,不得通过独立范围接口绕过现有公开分发安全要求。没有安全通过结果时 SHALL 直接扫描已存发布包而不改变已发布状态;范围申请 SHALL 绑定扫描 taskId。未完成、失败、不安全或旧扫描结果 SHALL 不能批准;原范围保持有效。需要新扫描但 scanner 未启用时 SHALL 明确拒绝。
#### Scenario: 审核期间发布版本改变

View file

@ -1,9 +1,11 @@
## 实施
- [x] 确认现有生命周期、统一审核与发布入口,记录正式需求
- [ ] 实现范围变更、审批、撤回及发布互斥
- [ ] 复用现有审核展示与维护入口
- [ ] 同步 API 类型、文档
- [x] 实现范围变更、审批、撤回及发布互斥
- [x] 复用现有审核展示与维护入口
- [x] 同步真实 springdoc 生成的 API 类型、客户端包装与用户文档
## 验证
- [ ] 后端成功、拒绝、权限、并发及真实数据库迁移
- [ ] 前端请求、状态、审核和类型检查
- [x] 后端成功、拒绝、权限、并发及真实数据库迁移(开发反馈使用 Java 25;正式 Java 21 整合验收另记)
- [x] 前端请求、状态、审核和类型检查
- [ ] 本地构建部署后验证详情、搜索、下载一致性
开发检查覆盖扫描失败/旧 task、完整派生 bundle/缺文件拒绝、陈旧搜索索引、提升更新两事务陈旧实体与待审互斥。部署与真实浏览器验收尚未执行,不以单测代替。

View file

@ -22,6 +22,7 @@ public class SkillVisibilityController extends BaseApiController {
super(responses); this.service = service;
}
@io.swagger.v3.oas.annotations.Operation(operationId = "getSkillVisibility")
@GetMapping("/{namespace}/{slug}/visibility")
public ApiResponse<SkillVisibilityAppService.Result> current(@PathVariable String namespace,
@PathVariable String slug, @RequestAttribute("userId") String actor,
@ -29,6 +30,7 @@ public class SkillVisibilityController extends BaseApiController {
return ok("response.success", service.current(namespace, slug, actor, roles));
}
@io.swagger.v3.oas.annotations.Operation(operationId = "changeSkillVisibility")
@PostMapping("/{namespace}/{slug}/visibility")
public ApiResponse<SkillVisibilityAppService.Result> change(@PathVariable String namespace,
@PathVariable String slug, @Valid @RequestBody ChangeVisibilityRequest request,

View file

@ -97,11 +97,11 @@ public class ReviewSkillDetailAppService {
String userId,
Map<Long, NamespaceRole> userNsRoles) {
ReviewAccessContext context = loadAuthorizedContext(reviewId, userId, userNsRoles);
if (context.task().getSubjectType() == ReviewSubjectType.SKILL_METADATA) {
if (context.task().getSubjectType() == ReviewSubjectType.SKILL_METADATA && context.task().getRequestedVisibility() == null) {
return metadataDetail(context);
}
SkillQueryService.ReviewSkillSnapshotDTO snapshot =
skillQueryService.getReviewSkillSnapshot(context.task().getSkillVersionId());
skillQueryService.getReviewSkillSnapshot(reviewVersionId(context.task()));
SkillLifecycleVersionResponse activeVersion = toLifecycleVersion(snapshot.activeVersion());
SkillDetailResponse skill = new SkillDetailResponse(
@ -162,7 +162,7 @@ public class ReviewSkillDetailAppService {
snapshot.documentationContent(),
"/api/v1/reviews/" + reviewId + "/download",
snapshot.activeVersion().getVersion(),
avatarChange(context)
avatarChange(context), visibilityChange(context.task())
);
}
@ -170,11 +170,11 @@ public class ReviewSkillDetailAppService {
String userId,
Map<Long, NamespaceRole> userNsRoles) {
ReviewAccessContext context = loadAuthorizedContext(reviewId, userId, userNsRoles);
if (context.task().getSkillVersionId() == null) {
if (reviewVersionId(context.task()) == null) {
throw new DomainBadRequestException("review.metadata.no_package");
}
SkillQueryService.ReviewSkillSnapshotDTO snapshot =
skillQueryService.getReviewSkillSnapshot(context.task().getSkillVersionId());
skillQueryService.getReviewSkillSnapshot(reviewVersionId(context.task()));
return skillDownloadService.downloadReviewVersion(snapshot.skill(), snapshot.activeVersion());
}
@ -188,11 +188,11 @@ public class ReviewSkillDetailAppService {
String userId,
Map<Long, NamespaceRole> userNsRoles) {
ReviewAccessContext context = loadAuthorizedContext(reviewId, userId, userNsRoles);
if (context.task().getSkillVersionId() == null) {
if (reviewVersionId(context.task()) == null) {
throw new DomainBadRequestException("review.metadata.no_package");
}
return skillQueryService.getFileContentByVersionId(
context.task().getSkillVersionId(),
reviewVersionId(context.task()),
filePath
);
}
@ -230,6 +230,10 @@ public class ReviewSkillDetailAppService {
avatarChange(context), visibilityChange(context.task()));
}
private Long reviewVersionId(ReviewTask task) {
return task.getRequestedVisibility() != null ? task.getVisibilityVersionId() : task.getSkillVersionId();
}
private ReviewSkillDetailResponse.VisibilityChange visibilityChange(ReviewTask task) {
if (task.getRequestedVisibility() == null) { return null; }
var scan = securityAudits.findLatestActiveByVersionIdAndScannerType(task.getVisibilityVersionId(),

View file

@ -201,6 +201,10 @@ public class SkillAvatarAppService implements ReviewAvatarParticipant {
private SkillAvatarStatusResponse createStoredCandidate(Skill skill, String namespaceSlug, String submittedBy,
String auditActor, String action, String key, String sha256, SkillVisibility audience,
AuditRequestContext context, ReviewTask review) {
if (reviews != null && !"SKILL_AVATAR_SCOPE_REVIEW".equals(action)
&& reviews.existsBySkillIdAndRequestedVisibilityIsNotNullAndStatus(skill.getId(), ReviewTaskStatus.PENDING)) {
throw new DomainConflictException("error.skill.visibility.pending");
}
AvatarReviewSettingsResponse policy = settings.current();
boolean privateOnly = audience == SkillVisibility.PRIVATE;
boolean machineEnabled = !privateOnly && policy.machineEnabled();
@ -462,7 +466,7 @@ public class SkillAvatarAppService implements ReviewAvatarParticipant {
if (reviews == null) { return; }
for (var task : reviews.findByAvatarCandidateIdAndStatus(candidate.getId(),
ReviewTaskStatus.PENDING)) {
if (task.getSubjectType() == ReviewSubjectType.SKILL_METADATA) {
if (task.getSubjectType() == ReviewSubjectType.SKILL_METADATA && task.getRequestedVisibility() == null) {
log(task.getSubmittedBy(), "SKILL_AVATAR_SUPERSEDE", candidate.getId(), new AuditRequestContext(null, null),
AuditDetail.builder().put("reviewTaskId", task.getId()).put("candidateId", candidate.getId())
.put("reason", "replaced-or-removed").put("submittedBy", task.getSubmittedBy())

View file

@ -346,3 +346,4 @@ error.skill.visibility.stale=Visibility or the published version changed. Withdr
error.skill.visibility.notPublished=Only active published skills in an active namespace can change visibility.
error.skill.visibility.scanUnavailable=The published bundle is unavailable for a security scan.
error.skill.visibility.scanIncomplete=The current security scan has not passed. Wider access cannot be approved.
error.skill.visibility.avatarPending=Finish or withdraw the pending avatar review before changing visibility.

View file

@ -289,3 +289,4 @@ error.skill.visibility.stale=Видимость или опубликованн
error.skill.visibility.notPublished=Видимость можно менять только у активного опубликованного навыка в активном пространстве.
error.skill.visibility.scanUnavailable=Опубликованный пакет недоступен для проверки безопасности.
error.skill.visibility.scanIncomplete=Текущая проверка безопасности не пройдена. Расширение доступа нельзя одобрить.
error.skill.visibility.avatarPending=Завершите или отзовите проверку аватара перед изменением видимости.

View file

@ -348,3 +348,4 @@ error.skill.visibility.stale=技能范围或发布版本已变化,请撤回旧
error.skill.visibility.notPublished=仅正常空间内正常、可见且已发布的技能可以修改可见范围。
error.skill.visibility.scanUnavailable=该发布版本的完整包尚不可用,无法发起安全扫描。
error.skill.visibility.scanIncomplete=本次安全扫描尚未通过,无法批准扩大范围。
error.skill.visibility.avatarPending=请先完成或撤回待审核头像,再修改可见范围。

View file

@ -0,0 +1,61 @@
package com.iflytek.skillhub.controller;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.iflytek.skillhub.domain.skill.SkillVisibility;
import com.iflytek.skillhub.service.SkillVisibilityAppService;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Map;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.web.servlet.MockMvc;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@SpringBootTest
@AutoConfigureMockMvc(addFilters = false)
@ActiveProfiles("test")
class SkillVisibilityControllerTest {
@Autowired MockMvc mvc;
@Autowired ObjectMapper mapper;
@MockBean SkillVisibilityAppService visibility;
@Test
void changeReturnsCurrentAndPendingScopesWithoutReplacingThePackage() throws Exception {
when(visibility.change(eq("team"), eq("foo"), eq(SkillVisibility.PUBLIC), eq("owner"), anyMap(), any()))
.thenReturn(new SkillVisibilityAppService.Result(SkillVisibility.PRIVATE, SkillVisibility.PUBLIC, 42L));
mvc.perform(post("/api/web/skills/team/foo/visibility").contentType("application/json")
.content("{\"visibility\":\"PUBLIC\"}").requestAttr("userId", "owner").requestAttr("userNsRoles", Map.of()))
.andExpect(status().isOk()).andExpect(jsonPath("$.data.visibility").value("PRIVATE"))
.andExpect(jsonPath("$.data.requestedVisibility").value("PUBLIC"))
.andExpect(jsonPath("$.data.reviewTaskId").value(42));
}
@Test
void invalidOrMissingVisibilityIsRejected() throws Exception {
for (String content : new String[] {"{}", "{\"visibility\":\"INVALID\"}"}) {
mvc.perform(post("/api/web/skills/team/foo/visibility").contentType("application/json")
.content(content).requestAttr("userId", "owner").requestAttr("userNsRoles", Map.of()))
.andExpect(status().isBadRequest());
}
}
@Test
void openApiDescribesVisibilityChangeAndReviewFields() throws Exception {
String json = mvc.perform(get("/v3/api-docs")).andExpect(status().isOk())
.andReturn().getResponse().getContentAsString();
var schema = mapper.readTree(json);
assertThat(schema.path("paths").has("/api/web/skills/{namespace}/{slug}/visibility")).isTrue();
assertThat(schema.path("components").path("schemas").path("ReviewTaskResponse")
.path("properties").has("requestedVisibility")).isTrue();
String output = System.getProperty("skillhub.openapi.output");
if (output != null && !output.isBlank()) { Files.writeString(Path.of(output), json); }
}
}

View file

@ -91,6 +91,7 @@ class SkillAvatarRecoveryPostgresTest {
@Autowired private JdbcTemplate jdbc;
@Autowired private com.iflytek.skillhub.task.SkillAvatarCleanupTask cleanup;
@Autowired private com.iflytek.skillhub.infra.jpa.UserAccountJpaRepository users;
@MockBean private com.iflytek.skillhub.domain.skill.service.SkillVisibilityService visibilityChanges;
@MockBean private ObjectStorageService storage;
@MockBean private SkillAvatarImageProcessor imageProcessor;
@MockBean private AvatarReviewSettingsService settings;

View file

@ -92,6 +92,7 @@ class SkillAvatarUploadPostgresTest {
@Autowired UserAccountJpaRepository users;
@Autowired PlatformTransactionManager transactions;
@Autowired JdbcTemplate jdbc;
@MockBean private com.iflytek.skillhub.domain.skill.service.SkillVisibilityService visibilityChanges;
@MockBean ObjectStorageService storage;
@MockBean SkillAvatarImageProcessor images;
@MockBean AvatarReviewSettingsService settings;

View file

@ -0,0 +1,258 @@
package com.iflytek.skillhub.repository;
import com.iflytek.skillhub.domain.namespace.Namespace;
import com.iflytek.skillhub.domain.review.*;
import static org.mockito.Mockito.*;
import com.iflytek.skillhub.domain.security.*;
import com.iflytek.skillhub.domain.skill.*;
import com.iflytek.skillhub.domain.skill.service.SkillVisibilityService;
import com.iflytek.skillhub.domain.skill.service.SkillReviewSubmitService;
import com.iflytek.skillhub.domain.user.UserAccount;
import com.iflytek.skillhub.infra.jpa.*;
import java.time.Clock;
import java.time.Instant;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;
import org.testcontainers.containers.PostgreSQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
@DataJpaTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@ActiveProfiles("test")
@Testcontainers
@Import({SkillVisibilityService.class, SkillReviewSubmitService.class,
JpaSkillRepositoryAdapter.class, PromotionService.class, ReviewPermissionChecker.class, SkillVisibilityPostgresTest.Configuration.class})
@Transactional(propagation = Propagation.NOT_SUPPORTED)
class SkillVisibilityPostgresTest {
@Container static final PostgreSQLContainer<?> POSTGRES = new PostgreSQLContainer<>("postgres:16-alpine");
@DynamicPropertySource static void database(DynamicPropertyRegistry registry) {
registry.add("spring.datasource.url", POSTGRES::getJdbcUrl);
registry.add("spring.datasource.username", POSTGRES::getUsername);
registry.add("spring.datasource.password", POSTGRES::getPassword);
registry.add("spring.datasource.driver-class-name", () -> "org.postgresql.Driver");
registry.add("spring.jpa.database-platform", () -> "org.hibernate.dialect.PostgreSQLDialect");
registry.add("spring.flyway.enabled", () -> true);
registry.add("spring.jpa.hibernate.ddl-auto", () -> "validate");
}
@TestConfiguration static class Configuration { @Bean Clock clock() { return Clock.systemUTC(); } @Bean com.fasterxml.jackson.databind.ObjectMapper mapper() { return new com.fasterxml.jackson.databind.ObjectMapper(); } }
@MockBean SecurityScanService scanner;
@MockBean com.iflytek.skillhub.domain.governance.GovernanceNotificationService notifications;
@org.springframework.boot.test.mock.mockito.SpyBean JpaSkillRepositoryAdapter skillAdapter;
@Autowired PromotionService promotions;
@Autowired PromotionRequestJpaRepository promotionRows;
@jakarta.persistence.PersistenceContext jakarta.persistence.EntityManager entityManager;
@Autowired org.springframework.jdbc.core.JdbcTemplate jdbc;
@Autowired SkillVisibilityService visibility;
@Autowired SkillReviewSubmitService submissions;
@Autowired SkillJpaRepository skills;
@Autowired SkillVersionJpaRepository versions;
@Autowired NamespaceJpaRepository namespaces;
@Autowired UserAccountJpaRepository users;
@Autowired SecurityAuditJpaRepository audits;
@Autowired ReviewTaskJpaRepository reviews;
@Autowired PlatformTransactionManager transactions;
@Test
void concurrentScopeSubmissionsPersistOnlyOnePendingRequest() throws Exception {
Fixture fixture = fixture();
CountDownLatch start = new CountDownLatch(1);
try (var pool = Executors.newFixedThreadPool(2)) {
var one = pool.submit(() -> change(start, fixture));
var two = pool.submit(() -> change(start, fixture));
start.countDown();
assertThat(one.get(30, TimeUnit.SECONDS) + two.get(30, TimeUnit.SECONDS)).isEqualTo(1);
}
var pending = reviews.findBySkillIdAndRequestedVisibilityIsNotNullAndStatus(fixture.skillId(), ReviewTaskStatus.PENDING).orElseThrow();
assertThat(pending.getPreviousVisibility()).isEqualTo(SkillVisibility.PRIVATE);
assertThat(pending.getRequestedVisibility()).isEqualTo(SkillVisibility.PUBLIC);
assertThat(pending.getVisibilityVersionId()).isEqualTo(fixture.publishedId());
assertThat(((SkillRepository) skills).findById(fixture.skillId()).orElseThrow().getVisibility()).isEqualTo(SkillVisibility.PRIVATE);
assertThat(((SkillVersionRepository) versions).findById(fixture.publishedId()).orElseThrow().getStatus()).isEqualTo(SkillVersionStatus.PUBLISHED);
}
@Test
void versionSubmissionAndScopeSubmissionAreMutuallyExclusiveAcrossTransactions() throws Exception {
Fixture fixture = fixture();
CountDownLatch start = new CountDownLatch(1);
try (var pool = Executors.newFixedThreadPool(2)) {
var scope = pool.submit(() -> change(start, fixture));
var content = pool.submit(() -> {
start.await(10, TimeUnit.SECONDS);
try {
submissions.submitForReview(fixture.skillId(), fixture.uploadedId(), SkillVisibility.PUBLIC, fixture.owner(), Map.of());
return 1;
} catch (com.iflytek.skillhub.domain.shared.exception.DomainConflictException conflict) { return 0; }
});
start.countDown();
assertThat(scope.get(30, TimeUnit.SECONDS) + content.get(30, TimeUnit.SECONDS)).isEqualTo(1);
}
boolean pendingScope = reviews.existsBySkillIdAndRequestedVisibilityIsNotNullAndStatus(fixture.skillId(), ReviewTaskStatus.PENDING);
boolean pendingContent = ((SkillVersionRepository) versions).findById(fixture.uploadedId()).orElseThrow().getStatus() == SkillVersionStatus.PENDING_REVIEW;
assertThat(pendingScope ^ pendingContent).isTrue();
}
@Test
void stalePublicSearchIndexDoesNotLeakNarrowedScopeOrCounts() {
Fixture fixture = fixture();
new TransactionTemplate(transactions).executeWithoutResult(status -> {
Skill skill = ((SkillRepository) skills).findById(fixture.skillId()).orElseThrow();
skill.setVisibility(SkillVisibility.PUBLIC);
skills.saveAndFlush(skill);
Namespace ns = namespaces.getReferenceById(skill.getNamespaceId());
jdbc.update("INSERT INTO skill_search_document (skill_id, namespace_id, namespace_slug, owner_id, title, visibility, status) VALUES (?, ?, ?, ?, ?, 'PUBLIC', 'ACTIVE')",
skill.getId(), ns.getId(), ns.getSlug(), fixture.owner(), "private-summary");
});
assertThat(search(fixture, null, Set.of()).total()).isEqualTo(1);
visibility.change(fixture.skillId(), SkillVisibility.NAMESPACE_ONLY, fixture.owner(), Map.of(), Set.of());
assertThat(search(fixture, null, Set.of()).skillIds()).isEmpty();
assertThat(search(fixture, null, Set.of()).total()).isZero();
assertThat(search(fixture, "outsider", Set.of()).total()).isZero();
Long namespaceId = ((SkillRepository) skills).findById(fixture.skillId()).orElseThrow().getNamespaceId();
assertThat(search(fixture, "member", Set.of(namespaceId)).total()).isEqualTo(1);
visibility.change(fixture.skillId(), SkillVisibility.PRIVATE, fixture.owner(), Map.of(), Set.of());
assertThat(search(fixture, "member", Set.of(namespaceId)).total()).isZero();
assertThat(jdbc.queryForObject("SELECT visibility FROM skill_search_document WHERE skill_id = ?", String.class, fixture.skillId())).isEqualTo("PUBLIC");
}
private com.iflytek.skillhub.search.SearchResult search(Fixture fixture, String user, Set<Long> memberships) {
return new TransactionTemplate(transactions).execute(status -> {
Skill skill = ((SkillRepository) skills).findById(fixture.skillId()).orElseThrow();
return new com.iflytek.skillhub.search.postgres.PostgresFullTextQueryService(entityManager).search(
new com.iflytek.skillhub.search.SearchQuery(null, skill.getNamespaceId(),
new com.iflytek.skillhub.search.SearchVisibilityScope(user, memberships, Set.of()),
"updated", 0, 10));
});
}
@Test
void promotionApprovalRefreshesItsPreloadedTargetAfterScopeNarrowing() throws Exception {
Fixture fixture = fixture();
PromotionFixture promotion = promotionFixture(fixture);
CountDownLatch targetLoaded = new CountDownLatch(1);
CountDownLatch scopeCommitted = new CountDownLatch(1);
doAnswer(invocation -> {
var result = invocation.callRealMethod();
if (Thread.currentThread().getName().startsWith("scope-promotion-")) {
targetLoaded.countDown();
if (!scopeCommitted.await(20, TimeUnit.SECONDS)) { throw new IllegalStateException("scope commit timeout"); }
}
return result;
}).when(skillAdapter).findById(promotion.targetId());
try (var pool = Executors.newSingleThreadExecutor(runnable -> new Thread(runnable, "scope-promotion-approval"))) {
var approval = pool.submit(() -> promotions.approvePromotion(promotion.requestId(), fixture.owner(), "checked",
Set.of("SUPER_ADMIN"), Set.of()));
assertThat(targetLoaded.await(20, TimeUnit.SECONDS)).isTrue();
visibility.change(promotion.targetId(), SkillVisibility.PRIVATE, fixture.owner(), Map.of(), Set.of());
scopeCommitted.countDown();
approval.get(30, TimeUnit.SECONDS);
} finally { scopeCommitted.countDown(); reset(skillAdapter); }
Skill target = ((SkillRepository) skills).findById(promotion.targetId()).orElseThrow();
assertThat(target.getVisibility()).isEqualTo(SkillVisibility.PRIVATE);
assertThat(target.getLatestVersionId()).isNotEqualTo(promotion.oldVersionId());
}
@Test
void pendingScopeBlocksPromotionApprovalAndRollsBackItsDecision() {
Fixture fixture = fixture();
PromotionFixture promotion = promotionFixture(fixture);
visibility.change(promotion.targetId(), SkillVisibility.PRIVATE, fixture.owner(), Map.of(), Set.of());
new TransactionTemplate(transactions).executeWithoutResult(status -> {
SecurityAudit audit = new SecurityAudit(promotion.oldVersionId(), ScannerType.SKILL_SCANNER, "target-safe-" + promotion.targetId());
audit.setScannedAt(Instant.now()); audit.setIsSafe(true); audits.saveAndFlush(audit);
});
visibility.change(promotion.targetId(), SkillVisibility.PUBLIC, fixture.owner(), Map.of(), Set.of());
assertThatThrownBy(() -> promotions.approvePromotion(promotion.requestId(), fixture.owner(), "checked", Set.of("SUPER_ADMIN"), Set.of()))
.hasMessageContaining("error.skill.visibility.pending");
Skill target = ((SkillRepository) skills).findById(promotion.targetId()).orElseThrow();
assertThat(target.getVisibility()).isEqualTo(SkillVisibility.PRIVATE);
assertThat(target.getLatestVersionId()).isEqualTo(promotion.oldVersionId());
assertThat(((PromotionRequestRepository) promotionRows).findById(promotion.requestId()).orElseThrow().getStatus()).isEqualTo(ReviewTaskStatus.PENDING);
}
private PromotionFixture promotionFixture(Fixture fixture) {
return new TransactionTemplate(transactions).execute(status -> {
String suffix = UUID.randomUUID().toString().substring(0, 8);
Namespace global = new Namespace("scope-global-" + suffix, "Global", fixture.owner());
global.setType(com.iflytek.skillhub.domain.namespace.NamespaceType.GLOBAL);
global = namespaces.saveAndFlush(global);
Skill target = new Skill(global.getId(), "foo", fixture.owner(), SkillVisibility.PUBLIC);
target.setSourceSkillId(fixture.skillId()); target = skills.saveAndFlush(target);
SkillVersion old = new SkillVersion(target.getId(), "0.9.0", fixture.owner());
old.setStatus(SkillVersionStatus.PUBLISHED); old.setBundleReady(true);
old = versions.saveAndFlush(old); target.setLatestVersionId(old.getId()); skills.saveAndFlush(target);
PromotionRequest initial = new PromotionRequest(fixture.skillId(), fixture.publishedId(), global.getId(), fixture.owner());
initial.setStatus(ReviewTaskStatus.APPROVED); initial.setTargetSkillId(target.getId()); initial.setTargetVersionId(old.getId());
promotionRows.saveAndFlush(initial);
PromotionRequest update = new PromotionRequest(fixture.skillId(), fixture.publishedId(), global.getId(), fixture.owner());
update.setRequestKind(PromotionRequestKind.UPDATE); update.setTargetSkillId(target.getId());
update = promotionRows.saveAndFlush(update);
return new PromotionFixture(target.getId(), old.getId(), update.getId());
});
}
private record PromotionFixture(Long targetId, Long oldVersionId, Long requestId) {}
@Test
void rollbackDoesNotLeaveAnApprovedScopeOrPendingRequest() {
Fixture fixture = fixture();
assertThatThrownBy(() -> new TransactionTemplate(transactions).execute(status -> {
visibility.change(fixture.skillId(), SkillVisibility.PUBLIC, fixture.owner(), Map.of(), Set.of());
throw new IllegalStateException("rollback");
})).hasMessage("rollback");
assertThat(reviews.existsBySkillIdAndRequestedVisibilityIsNotNullAndStatus(fixture.skillId(), ReviewTaskStatus.PENDING)).isFalse();
assertThat(((SkillRepository) skills).findById(fixture.skillId()).orElseThrow().getVisibility()).isEqualTo(SkillVisibility.PRIVATE);
}
private int change(CountDownLatch start, Fixture fixture) throws Exception {
start.await(10, TimeUnit.SECONDS);
try {
visibility.change(fixture.skillId(), SkillVisibility.PUBLIC, fixture.owner(), Map.of(), Set.of());
return 1;
} catch (com.iflytek.skillhub.domain.shared.exception.DomainConflictException conflict) { return 0; }
}
private Fixture fixture() {
return new TransactionTemplate(transactions).execute(status -> {
String suffix = UUID.randomUUID().toString().substring(0, 8);
String owner = "scope-owner-" + suffix;
users.saveAndFlush(new UserAccount(owner, owner, null, null));
Namespace ns = namespaces.saveAndFlush(new Namespace("scope-" + suffix, "Scope", owner));
Skill skill = skills.saveAndFlush(new Skill(ns.getId(), "foo", owner, SkillVisibility.PRIVATE));
SkillVersion published = new SkillVersion(skill.getId(), "1.0.0", owner);
published.setStatus(SkillVersionStatus.PUBLISHED);
published.setBundleReady(true);
published = versions.saveAndFlush(published);
skill.setLatestVersionId(published.getId());
skills.saveAndFlush(skill);
SecurityAudit scan = new SecurityAudit(published.getId(), ScannerType.SKILL_SCANNER, "scope-scan-" + suffix);
scan.setScannedAt(Instant.now()); scan.setIsSafe(true);
audits.saveAndFlush(scan);
SkillVersion uploaded = new SkillVersion(skill.getId(), "2.0.0", owner);
uploaded.setStatus(SkillVersionStatus.UPLOADED);
uploaded = versions.saveAndFlush(uploaded);
return new Fixture(skill.getId(), published.getId(), uploaded.getId(), owner);
});
}
private record Fixture(Long skillId, Long publishedId, Long uploadedId, String owner) {}
}

View file

@ -183,6 +183,39 @@ class ReviewSkillDetailAppServiceTest {
assertThat(downloadResult.contentLength()).isEqualTo(3L);
}
@Test
void visibilityReviewAllowsAuthorizedReviewerToInspectTheBoundPrivatePackage() throws Exception {
Skill skill = createSkill(101L, 20L, "skill-a");
skill.setVisibility(SkillVisibility.PRIVATE); skill.setLatestVersionId(100L);
ReviewTask task = ReviewTask.forVisibility(skill, SkillVisibility.PUBLIC, "owner-1");
task.setVisibilityScanTaskId("scope-scan"); setField(task, "id", 42L);
Namespace namespace = createNamespace(20L, "team-a");
SkillVersion published = createVersion(100L, 101L, "1.0.0", SkillVersionStatus.PUBLISHED);
var audits = org.mockito.Mockito.mock(com.iflytek.skillhub.domain.security.SecurityAuditRepository.class);
var scan = new com.iflytek.skillhub.domain.security.SecurityAudit(100L,
com.iflytek.skillhub.domain.security.ScannerType.SKILL_SCANNER, "scope-scan");
scan.setScannedAt(Instant.now()); scan.setIsSafe(true);
service.configureSecurityAudits(audits);
given(audits.findLatestActiveByVersionIdAndScannerType(100L,
com.iflytek.skillhub.domain.security.ScannerType.SKILL_SCANNER)).willReturn(Optional.of(scan));
given(reviewTaskRepository.findById(42L)).willReturn(Optional.of(task));
given(namespaceRepository.findById(20L)).willReturn(Optional.of(namespace));
given(rbacService.getUserRoleCodes("admin")).willReturn(Set.of("SKILL_ADMIN"));
given(reviewService.canViewReview(task, "admin", namespace.getType(), Map.of(), Set.of("SKILL_ADMIN"))).willReturn(true);
given(skillQueryService.getReviewSkillSnapshot(100L)).willReturn(new SkillQueryService.ReviewSkillSnapshotDTO(
skill, "Owner", published, published, List.of(published), List.of(createFile(5L, 100L, "SKILL.md")), "SKILL.md", "private package"));
given(skillQueryService.getFileContentByVersionId(100L, "SKILL.md"))
.willReturn(new ByteArrayInputStream("private package".getBytes()));
var download = new SkillDownloadService.DownloadResult(() -> new ByteArrayInputStream(new byte[]{1}), "review.zip", 1, "application/zip", null, true);
given(skillDownloadService.downloadReviewVersion(skill, published)).willReturn(download);
var detail = service.getReviewSkillDetail(42L, "admin", Map.of());
assertThat(detail.documentationContent()).isEqualTo("private package");
assertThat(detail.files()).hasSize(1);
assertThat(detail.visibilityChange().scanStatus()).isEqualTo("PASSED");
assertThat(service.getReviewFileContent(42L, "SKILL.md", "admin", Map.of()).readAllBytes()).isEqualTo("private package".getBytes());
assertThat(service.downloadReviewPackage(42L, "admin", Map.of()).filename()).isEqualTo("review.zip");
}
@Test
void getReviewSkillDetail_rejectsUnauthorizedUser() {
ReviewTask task = createReviewTask(42L, 101L, 20L, "submitter");

View file

@ -353,6 +353,18 @@ class SkillAvatarAppServiceTest {
verifyNoInteractions(skills);
}
@Test
void pendingVisibilityRequestCannotBeSupersededByANewAvatar() {
when(namespaces.findBySlug("team")).thenReturn(Optional.of(namespace));
when(skills.findLockedById(11L)).thenReturn(Optional.of(skill));
when(reviews.existsBySkillIdAndRequestedVisibilityIsNotNullAndStatus(11L,
com.iflytek.skillhub.domain.review.ReviewTaskStatus.PENDING)).thenReturn(true);
assertThatThrownBy(() -> service.submitStored("team", "foo", "owner", "new/image.png", "sha",
SkillVisibility.PUBLIC, new AuditRequestContext(null, null)))
.isInstanceOf(DomainConflictException.class).hasMessageContaining("error.skill.visibility.pending");
verifyNoInteractions(candidates, storage);
}
@Test
void nonOwnerCannotSubmitBeforeWritingToStorage() {
when(namespaces.findBySlug("team")).thenReturn(Optional.of(namespace));

View file

@ -258,6 +258,8 @@ public class RouteSecurityPolicyRegistry {
ApiTokenPolicy.require(HttpMethod.DELETE, "/api/v1/skills/*/*", "skill:delete"),
ApiTokenPolicy.require(HttpMethod.DELETE, "/api/v1/skills/*/*/versions/*", "skill:delete"),
ApiTokenPolicy.require(HttpMethod.DELETE, "/api/web/skills/*/*/versions/*", "skill:delete"),
ApiTokenPolicy.require(HttpMethod.POST, "/api/v1/skills/*/*/visibility", "skill:publish"),
ApiTokenPolicy.require(HttpMethod.POST, "/api/web/skills/*/*/visibility", "skill:publish"),
ApiTokenPolicy.require(HttpMethod.POST, "/api/v1/skills/*/*/archive", "skill:publish"),
ApiTokenPolicy.require(HttpMethod.POST, "/api/v1/skills/*/*/unarchive", "skill:publish"),
ApiTokenPolicy.require(HttpMethod.POST, "/api/web/skills/*/*/archive", "skill:publish"),

View file

@ -18,6 +18,17 @@ class RouteSecurityPolicyRegistryTest {
private final RouteSecurityPolicyRegistry registry = new RouteSecurityPolicyRegistry();
@Test
void visibilityWritesRequirePublishScopeAndAuthenticatedReads() {
for (String prefix : List.of("/api/v1", "/api/web")) {
String route = prefix + "/skills/team/foo/visibility";
assertEquals(RouteSecurityPolicyRegistry.AccessLevel.AUTHENTICATED, registry.accessLevel("GET", route));
assertEquals(RouteSecurityPolicyRegistry.AccessLevel.AUTHENTICATED, registry.accessLevel("POST", route));
assertFalse(registry.authorizeApiToken("POST", route, Set.of("skill:read")).allowed());
assertTrue(registry.authorizeApiToken("POST", route, Set.of("skill:publish")).allowed());
}
}
@Test
void packagePreviewIsAuthenticatedAndRequiresPublishScope() {
for (String prefix : java.util.List.of("/api/v1", "/api/web")) {

View file

@ -54,6 +54,11 @@ public class PromotionService {
private final EntityManager entityManager;
private final Clock clock;
private final ObjectMapper objectMapper;
private com.iflytek.skillhub.domain.skill.service.SkillVisibilityService visibilityService;
@org.springframework.beans.factory.annotation.Autowired
public void setVisibilityService(com.iflytek.skillhub.domain.skill.service.SkillVisibilityService service) {
this.visibilityService = service;
}
public PromotionService(PromotionRequestRepository promotionRequestRepository,
SkillRepository skillRepository,
@ -221,6 +226,9 @@ public class PromotionService {
}
// Serialize approval with ordinary uploads that lock target Skill before publishing.
entityManager.lock(targetSkill, jakarta.persistence.LockModeType.PESSIMISTIC_WRITE);
entityManager.refresh(targetSkill);
assertSkillActive(targetSkill);
if (visibilityService != null) { visibilityService.assertNoPendingVisibility(targetSkill.getId()); }
assertTargetVersionAvailable(targetSkill.getId(), sourceVersion.getVersion());
applySourceVersionMetadata(targetSkill, sourceSkill, sourceVersion);
} else {

View file

@ -40,6 +40,10 @@ public class SecurityScanService {
private final ObjectMapper objectMapper;
private final String scanMode;
private final boolean enabled;
private com.iflytek.skillhub.domain.skill.service.SkillDownloadService bundles;
@Autowired
public void setBundles(com.iflytek.skillhub.domain.skill.service.SkillDownloadService service) { this.bundles = service; }
@Autowired
public SecurityScanService(SecurityAuditRepository auditRepository,
@ -78,8 +82,8 @@ public class SecurityScanService {
if (version.getStatus() != SkillVersionStatus.PUBLISHED || !version.isBundleReady()) {
throw new IllegalStateException("Only published bundled versions can be scanned");
}
ScanTask task = new ScanTask(UUID.randomUUID().toString(), version.getId(), null,
"packages/" + version.getSkillId() + "/" + version.getId() + "/bundle.zip",
String bundleKey = bundles.ensureScanBundle(version);
ScanTask task = new ScanTask(UUID.randomUUID().toString(), version.getId(), null, bundleKey,
publisherId, System.currentTimeMillis(),
Map.of("scannerType", ScannerType.SKILL_SCANNER.getValue()));
persistScanAttempt(version, task);

View file

@ -212,6 +212,20 @@ public class SkillDownloadService {
return result;
}
/** Repairs a derived/legacy version's missing bundle before scanning its full package. */
public String ensureScanBundle(SkillVersion version) {
String key = String.format("packages/%d/%d/bundle.zip", version.getSkillId(), version.getId());
if (objectStorageService.exists(key)) { return key; }
List<SkillFile> files = skillFileRepository.findByVersionId(version.getId());
if (files.isEmpty() || files.size() != version.getFileCount()
|| files.stream().anyMatch(file -> !objectStorageService.exists(file.getStorageKey()))) {
throw new DomainBadRequestException("error.skill.bundle.notFound");
}
byte[] bundle = createBundle(files.stream().sorted(Comparator.comparing(SkillFile::getFilePath)).toList());
objectStorageService.putObject(key, new ByteArrayInputStream(bundle), bundle.length, "application/zip");
return key;
}
private String buildBundleStorageKey(Skill skill, SkillVersion version) {
return String.format("packages/%d/%d/bundle.zip", skill.getId(), version.getId());
}

View file

@ -52,6 +52,9 @@ public class SkillVisibilityService {
|| !versions.findBySkillIdAndStatus(skillId, SkillVersionStatus.SCANNING).isEmpty()) {
throw new DomainConflictException("error.skill.visibility.pending");
}
if (skill.getPendingAvatarId() != null) {
throw new DomainConflictException("error.skill.visibility.avatarPending");
}
if (target.ordinal() > skill.getVisibility().ordinal()) {
apply(skill, target, actor);
return null;

View file

@ -0,0 +1,74 @@
package com.iflytek.skillhub.domain.review;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.iflytek.skillhub.domain.governance.GovernanceNotificationService;
import com.iflytek.skillhub.domain.namespace.*;
import com.iflytek.skillhub.domain.skill.*;
import com.iflytek.skillhub.domain.skill.service.*;
import jakarta.persistence.EntityManager;
import java.time.Clock;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationEventPublisher;
import static org.mockito.Mockito.*;
import static org.assertj.core.api.Assertions.*;
class ReviewVisibilityWorkflowTest {
private final ReviewTaskRepository tasks = mock(ReviewTaskRepository.class);
private final SkillVersionRepository versions = mock(SkillVersionRepository.class);
private final NamespaceRepository namespaces = mock(NamespaceRepository.class);
private final ReviewPermissionChecker permissions = mock(ReviewPermissionChecker.class);
private final ReviewAvatarParticipant avatars = mock(ReviewAvatarParticipant.class);
private final SkillVisibilityService visibility = mock(SkillVisibilityService.class);
private ReviewService service;
private ReviewTask task;
@BeforeEach
void setup() throws Exception {
service = new ReviewService(tasks, versions, mock(SkillRepository.class), namespaces, permissions,
mock(ApplicationEventPublisher.class), new ObjectMapper(), mock(SkillGovernanceService.class),
mock(GovernanceNotificationService.class), mock(EntityManager.class), Clock.systemUTC());
service.setAvatarParticipant(avatars); service.setVisibilityService(visibility);
Skill skill = mock(Skill.class);
when(skill.getId()).thenReturn(1L); when(skill.getNamespaceId()).thenReturn(2L);
when(skill.getVisibility()).thenReturn(SkillVisibility.PRIVATE); when(skill.getLatestVersionId()).thenReturn(3L);
task = ReviewTask.forVisibility(skill, SkillVisibility.PUBLIC, "owner");
var id = ReviewTask.class.getDeclaredField("id"); id.setAccessible(true); id.set(task, 4L);
when(tasks.findById(4L)).thenReturn(Optional.of(task));
when(tasks.updateStatusWithVersion(eq(4L), any(), any(), any(), any())).thenReturn(1);
Namespace namespace = mock(Namespace.class);
when(namespace.getStatus()).thenReturn(NamespaceStatus.ACTIVE);
when(namespace.getType()).thenReturn(NamespaceType.TEAM);
when(namespaces.findById(2L)).thenReturn(Optional.of(namespace));
when(permissions.canReview(eq(task), eq("admin"), any(), anyMap(), anySet())).thenReturn(true);
}
@Test
void approveParticipatesInUnifiedReviewWithoutRepublishingContent() {
service.approveReview(4L, "admin", "checked", Map.of(), Set.of());
verify(visibility).validateApproval(task);
verify(visibility).approve(task, "admin");
verify(avatars).decide(task, true, "admin", "checked");
assertThat(task.getStatus()).isEqualTo(ReviewTaskStatus.APPROVED);
verifyNoInteractions(versions);
}
@Test
void rejectLeavesPublishedVersionAndScopeUntouched() {
service.rejectReview(4L, "admin", "not ready", Map.of(), Set.of());
verifyNoInteractions(visibility, versions);
verify(avatars).decide(task, false, "admin", "not ready");
assertThat(task.getStatus()).isEqualTo(ReviewTaskStatus.REJECTED);
}
@Test
void withdrawUsesExistingReviewPathWithoutChangingPublishedContent() {
service.withdrawMetadata(task, "owner");
verify(tasks).delete(task);
verify(avatars).withdraw(task);
verifyNoInteractions(visibility, versions);
}
}

View file

@ -67,7 +67,11 @@ class SecurityScanServiceTest {
setId(version, 42L);
version.setStatus(SkillVersionStatus.PUBLISHED);
version.setBundleReady(true);
var bundles = org.mockito.Mockito.mock(com.iflytek.skillhub.domain.skill.service.SkillDownloadService.class);
given(bundles.ensureScanBundle(version)).willReturn("packages/8/42/bundle.zip");
service.setBundles(bundles);
ScanTask task = service.scanPublishedVersion(version, "publisher-1");
verify(bundles).ensureScanBundle(version);
assertThat(task.bundleKey()).isEqualTo("packages/8/42/bundle.zip");
assertThat(task.skillPath()).isNull();
assertThat(version.getStatus()).isEqualTo(SkillVersionStatus.PUBLISHED);

View file

@ -73,6 +73,35 @@ class SkillDownloadServiceTest {
);
}
@Test
void missingDerivedScanBundleIsRebuiltFromEveryStoredFile() throws Exception {
SkillVersion version = new SkillVersion(8L, "1.0.0", "owner");
setId(version, 42L); version.setFileCount(1);
SkillFile file = new SkillFile(42L, "SKILL.md", 3L, "text/markdown", "sha", "source/SKILL.md");
when(skillFileRepository.findByVersionId(42L)).thenReturn(List.of(file));
when(objectStorageService.exists("packages/8/42/bundle.zip")).thenReturn(false);
when(objectStorageService.exists("source/SKILL.md")).thenReturn(true);
when(objectStorageService.getObject("source/SKILL.md")).thenReturn(new ByteArrayInputStream(new byte[]{1, 2, 3}));
assertEquals("packages/8/42/bundle.zip", service.ensureScanBundle(version));
var content = org.mockito.ArgumentCaptor.forClass(InputStream.class);
verify(objectStorageService).putObject(eq("packages/8/42/bundle.zip"), content.capture(), anyLong(), eq("application/zip"));
try (ZipInputStream zip = new ZipInputStream(content.getValue())) {
assertEquals("SKILL.md", zip.getNextEntry().getName());
assertArrayEquals(new byte[]{1, 2, 3}, zip.readAllBytes());
}
verifyNoInteractions(eventPublisher);
}
@Test
void incompleteDerivedPackageCannotBeScannedAsPartialBundle() throws Exception {
SkillVersion version = new SkillVersion(8L, "1.0.0", "owner");
setId(version, 42L); version.setFileCount(1);
when(skillFileRepository.findByVersionId(42L)).thenReturn(List.of(
new SkillFile(42L, "SKILL.md", 3L, "text/markdown", "sha", "missing/SKILL.md")));
assertThrows(DomainBadRequestException.class, () -> service.ensureScanBundle(version));
verify(objectStorageService, never()).putObject(anyString(), any(), anyLong(), anyString());
}
@Test
void testDownloadLatest_Success() throws Exception {
// Arrange

View file

@ -75,6 +75,16 @@ class SkillVisibilityServiceTest {
assertThat(skill.getVisibility()).isEqualTo(SkillVisibility.PUBLIC);
}
@Test
void pendingAvatarBlocksScopeChangeWithoutSupersedingIt() {
skill.setPendingAvatarId(99L);
assertThatThrownBy(() -> service.change(1L, SkillVisibility.PRIVATE, "owner", Map.of(), Set.of()))
.hasMessageContaining("error.skill.visibility.avatarPending");
assertThat(skill.getPendingAvatarId()).isEqualTo(99L);
assertThat(skill.getVisibility()).isEqualTo(SkillVisibility.PUBLIC);
verify(reviews, never()).save(any());
}
@Test
void pendingVersionBlocksChange() {
when(versions.findBySkillIdAndStatus(1L, SkillVersionStatus.PENDING_REVIEW))

View file

@ -112,10 +112,10 @@ public class PostgresFullTextQueryService implements SearchQueryService {
}
sql.append("WHERE 1=1 ");
// Visibility filtering
sql.append("AND (d.visibility = 'PUBLIC' ");
// Authorize against the current aggregate, even while its asynchronous index is stale.
sql.append("AND (s.visibility = 'PUBLIC' ");
if (query.visibilityScope().userId() != null) {
sql.append("OR (d.visibility = 'NAMESPACE_ONLY' AND d.namespace_id IN :memberNamespaceIds) ");
sql.append("OR (s.visibility = 'NAMESPACE_ONLY' AND s.namespace_id IN :memberNamespaceIds) ");
}
sql.append(") ");

View file

@ -390,7 +390,7 @@ class PostgresFullTextQueryServiceTest {
ArgumentCaptor<String> sqlCaptor = ArgumentCaptor.forClass(String.class);
verify(entityManager, org.mockito.Mockito.times(2)).createNativeQuery(sqlCaptor.capture());
assertThat(sqlCaptor.getAllValues().getFirst())
.contains("AND (d.visibility = 'PUBLIC' )")
.contains("AND (s.visibility = 'PUBLIC' )")
.contains("AND d.status = 'ACTIVE'")
.contains("AND s.status = 'ACTIVE'")
.contains("AND s.hidden = FALSE")

View file

@ -624,12 +624,12 @@ export const accountApi = {
export const skillLifecycleApi = {
async getVisibility(namespace: string, slug: string) {
const cleanNamespace = namespace.startsWith('@') ? namespace.slice(1) : namespace
return fetchJson<{ visibility: string; requestedVisibility?: string; reviewTaskId?: number }>(
return fetchJson<components['schemas']['Result']>(
`${WEB_API_PREFIX}/skills/${encodeURIComponent(cleanNamespace)}/${encodeURIComponent(slug)}/visibility`)
},
async changeVisibility(namespace: string, slug: string, visibility: 'PUBLIC' | 'NAMESPACE_ONLY' | 'PRIVATE') {
const cleanNamespace = namespace.startsWith('@') ? namespace.slice(1) : namespace
return fetchJson<{ visibility: string; requestedVisibility?: string; reviewTaskId?: number }>(
return fetchJson<components['schemas']['Result']>(
`${WEB_API_PREFIX}/skills/${encodeURIComponent(cleanNamespace)}/${encodeURIComponent(slug)}/visibility`, {
method: 'POST', headers: await ensureCsrfHeaders({ 'Content-Type': 'application/json' }),
body: JSON.stringify({ visibility }),

View file

@ -1186,6 +1186,38 @@ export interface paths {
patch?: never;
trace?: never;
};
"/api/v1/skills/{namespace}/{slug}/visibility": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["getSkillVisibility"];
put?: never;
post: operations["changeSkillVisibility"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/web/skills/{namespace}/{slug}/visibility": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["getSkillVisibility_1"];
put?: never;
post: operations["changeSkillVisibility_1"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/v1/skills/{namespace}/{slug}/versions/{version}/yank": {
parameters: {
query?: never;
@ -6693,6 +6725,27 @@ export interface components {
/** @enum {string} */
visibility?: "PUBLIC" | "NAMESPACE_ONLY" | "PRIVATE";
};
ChangeVisibilityRequest: {
/** @enum {string} */
visibility: "PUBLIC" | "NAMESPACE_ONLY" | "PRIVATE";
};
ApiResponseResult: {
/** Format: int32 */
code?: number;
msg?: string;
data?: components["schemas"]["Result"];
/** Format: date-time */
timestamp?: string;
requestId?: string;
};
Result: {
/** @enum {string} */
visibility?: "PUBLIC" | "NAMESPACE_ONLY" | "PRIVATE";
/** @enum {string} */
requestedVisibility?: "PUBLIC" | "NAMESPACE_ONLY" | "PRIVATE";
/** Format: int64 */
reviewTaskId?: number;
};
AdminSkillActionRequest: {
reason?: string;
};
@ -6862,6 +6915,8 @@ export interface components {
/** Format: int64 */
avatarCandidateId?: number;
avatarRemoval?: boolean;
previousVisibility?: string;
requestedVisibility?: string;
};
ReviewTaskRequest: {
/** Format: int64 */
@ -8048,6 +8103,13 @@ export interface components {
downloadUrl?: string;
activeVersion?: string;
avatarChange?: components["schemas"]["AvatarChange"];
visibilityChange?: components["schemas"]["VisibilityChange"];
};
VisibilityChange: {
previousVisibility?: string;
requestedVisibility?: string;
scanStatus?: string;
readyForApproval?: boolean;
};
ApiResponseListReviewTaskResponse: {
/** Format: int32 */
@ -11900,6 +11962,106 @@ export interface operations {
};
};
};
getSkillVisibility: {
parameters: {
query?: never;
header?: never;
path: {
namespace: string;
slug: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"*/*": components["schemas"]["ApiResponseResult"];
};
};
};
};
changeSkillVisibility: {
parameters: {
query?: never;
header?: never;
path: {
namespace: string;
slug: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["ChangeVisibilityRequest"];
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"*/*": components["schemas"]["ApiResponseResult"];
};
};
};
};
getSkillVisibility_1: {
parameters: {
query?: never;
header?: never;
path: {
namespace: string;
slug: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"*/*": components["schemas"]["ApiResponseResult"];
};
};
};
};
changeSkillVisibility_1: {
parameters: {
query?: never;
header?: never;
path: {
namespace: string;
slug: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["ChangeVisibilityRequest"];
};
};
responses: {
/** @description OK */
200: {
headers: {
[name: string]: unknown;
};
content: {
"*/*": components["schemas"]["ApiResponseResult"];
};
};
};
};
yankVersion: {
parameters: {
query?: never;

View file

@ -656,7 +656,7 @@ export interface ReviewProgressPage {
}
export interface ReviewSkillDetail {
visibilityChange?: { previousVisibility: string; requestedVisibility: string; scanStatus: string; readyForApproval: boolean }
visibilityChange?: components['schemas']['VisibilityChange']
skill: SkillDetail
versions: SkillVersion[]
files: SkillFile[]

View file

@ -19,7 +19,7 @@ export function SkillVisibilityDialog({ namespace, slug, visibility, disabled =
const [target, setTarget] = useState<Visibility>('PUBLIC')
const [error, setError] = useState('')
const state = useQuery({
queryKey: ['skill', namespace, slug, 'visibility'],
queryKey: ['skills', namespace, slug, 'visibility'],
queryFn: () => skillLifecycleApi.getVisibility(namespace, slug),
enabled: open,
})

View file

@ -2773,7 +2773,7 @@
"current": "Current scope: {{visibility}}",
"PUBLIC": "Public",
"NAMESPACE_ONLY": "Namespace members",
"PRIVATE": "Only me",
"PRIVATE": "Private (owner and authorized administrators)",
"expanding": "Wider access requires review. Current access stays in effect until approval. Track or withdraw the request in My review progress.",
"narrowing": "Narrower access takes effect immediately. Previous viewers may lose access to details and downloads.",
"submit": "Submit for review",

View file

@ -2775,7 +2775,7 @@
"current": "Текущий доступ: {{visibility}}",
"PUBLIC": "Публичный",
"NAMESPACE_ONLY": "Участникам пространства",
"PRIVATE": "Только мне",
"PRIVATE": "Приватный (владельцу и уполномоченным администраторам)",
"expanding": "Расширение доступа требует проверки. До одобрения действует текущий доступ. Заявку можно просмотреть или отозвать в разделе проверок.",
"narrowing": "Ограничение доступа применяется сразу. Предыдущие пользователи могут потерять доступ к просмотру и загрузке.",
"submit": "Отправить на проверку",

View file

@ -2772,7 +2772,7 @@
"current": "当前范围:{{visibility}}",
"PUBLIC": "公开",
"NAMESPACE_ONLY": "空间成员可见",
"PRIVATE": "仅自己可见",
"PRIVATE": "私有(所有者和有权管理员)",
"expanding": "扩大范围需要审核,通过前保持当前范围。可在“我的审核进度”查看或撤回申请。",
"narrowing": "缩小范围立即生效,原先可访问的用户可能无法继续查看或下载。",
"submit": "提交审核",

View file

@ -24,6 +24,8 @@ vi.mock('react-i18next', async () => {
}
})
vi.mock('@/features/skill/skill-visibility-dialog', () => ({ SkillVisibilityDialog: () => createElement('span', null, 'visibility-control') }))
vi.mock('@/features/auth/use-auth', () => ({
useAuth: () => ({ hasRole: (role: string) => role === 'SUPER_ADMIN' && isSuperAdmin }),
}))

View file

@ -63,7 +63,7 @@ function ReviewDetailScreen({
isError: isReviewAttemptsError,
} = useReviewAttempts(taskId)
const isSuiteReview = review?.subjectType === 'SUITE_VERSION'
const isMetadataReview = review?.subjectType === 'SKILL_METADATA'
const isMetadataReview = review?.subjectType === 'SKILL_METADATA' && !review.requestedVisibility
const {
data: reviewSkillDetail,
isLoading: isLoadingReviewSkillDetail,
@ -237,7 +237,7 @@ function ReviewDetailScreen({
<Label className="text-xs text-muted-foreground uppercase tracking-wider">{t('review.version')}</Label>
<p className="font-semibold">
<span className="px-2.5 py-0.5 rounded-full bg-primary/10 text-primary text-sm font-mono">
{isMetadataReview ? t('review.metadataChange') : review.version}
{review.requestedVisibility ? t('skillVisibility.title') : isMetadataReview ? t('review.metadataChange') : review.version}
</span>
</p>
</div>

View file

@ -4,6 +4,7 @@ import { Link, useParams, useNavigate, useRouterState, useSearch } from '@tansta
import { useMutation, useQueryClient } from '@tanstack/react-query'
import { ArrowLeft, ArrowUpCircle, Boxes, ChevronDown, ChevronUp, Clock, Folder, Globe, Lock, RefreshCw, ShieldCheck, Terminal, User, Users } from 'lucide-react'
import { MarkdownRenderer } from '@/features/skill/markdown-renderer'
import { SkillVisibilityDialog } from '@/features/skill/skill-visibility-dialog'
import { SkillAvatar } from '@/features/skill/skill-avatar'
import { SkillAvatarTakedown } from '@/features/skill/skill-avatar-takedown'
import { resolvePackageRelativeLink } from '@/features/skill/package-relative-link'
@ -1495,6 +1496,9 @@ export function SkillDetailPage() {
</div>
</div>
<div className="flex flex-col gap-3 pt-3 border-t border-border/40">
{skill.status === 'ACTIVE' && !skill.hidden && publishedVersion && <SkillVisibilityDialog
namespace={namespace} slug={slug} visibility={skill.visibility} disabled={hasPendingOwnerPreview} />}
{skill.status === 'ARCHIVED' ? (
<Button variant="outline" onClick={() => setUnarchiveConfirmOpen(true)} disabled={unarchiveMutation.isPending}>
{unarchiveMutation.isPending ? t('skillDetail.processing') : t('skillDetail.unarchiveSkill')}