@james_sww/metaform-asset-distribution 0.1.6 → 0.1.7

package/codebase/template/src/workspace/default-workspace.tsx

@@ -1,38 +1,35 @@
-import { useState } from "react";
-
+import { EmptyState } from "../components/common/empty-state";
+import { ApplicationBreadcrumbs, useApplicationLocation } from "../integrations/application-hooks";
+import { useApplicationCapabilities } from "../integrations/application-provider";
 import { RegionSlot } from "../platform/region/region-slot";
-import { RoleWorkspaceShell } from "../layouts/role-workspace-shell";
+import { ApplicationWorkspaceShell } from "../integrations/application-access";
 import { workspaceRouteContract } from "./routes";
 
 export function DefaultWorkspace() {
-  const [routeId, setRouteId] = useState("my-value");
-  const contract = workspaceRouteContract(routeId)!;
+  const { navigation } = useApplicationCapabilities();
+  const location = useApplicationLocation();
+  const contract = workspaceRouteContract(location.target);
   return (
-    <RoleWorkspaceShell
+    <ApplicationWorkspaceShell
       model={{
         productName: "应用工作空间",
         workspaceTitle: "待初始化工作空间",
-        session: { status: "anonymous" },
         themes: [],
-        activeThemeId: routeId,
+        activeThemeId: location.target,
       }}
       commands={{
         onSelectTheme: (id) => {
-          if (workspaceRouteContract(id)) setRouteId(id);
+          navigation.open({ target: id });
         },
       }}
       slots={{
+        breadcrumbs: <ApplicationBreadcrumbs />,
         content: (
-          <div className="workspace-default-page mx-auto w-full max-w-6xl space-y-6">
-            <h1 className="text-xl font-semibold text-foreground">
-              {contract.title}
-            </h1>
-            <p className="text-sm text-muted-foreground">
-              尚未配置应用本体。进入 S7
-              前完成页面映射、业务资产安装和语义区域初始化。
-            </p>
-            <RegionSlot contract={contract} source={{ component: "src/workspace/default-workspace.tsx", contract: "src/workspace/routes.ts" }} />
-          </div>
+          contract ? <RegionSlot
+            contract={contract}
+            source={{ component: "src/workspace/default-workspace.tsx", contract: "src/workspace/routes.ts" }}
+            className="min-h-64"
+          /> : <EmptyState title="页面尚未映射" description="请在当前应用路由中声明此页面的逻辑目标。" />
         ),
       }}
     />

package/codebase/template/src/workspace/routes.ts

@@ -1,3 +1,4 @@
+import type { ApplicationRoute } from "../integrations/application-contract";
 import type { SemanticRegionContract } from "../components/common/semantic-region/contract";
 import { DEFAULT_WORKSPACE_ROUTES } from "../layouts/role-workspace-routes";
 
@@ -8,6 +9,7 @@ const responsibilities: Record<WorkspaceRouteId, string> = {
   "value-panorama":
     "呈现应用覆盖的业务价值及任务关系，具体内容等待应用本体确认。",
   "my-value": "呈现当前角色承担的职责、工作任务与价值贡献。",
+  "my-tasks": "当前角色的任务汇总占位，汇总数据尚未接入。",
   inbox: "汇集当前角色获准处理的待办事项，查询范围与办理动作等待绑定。",
   "enterprise-tasks": "呈现企业任务协作与进展，角色可见范围等待确认。",
 };
@@ -77,3 +79,7 @@ export function workspaceRouteContract(
     },
   };
 }
+
+export const workspaceApplicationRoutes: readonly ApplicationRoute[] = DEFAULT_WORKSPACE_ROUTES.map(
+  (route) => ({ id: route.id, path: `/${route.id}`, title: route.label }),
+);

package/codebase/template/tests/application-identity.test.mjs

@@ -0,0 +1,236 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+const load = () => import('../src/integrations/application-identity.ts');
+const context = () => ({ protocolVersion: 1, session: { status: 'authenticated', user: { id: 'u1', name: '用户' } }, access: { mode: 'runtime', applicationId: 'app-1', releaseId: 'r1', version: 'v1', pages: [{ id: 'p1', name: '工作台', path: '/operator/', roleKey: 'operator' }], permissions: ['task.read'] } });
+const host = (getContext = async () => context()) => ({ MetaFormApp: { identity: { getContext, async signIn() {}, async signOut() {} } } });
+const config = { endpoint: '/identity', signInPath: '/auth/login', signOutPath: '/auth/logout' };
+
+test('SDK 会话、页面与动作检查共享快照，不依赖业务动作声明', async () => {
+  const { createDefaultApplicationAdapters } = await load(); let reads = 0;
+  const adapter = createDefaultApplicationAdapters({ host: host(async () => { reads++; return context(); }) }).identity;
+  const [session, access, allowed, denied] = await Promise.all([adapter.getSession({}), adapter.getAccess({}), adapter.checkAction({ operation: 'task.read' }, {}), adapter.checkAction({ operation: 'task.write' }, {})]);
+  assert.equal(reads, 1); assert.equal(session.user.id, 'u1'); assert.equal(access.applicationId, 'app-1'); assert.equal(allowed.allowed, true); assert.equal(denied.allowed, false);
+});
+
+test('宿主缺少协议禁止 HTTP 回退，未配置明确不可用', async () => {
+  const { createDefaultApplicationAdapters } = await load(); let requests = 0;
+  for (const candidate of [{ MetaFormApp: {} }, { MetaFormApp: { identity: {} } }, {}]) {
+    const adapter = createDefaultApplicationAdapters({ host: candidate, config: candidate.MetaFormApp ? config : null, fetch: async () => { requests++; return Response.json(context()); } }).identity;
+    assert.equal(adapter.availability('session').state, 'unavailable'); await assert.rejects(adapter.getSession({}));
+  }
+  assert.equal(requests, 0);
+});
+
+test('错误协议、缺少发布身份必须拒绝，匿名不能附带权限', async () => {
+  const { createDefaultApplicationAdapters } = await load();
+  for (const value of [{ ...context(), protocolVersion: 2 }, { ...context(), access: { ...context().access, releaseId: undefined } }]) {
+    const adapter = createDefaultApplicationAdapters({ host: host(async () => value) }).identity; await assert.rejects(adapter.getAccess({}));
+  }
+  const anonymous = createDefaultApplicationAdapters({ host: host(async () => ({ ...context(), session: { status: 'anonymous' } })) }).identity;
+  assert.equal((await anonymous.checkAction({ operation: 'task.read' }, {})).allowed, false);
+});
+
+test('正式页面精确匹配入口及角色，空页面和越权深链接不默认放行', async () => {
+  const { canAccessApplicationPage } = await load(); const access = context().access;
+  assert.equal(canAccessApplicationPage(access, '/operator/', 'operator'), true);
+  assert.equal(canAccessApplicationPage(access, '/reviewer/', 'reviewer'), false);
+  assert.equal(canAccessApplicationPage(access, '/operator-evil/', 'operator'), false);
+  assert.equal(canAccessApplicationPage({ ...access, pages: [] }, '/operator/', 'operator'), false);
+});
+
+test('退出清理权限，旧异步回执不能恢复身份，显式登录后允许切换用户', async () => {
+  const { createDefaultApplicationAdapters } = await load(); let finish;
+  let value = new Promise(resolve => { finish = resolve; });
+  const adapter = createDefaultApplicationAdapters({ host: host(() => value) }).identity;
+  const pending = adapter.getSession({}); await adapter.signOut({}); finish(context());
+  await assert.rejects(pending, { name: 'AbortError' });
+  assert.deepEqual(await adapter.getSession({}), { status: 'anonymous' });
+  assert.equal((await adapter.checkAction({ operation: 'task.read' }, {})).allowed, false);
+  value = Promise.resolve({ ...context(), session: { status: 'authenticated', user: { id: 'u2', name: '新用户' } } }); await adapter.signIn({}); adapter.refresh();
+  assert.equal((await adapter.getSession({})).user.id, 'u2');
+});
+
+test('HTTP 同源接入、401 清理和登录保留深链接', async () => {
+  const { createDefaultApplicationAdapters } = await load(); const requests = [], navigations = []; let response = Response.json(context());
+  const adapter = createDefaultApplicationAdapters({ host: {}, config, location: { origin: 'https://app.test', pathname: '/operator/', search: '?a=1', hash: '#/tasks/42' }, navigate: url => navigations.push(url), fetch: async (url, options) => { requests.push({ url, options }); return response; } }).identity;
+  assert.equal((await adapter.getSession({})).status, 'authenticated'); assert.equal(requests[0].options.credentials, 'same-origin');
+  adapter.refresh(); response = new Response('', { status: 401 }); assert.equal((await adapter.getSession({})).status, 'expired');
+  assert.equal((await adapter.checkAction({ operation: 'task.read' }, {})).allowed, false); await adapter.signIn({});
+  const login = new URL(navigations[0], 'https://app.test'); assert.equal(login.pathname, '/auth/login'); assert.equal(login.searchParams.get('return_to'), '/operator/?a=1#/tasks/42');
+  assert.equal(createDefaultApplicationAdapters({ host: {}, config: { ...config, endpoint: 'https://other.test/identity' } }).identity.availability('session').state, 'unavailable');
+});
+
+test('HTTP 退出以 CSRF 同源表单提交并立即清理身份', async () => {
+  const { createDefaultApplicationAdapters } = await load(); const forms = [];
+  const adapter = createDefaultApplicationAdapters({ host: {}, config, fetch: async () => Response.json({ ...context(), csrfToken: 'csrf-test' }), submitForm: (path, fields) => forms.push({ path, fields }) }).identity;
+  await adapter.getSession({}); await adapter.signOut({});
+  assert.deepEqual(forms, [{ path: '/auth/logout', fields: { csrf_token: 'csrf-test' } }]); assert.deepEqual(await adapter.getSession({}), { status: 'anonymous' });
+});
+
+test('Provider 共享身份状态去重并在刷新期间清理旧页面及旧用户', async () => {
+  const { createApplicationIdentityState } = await import('../src/integrations/application-identity-state.ts');
+  let reads = 0, finish;
+  let session = Promise.resolve({ status: 'authenticated', user: { id: 'u1', name: '用户' } });
+  const store = createApplicationIdentityState({ getSession: async () => { reads++; return { status: 'success', data: await session }; }, getAccess: async () => ({ status: 'success', data: context().access }) });
+  await Promise.all([store.load(), store.load()]); assert.equal(reads, 1); assert.equal(store.getSnapshot().session.data.user.id, 'u1');
+  session = new Promise(resolve => { finish = resolve; }); const pending = store.reload();
+  assert.deepEqual(store.getSnapshot(), { session: { status: 'loading' }, access: { status: 'loading' } });
+  finish({ status: 'anonymous' }); await pending;
+  assert.equal(store.getSnapshot().session.data.status, 'anonymous'); assert.equal(store.getSnapshot().access.status, 'unavailable');
+});
+
+test('可信预览允许打造空白模板，HTTP 不接受预览模式，角色菜单仅保留授权入口', async () => {
+  const { createDefaultApplicationAdapters, canAccessApplicationPage, filterApplicationRoleEntries } = await load();
+  const preview = { ...context().access, mode: 'preview', releaseId: undefined, pages: [] };
+  assert.equal(canAccessApplicationPage(preview, '/'), true);
+  const adapter = createDefaultApplicationAdapters({ host: {}, config, fetch: async () => Response.json({ ...context(), access: preview }) }).identity;
+  await assert.rejects(adapter.getAccess({}));
+  assert.deepEqual(filterApplicationRoleEntries(context().access, [{ id: 'operator', label: '操作', href: '/operator/#/my-tasks' }, { id: 'reviewer', label: '复核', href: '/reviewer/' }, { id: 'operator', label: '伪造', href: 'https://evil.test/operator/' }]).map(entry => entry.label), ['操作']);
+});
+
+test('退出失败和权限撤销也不会继续使用缓存授权', async () => {
+  const { createDefaultApplicationAdapters } = await load();
+  const candidate = host(); candidate.MetaFormApp.identity.signOut = async () => { throw new Error('退出失败'); };
+  const adapter = createDefaultApplicationAdapters({ host: candidate }).identity;
+  await adapter.getSession({}); await assert.rejects(adapter.signOut({}));
+  assert.equal((await adapter.checkAction({ operation: 'task.read' }, {})).allowed, false);
+  candidate.MetaFormApp.identity.getContext = async () => ({ ...context(), access: { ...context().access, permissions: [], pages: [] } });
+  await adapter.signIn({}); adapter.refresh();
+  assert.equal((await adapter.getSession({})).status, 'authenticated');
+  assert.equal((await adapter.checkAction({ operation: 'task.read' }, {})).allowed, false);
+});
+
+test('登录旧回执不能在后续退出之后清除匿名缓存', async () => {
+  const { createDefaultApplicationAdapters } = await load(); let finish;
+  const candidate = host(); candidate.MetaFormApp.identity.signIn = () => new Promise(resolve => { finish = resolve; });
+  const adapter = createDefaultApplicationAdapters({ host: candidate }).identity;
+  const login = adapter.signIn({}); await adapter.signOut({}); finish();
+  await assert.rejects(login, { name: 'AbortError' });
+  assert.deepEqual(await adapter.getSession({}), { status: 'anonymous' });
+});
+
+test('业务权限拒绝后失效公共身份缓存，保留原业务检查', async () => {
+  const { createDefaultApplicationAdapters } = await load();
+  const { createApplicationRuntime } = await import('../src/integrations/application-runtime.ts');
+  let value = context(); const adapter = createDefaultApplicationAdapters({ host: host(async () => value) }).identity;
+  const app = createApplicationRuntime({ adapters: { identity: adapter, data: { availability: () => ({ state: 'ready' }), query: async () => { throw Object.assign(new Error('拒绝'), { status: 403 }); } } }, navigation: {}, feedback: {}, confirm: async () => ({ status: 'success', data: undefined }) });
+  assert.equal((await app.identity.checkAction({ operation: 'task.read' })).data.allowed, true);
+  value = { ...context(), access: { ...context().access, permissions: [], pages: [] } };
+  const denied = await app.data.query({ key: 'tasks', operation: 'tasks.list' }); assert.equal(denied.status, 'error');
+  assert.equal((await app.identity.checkAction({ operation: 'task.read' })).data.allowed, false);
+});
+
+test('AoBase canonical 页面与独立角色入口通过稳定 roleKey 求交', async () => {
+  const { canAccessApplicationPage, filterApplicationRoleEntries } = await load();
+  const access = { ...context().access, pages: [{ id: 'p1', name: '操作员', path: '/my-tasks?previewRole=operator', roleKey: 'operator' }] };
+  assert.equal(canAccessApplicationPage(access, '/my-tasks?previewRole=operator', 'operator'), true);
+  assert.equal(canAccessApplicationPage(access, '/my-tasks?previewRole=reviewer', 'reviewer'), false);
+  assert.equal(filterApplicationRoleEntries(access, [{ id: 'operator', label: '操作', href: '/operator/#/my-tasks' }]).length, 1);
+});
+
+for (const outcome of ['success', 'error']) {
+  test(`SDK 退出等待期间刷新不能恢复身份，退出${outcome}后保持无权限`, async () => {
+    const { createDefaultApplicationAdapters } = await load();
+    const { createApplicationRuntime } = await import('../src/integrations/application-runtime.ts');
+    let finish;
+    const candidate = host();
+    candidate.MetaFormApp.identity.signOut = () => new Promise((resolve, reject) => { finish = () => outcome === 'success' ? resolve() : reject(new Error('退出服务失败')); });
+    const adapter = createDefaultApplicationAdapters({ host: candidate }).identity;
+    const app = createApplicationRuntime({ adapters: { identity: adapter }, navigation: {}, feedback: {}, confirm: async () => ({ status: 'success', data: undefined }) });
+    const unsubscribe = app.identity.subscribe(() => {});
+    try {
+      assert.equal((await app.identity.getSession()).data.status, 'authenticated');
+      const pending = app.identity.signOut();
+      app.identity.refresh();
+      const during = await Promise.all([app.identity.getSession(), app.identity.getAccess()]);
+      finish();
+      const result = await pending;
+      assert.equal(result.status, outcome);
+      if (outcome === 'error') assert.equal(result.error.message, '退出服务失败');
+      const session = await app.identity.getSession();
+      const action = await app.identity.checkAction({ operation: 'task.read' });
+      assert.equal(during[0].data.status, 'anonymous');
+      assert.equal(during[1].status, 'unavailable');
+      assert.equal(session.data.status, 'anonymous');
+      assert.equal(action.data.allowed, false);
+      assert.equal(app.identity.getSnapshot().access.status, 'unavailable');
+    } finally { unsubscribe(); }
+  });
+}
+
+test('公共登录在退出进行中明确拒绝，退出完成后允许新用户登录', async () => {
+  const { createDefaultApplicationAdapters } = await load();
+  const { createApplicationRuntime } = await import('../src/integrations/application-runtime.ts');
+  let finishSignOut;
+  let signIns = 0;
+  let value = context();
+  const candidate = host(async () => value);
+  candidate.MetaFormApp.identity.signOut = () => new Promise(resolve => { finishSignOut = resolve; });
+  candidate.MetaFormApp.identity.signIn = async () => { signIns++; value = { ...context(), session: { status: 'authenticated', user: { id: 'u2', name: '新用户' } } }; };
+  const adapter = createDefaultApplicationAdapters({ host: candidate }).identity;
+  const app = createApplicationRuntime({ adapters: { identity: adapter }, navigation: {}, feedback: {}, confirm: async () => ({ status: 'success', data: undefined }) });
+  assert.equal((await app.identity.getSession()).data.user.id, 'u1');
+  const logout = app.identity.signOut();
+  const during = await app.identity.signIn();
+  const callsDuring = signIns;
+  finishSignOut();
+  await logout;
+  assert.equal(during.status, 'unavailable');
+  assert.equal(callsDuring, 0);
+  assert.equal((await app.identity.getSession()).data.status, 'anonymous');
+  assert.equal((await app.identity.signIn()).status, 'success');
+  assert.equal(signIns, 1);
+  assert.equal((await app.identity.getSession()).data.user.id, 'u2');
+});
+
+test('默认适配器也拒绝退出进行中的直接登录调用', async () => {
+  const { createDefaultApplicationAdapters } = await load();
+  let finishSignOut;
+  let signIns = 0;
+  const candidate = host();
+  candidate.MetaFormApp.identity.signOut = () => new Promise(resolve => { finishSignOut = resolve; });
+  candidate.MetaFormApp.identity.signIn = async () => { signIns++; };
+  const adapter = createDefaultApplicationAdapters({ host: candidate }).identity;
+  const logout = adapter.signOut({});
+  let loginError;
+  try { await adapter.signIn({}); } catch (error) { loginError = error; }
+  finishSignOut(); await logout;
+  assert.equal(loginError?.name, 'CapabilityUnavailableError');
+  assert.equal(signIns, 0);
+});
+
+for (const transport of ['SDK', 'HTTP']) {
+  for (const outcome of ['success', 'error']) {
+    test(`${transport} 退出命令立即结束后普通刷新仍锁存匿名，${outcome}不复水合旧授权，显式登录后可恢复`, async () => {
+      const { createDefaultApplicationAdapters } = await load();
+      const { createApplicationRuntime } = await import('../src/integrations/application-runtime.ts');
+      let reads = 0;
+      let value = context();
+      const candidate = host(async () => { reads++; return value; });
+      candidate.MetaFormApp.identity.signOut = async () => { if (outcome === 'error') throw new Error('退出导航失败'); };
+      candidate.MetaFormApp.identity.signIn = async () => { value = { ...context(), session: { status: 'authenticated', user: { id: 'u2', name: '新用户' } } }; };
+      const adapter = createDefaultApplicationAdapters(transport === 'SDK' ? { host: candidate } : {
+        host: {}, config,
+        location: { origin: 'https://app.test', pathname: '/operator/', search: '', hash: '#/my-tasks' },
+        fetch: async () => { reads++; return Response.json({ ...value, csrfToken: 'csrf-test' }); },
+        submitForm: () => { if (outcome === 'error') throw new Error('退出导航失败'); },
+        navigate: () => { value = { ...context(), session: { status: 'authenticated', user: { id: 'u2', name: '新用户' } } }; },
+      }).identity;
+      const app = createApplicationRuntime({ adapters: { identity: adapter }, navigation: {}, feedback: {}, confirm: async () => ({ status: 'success', data: undefined }) });
+      assert.equal((await app.identity.getSession()).data.user.id, 'u1');
+      const result = await app.identity.signOut();
+      assert.equal(result.status, outcome);
+      if (outcome === 'error') assert.equal(result.error.message, '退出导航失败');
+      app.identity.refresh();
+      const [session, access, action] = await Promise.all([app.identity.getSession(), app.identity.getAccess(), app.identity.checkAction({ operation: 'task.read' })]);
+      assert.equal(session.data.status, 'anonymous');
+      assert.equal(access.status, 'unavailable');
+      assert.equal(action.data.allowed, false);
+      assert.equal(reads, 1);
+      assert.equal((await app.identity.signIn()).status, 'success');
+      app.identity.refresh();
+      assert.equal((await app.identity.getSession()).data.user.id, 'u2');
+      assert.equal((await app.identity.checkAction({ operation: 'task.read' })).data.allowed, true);
+    });
+  }
+}

package/codebase/template/tests/semantic-region.test.mjs

@@ -0,0 +1,23 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { validateSemanticRegion } from '../src/components/common/semantic-region/contract.ts';
+
+const emptyRegion = {
+  id: 'focus-empty', pageId: 'task-empty', title: '已存在但未定义的关注项',
+  responsibility: '', sourceRefs: [{ ref: 'urn:example:object:9223372036854775807' }],
+  inputs: [], outputs: [], bindings: [], actions: [], businessStates: [], navigation: [],
+  replacement: { inputs: [], events: [], stateOwner: '' }, questions: [],
+  progress: { design: 'proposed', implementation: 'scaffold', binding: 'pending', verification: 'not-run' },
+};
+
+test('有身份而无业务说明的区域支持显式空定义，仍拒绝缺失或错误类型', () => {
+  assert.equal(validateSemanticRegion(emptyRegion).valid, true);
+  for (const responsibility of [undefined, null, 42]) {
+    assert.equal(validateSemanticRegion({ ...emptyRegion, responsibility }).valid, false);
+  }
+  for (const stateOwner of [undefined, null, 42]) {
+    assert.equal(validateSemanticRegion({ ...emptyRegion, replacement: { ...emptyRegion.replacement, stateOwner } }).valid, false);
+  }
+  assert.equal(validateSemanticRegion({ ...emptyRegion, id: '' }).valid, false);
+  assert.equal(validateSemanticRegion({ ...emptyRegion, bindings: [{ id: 'binding', label: '数据', logicalTarget: '来源', status: 'confirmed' }] }).valid, false);
+});

package/codebase/template/tests/workspace-navigation.test.mjs

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { test } from 'node:test';
 
-import { findNavigationPath, isSelectableNavigationItem, openNavigationBranch } from '../src/layouts/workspace-navigation-model.ts';
+import { findNavigationPath, isSelectableNavigationItem, openNavigationBranch, taskOverviewNavigation } from '../src/layouts/workspace-navigation-model.ts';
 
 const items = [{
   id: 'tasks', label: '任务', availability: 'implemented', children: [{
@@ -36,6 +36,18 @@ const accordionItems = [{
   ],
 }];
 
+test('我的任务有独立汇总入口，主题仍只展开，任务保持可选', () => {
+  const navigation = taskOverviewNavigation(items);
+  assert.equal(navigation.length, 1);
+  assert.equal(navigation[0].id, 'my-tasks');
+  assert.equal(navigation[0].count, undefined);
+  assert.equal(isSelectableNavigationItem(navigation, 'my-tasks'), true);
+  assert.equal(isSelectableNavigationItem(navigation, 'tasks'), false);
+  assert.equal(isSelectableNavigationItem(navigation, 'arrange'), true);
+  assert.deepEqual(findNavigationPath(navigation, 'arrange').map(item => item.id), ['my-tasks', 'tasks', 'prepare', 'arrange']);
+  assert.equal(isSelectableNavigationItem(taskOverviewNavigation([]), 'my-tasks'), true);
+});
+
 test('默认同级互斥：开启兄弟分组时移除旧分组及其子树，保留祖先', () => {
   assert.deepEqual(openNavigationBranch(accordionItems, ['root', 'first', 'first-child'], 'second'), ['root', 'second']);
 });

package/codebase/template/tests/workspace-role-switcher.test.mjs

@@ -0,0 +1,25 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { workspaceRoleOptions } from '../src/layouts/workspace-role-model.ts';
+
+test('角色入口只接受应用提供的内部地址，保持身份与显示名分离', () => {
+  const entries = [
+    { id: 'operator', label: '操作员', href: '/operator/#/my-tasks' },
+    { id: 'reviewer', label: '复核员', href: '/reviewer/#/my-tasks' },
+    { id: 'external', label: '外部', href: 'https://external.invalid/' },
+    { id: 'protocol', label: '协议相对', href: '//external.invalid/' },
+    { id: 'backslash', label: '反斜杠', href: '/\\external.invalid/' },
+    { id: 'script', label: '脚本', href: 'javascript:alert(1)' },
+    { id: 'control', label: '控制字符', href: '/\n/external.invalid/' },
+    { id: 'operator', label: '重复身份', href: '/duplicate/' },
+  ];
+  const result = workspaceRoleOptions(entries, 'reviewer');
+  assert.deepEqual(result.entries.map(entry => entry.id), ['operator', 'reviewer']);
+  assert.equal(result.current?.label, '复核员');
+  assert.equal(result.current?.href, '/reviewer/#/my-tasks');
+});
+
+test('没有角色列表或当前身份不在列表中时，不假定默认角色', () => {
+  assert.deepEqual(workspaceRoleOptions([], 'unknown'), { entries: [], current: undefined });
+  assert.equal(workspaceRoleOptions([{ id: 'operator', label: '操作员', href: '/operator/' }], 'unknown').current, undefined);
+});

package/codebase/template/tests/workspace-sidebar-resize.test.mjs

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { sidebarSizing, sidebarWidthForKey } from '../src/layouts/workspace-sidebar-model.ts';
+
+test('菜单默认宽度与上下限稳定，为内容区保留最小空间', () => {
+  assert.deepEqual(sidebarSizing(undefined, 1200), { width: 224, min: 200, max: 420 });
+  assert.equal(sidebarSizing(100, 1200).width, 200);
+  assert.equal(sidebarSizing(999, 1200).width, 420);
+  assert.deepEqual(sidebarSizing(400, 768), { width: 376, min: 200, max: 376 });
+  assert.equal(sidebarSizing(400, 500).width, 200);
+  assert.equal(sidebarSizing(NaN, 1200).width, 224);
+  assert.equal(sidebarSizing(Infinity, 1200).width, 224);
+  assert.equal(sidebarSizing(300, 0).width, 300);
+});
+
+test('键盘调整遵守容器边界，普通按键不接管', () => {
+  assert.equal(sidebarWidthForKey('ArrowRight', 224, 1200), 240);
+  assert.equal(sidebarWidthForKey('ArrowLeft', 200, 1200), 200);
+  assert.equal(sidebarWidthForKey('Home', 300, 1200), 200);
+  assert.equal(sidebarWidthForKey('End', 224, 768), 376);
+  assert.equal(sidebarWidthForKey('Tab', 224, 1200), undefined);
+});

package/dist/apply.js

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { cp, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
 import { basename, dirname } from 'node:path';
 import { DistributionError } from './contracts.js';
 import { commitStagedFiles, listRetainedBackups, recoverTransaction, withInstallLock, } from './install-transaction.js';
@@ -24,10 +24,19 @@ export async function applyPlan(input) {
         const stage = await mkdtemp(prefix + '-stage-');
         let committing = false;
         try {
-            await cp(root, stage, {
-                recursive: true,
-                filter: (path) => path === root || !['node_modules', '.git', 'dist', '.vite'].includes(basename(path)),
-            });
+            const excluded = new Set(['node_modules', '.git', 'dist', '.vite', '.metaform-install']);
+            if (process.env.METAFORM_ASSETS_PROJECT_MODE === '1') {
+                for (const path of Object.keys(before)) {
+                    const target = validateTargetPath(stage, path);
+                    await mkdir(dirname(target), { recursive: true });
+                    await writeFile(target, await readFile(validateTargetPath(root, path)), { mode: 0o644 });
+                }
+            }
+            else
+                await cp(root, stage, {
+                    recursive: true,
+                    filter: (path) => path === root || !excluded.has(basename(path)),
+                });
             for (const change of plan.changes) {
                 const bytes = Buffer.from(change.after.contentBase64, 'base64');
                 if (change.path !== change.after.targetPath ||

package/dist/cli.js

@@ -9,14 +9,18 @@ import { runOfficialAdd } from './official.js';
 import { planAdd } from './planner.js';
 import { planPrepare } from './prepare.js';
 import { baseline, projectDigest, readLock, reconcileProject } from './provenance.js';
+import { readRegistryInput } from './installation-release.js';
+import { selectedRelease } from './selected-release.js';
 import { assetClosure } from './publish.js';
 import { initProject } from './template.js';
 import { validateRelease, validateTargetPath } from './validate.js';
 async function loadRegistry(location) {
+    if (!location && process.env.METAFORM_ASSETS_PROJECT_MODE === '1')
+        throw new DistributionError('selected_registry_required');
     if (!location)
         return validateRelease(JSON.parse(await readFile(fileURLToPath(new URL('../registry/release.json', import.meta.url)), 'utf8')));
     if (!/^https?:/.test(location))
-        return validateRelease(JSON.parse(await readFile(resolve(location), 'utf8')));
+        return readRegistryInput(JSON.parse(await readFile(resolve(location), 'utf8')));
     const url = new URL(location);
     if (url.protocol !== 'https:' && !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
         throw new DistributionError('registry_requires_https');
@@ -39,7 +43,7 @@ async function loadRegistry(location) {
         }
         chunks.push(value);
     }
-    return validateRelease(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+    return readRegistryInput(JSON.parse(Buffer.concat(chunks).toString('utf8')));
 }
 export async function runCLI(argv, io) {
     try {
@@ -79,6 +83,7 @@ export async function runCLI(argv, io) {
                     'prepare --plan <file>',
                     'search <query>',
                     'inspect <id>',
+                    'export <id#variant> (selected release JSON)',
                     'plan add <id[@version]>',
                     'add <id[@version]>',
                     'add --plan <file>',
@@ -147,7 +152,12 @@ export async function runCLI(argv, io) {
             const release = await loadRegistry(options.get('registry'));
             if (options.has('expect-digest') && options.get('expect-digest') !== release.digest)
                 throw new DistributionError('release_digest_mismatch');
-            if (cmd === 'search') {
+            if (cmd === 'export') {
+                if (!words.length)
+                    throw new DistributionError('assets_required');
+                output = selectedRelease(release, words.map(id => { const item = selectInstallItem(release, id, options.get('variant')); return { id: item.assetId, version: item.version }; }));
+            }
+            else if (cmd === 'search') {
                 const query = words.join(' ').toLocaleLowerCase().trim();
                 const match = (record) => record.maturity !== 'deprecated' &&
                     (!query || JSON.stringify(record).toLocaleLowerCase().includes(query));

package/dist/commands.js

@@ -19,5 +19,8 @@ export async function command(program, args, cwd) {
     });
 }
 export async function installDependencies(root) {
-    await command('corepack', ['pnpm', 'install', '--ignore-scripts'], root);
+    if (process.env.METAFORM_ASSETS_PROJECT_MODE === '1')
+        await command('pnpm', ['install', '--ignore-scripts', '--no-frozen-lockfile', '--store-dir', '/tmp/metaform-pnpm-store'], root);
+    else
+        await command('corepack', ['pnpm', 'install', '--ignore-scripts', '--no-frozen-lockfile'], root);
 }

package/dist/contracts.d.ts

@@ -54,6 +54,7 @@ export type RegistryRelease = {
     id: string;
     version: string;
     sourceCommit: string;
+    upstreamReleaseDigest?: string;
     sourceBaseline?: {
         sourcesDigest: string;
         contentDigest: string;
@@ -87,6 +88,7 @@ export type CatalogSnapshot = {
 };
 export type InstalledAsset = AssetRef & {
     releaseDigest: string;
+    upstreamReleaseDigest?: string;
     files: Record<string, string>;
     installation?: InstallationInfo;
 };

package/dist/install-transaction.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { constants, lstatSync, realpathSync } from 'node:fs';
+import { constants, lstatSync, mkdirSync, realpathSync } from 'node:fs';
 import { copyFile, link, lstat, mkdir, open, readFile, readdir, rename, rm, rmdir, writeFile, } from 'node:fs/promises';
 import { basename, dirname, join, resolve } from 'node:path';
 import lockfile from 'proper-lockfile';
@@ -11,7 +11,21 @@ export function transactionPaths(root) {
     if (lstatSync(root).isSymbolicLink())
         throw new DistributionError('symlink', [root]);
     root = realpathSync(root);
-    const prefix = join(dirname(root), '.' + basename(root) + '.metaform-install');
+    let prefix = join(dirname(root), '.' + basename(root) + '.metaform-install');
+    if (process.env.METAFORM_ASSETS_PROJECT_MODE === '1') {
+        const scratch = join(root, '.metaform-install');
+        try {
+            mkdirSync(scratch, { mode: 0o755 });
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+        const info = lstatSync(scratch);
+        if (!info.isDirectory() || info.isSymbolicLink())
+            throw new DistributionError('unsafe_transaction_directory', [scratch]);
+        prefix = join(scratch, 'transaction');
+    }
     return { root, prefix, journal: prefix + '.json' };
 }
 async function optionalStat(path) {
@@ -107,7 +121,7 @@ async function readJournal(root) {
         j.root !== loc.root ||
         typeof j.stage !== 'string' ||
         !j.stage.startsWith(loc.prefix + '-stage-') ||
-        dirname(j.stage) !== dirname(loc.root) ||
+        dirname(j.stage) !== dirname(loc.prefix) ||
         j.backup !== j.stage + '-backup' ||
         !Array.isArray(j.files) ||
         j.files.length > 10000 ||
@@ -263,13 +277,13 @@ export async function recoverTransaction(root) {
 }
 export async function listRetainedBackups(root) {
     const loc = transactionPaths(root), receipts = [];
-    for (const name of await readdir(dirname(loc.root))) {
+    for (const name of await readdir(dirname(loc.prefix))) {
         if (!name.startsWith(basename(loc.prefix) + '-stage-') || !name.endsWith('.receipt.json'))
             continue;
-        const receipt = JSON.parse(await readFile(join(dirname(loc.root), name), 'utf8'));
+        const receipt = JSON.parse(await readFile(join(dirname(loc.prefix), name), 'utf8'));
         if (receipt.projectRoot !== loc.root ||
             typeof receipt.retainedBackup !== 'string' ||
-            dirname(receipt.retainedBackup) !== dirname(loc.root) ||
+            dirname(receipt.retainedBackup) !== dirname(loc.prefix) ||
             !receipt.retainedBackup.startsWith(loc.prefix + '-stage-') ||
             !receipt.retainedBackup.endsWith('-backup'))
             throw new DistributionError('invalid_receipt');

package/dist/installation-release.d.ts

@@ -0,0 +1,33 @@
+import { type RegistryRelease } from './contracts.js';
+type ResourceSelection = {
+    id: string;
+    variant: string;
+    metadata?: Record<string, unknown>;
+};
+export declare function createInstallationRelease(value: unknown, assets: ResourceSelection[]): {
+    status: "unavailable";
+    reason: string;
+    format?: undefined;
+    cliPackage?: undefined;
+    minimumCliVersion?: undefined;
+    expectedDigest?: undefined;
+    release?: undefined;
+} | {
+    status: "reference-only";
+    reason: string;
+    format?: undefined;
+    cliPackage?: undefined;
+    minimumCliVersion?: undefined;
+    expectedDigest?: undefined;
+    release?: undefined;
+} | {
+    status: "available";
+    format: "metaform-cli-release-v1";
+    cliPackage: string;
+    minimumCliVersion: string;
+    expectedDigest: string;
+    release: RegistryRelease;
+    reason?: undefined;
+};
+export declare function readRegistryInput(value: unknown, depth?: number): RegistryRelease;
+export {};