@james_sww/metaform-asset-distribution 0.1.6 → 0.1.7

package/codebase/template/src/integrations/application-runtime.ts

@@ -0,0 +1,159 @@
+import type {
+  ApplicationAdapters, ApplicationCapabilities, ApplicationNavigation, AttachmentAccess,
+  AttachmentReference, CapabilityAvailability, CapabilityName, CommandReceipt,
+  QueryResponse, RequestOptions,
+} from './application-contract';
+import type { ToastContextValue } from '../contexts/toast-context';
+import { createApplicationIdentityState } from './application-identity-state.ts';
+import { notBound, ready, runCapability } from './capability-result.ts';
+
+function receipt<T>(value: CommandReceipt<T>): CommandReceipt<T> {
+  if (!value || !['succeeded', 'accepted', 'pending'].includes(value.status)) {
+    throw Object.assign(new Error('服务没有返回可确认的执行回执，请先查询处理结果。'), { code: 'invalid_receipt', outcomeUnknown: true });
+  }
+  return value;
+}
+function access(value: AttachmentAccess): AttachmentAccess {
+  if (!value || typeof value.url !== 'string' || !/^(https?:\/\/|blob:|\/(?!\/))/.test(value.url)) {
+    throw new Error('附件服务未返回有效的预览或下载地址。');
+  }
+  return value;
+}
+function selectedFiles(request: { accept?: string; multiple?: boolean }, options: RequestOptions): Promise<readonly File[]> {
+  return new Promise((resolve, reject) => {
+    const input = document.createElement('input');
+    input.type = 'file'; input.accept = request.accept ?? ''; input.multiple = request.multiple ?? false;
+    input.hidden = true;
+    const cleanup = () => { input.remove(); options.signal?.removeEventListener('abort', abort); };
+    const abort = () => { cleanup(); reject(new DOMException('文件选择已取消。', 'AbortError')); };
+    input.onchange = () => { const files = Array.from(input.files ?? []); cleanup(); if (files.length) resolve(files); else abort(); };
+    input.addEventListener('cancel', abort, { once: true });
+    options.signal?.addEventListener('abort', abort, { once: true });
+    document.body.append(input);
+    if (options.signal?.aborted) abort();
+    else { try { input.click(); } catch (error) { cleanup(); reject(error); } }
+  });
+}
+
+export function createApplicationRuntime(options: {
+  adapters: ApplicationAdapters;
+  navigation: ApplicationNavigation;
+  feedback: ToastContextValue;
+  confirm: ApplicationCapabilities['confirm'];
+}): ApplicationCapabilities {
+  const { adapters, navigation, feedback, confirm } = options;
+  const queries = new Map<string, Set<() => void>>();
+  function availability(capability: CapabilityName, operation = ''): CapabilityAvailability {
+    try {
+      if (['navigation', 'notification', 'confirmation'].includes(capability)) return ready;
+      if (capability === 'attachment.select') return typeof document === 'undefined' ? notBound('当前环境不能选择本地文件。') : ready;
+      if (capability === 'query' || capability === 'command') {
+        const method = capability === 'query' ? adapters.data?.query : adapters.data?.execute;
+        return method ? adapters.data!.availability(capability, operation) : notBound(`尚未绑定${capability === 'query' ? '数据查询' : '业务提交'}服务。`);
+      }
+      if (['session', 'permission', 'access', 'signIn', 'signOut'].includes(capability)) {
+        const operation = capability as 'session' | 'permission' | 'access' | 'signIn' | 'signOut';
+        const method = operation === 'session' ? adapters.identity?.getSession : operation === 'permission' ? adapters.identity?.checkAction : operation === 'access' ? adapters.identity?.getAccess : adapters.identity?.[operation];
+        return method ? adapters.identity!.availability(operation) : notBound(`尚未绑定${capability === 'session' ? '身份会话' : '动作权限'}服务。`);
+      }
+      if (capability.startsWith('attachment.')) {
+        const method = capability.slice('attachment.'.length) as 'upload' | 'link' | 'preview' | 'download';
+        return adapters.attachments?.[method] ? adapters.attachments.availability(method) : notBound('附件存储服务尚未接入；选择文件不代表已上传。');
+      }
+      if (capability.startsWith('extension.')) return adapters.extensions?.[capability.slice('extension.'.length)]?.availability(operation) ?? notBound('此扩展尚未绑定真实服务。');
+      return notBound();
+    } catch (error) { return { state: 'error', reason: error instanceof Error ? error.message : '无法读取能力状态。' }; }
+  }
+  const identityReader = {
+    getSession: (requestOptions: RequestOptions = {}) => runCapability(availability('session'), () => adapters.identity!.getSession!(requestOptions), requestOptions),
+    getAccess: (requestOptions: RequestOptions = {}) => runCapability(availability('access'), () => adapters.identity!.getAccess!(requestOptions), requestOptions),
+  };
+  const identityState = createApplicationIdentityState(identityReader);
+  async function withIdentityInvalidation<T>(execute: () => Promise<T>): Promise<T> {
+    try { return await execute(); }
+    catch (error) {
+      const detail = error as { status?: number; code?: string } | null;
+      if (detail?.status === 401 || detail?.status === 403 || detail?.code === 'unauthorized' || detail?.code === 'forbidden') {
+        adapters.identity?.refresh?.(); void identityState.reload();
+      }
+      throw error;
+    }
+  }
+  let identitySubscribers = 0;
+  let unsubscribeIdentity: (() => void) | undefined;
+  const runtime: ApplicationCapabilities = {
+    protocolVersion: 1, navigation, feedback, confirm, availability,
+    subscribeAvailability(capability, listener) {
+      const adapter = capability === 'query' || capability === 'command' ? adapters.data
+        : ['session', 'permission', 'access', 'signIn', 'signOut'].includes(capability) ? adapters.identity
+          : capability.startsWith('attachment.') ? adapters.attachments
+            : capability.startsWith('extension.') ? adapters.extensions?.[capability.slice('extension.'.length)] : undefined;
+      return adapter?.subscribe?.(listener) ?? (() => {});
+    },
+    data: {
+      query: <T,>(request: Parameters<ApplicationCapabilities['data']['query']>[0], requestOptions = {}) =>
+        runCapability(availability('query', request.operation), async () => {
+          const value = await withIdentityInvalidation(() => adapters.data!.query!<T>(request, requestOptions));
+          if (!value || !Object.hasOwn(value, 'data')) throw new Error('查询服务没有返回有效数据。');
+          return value as QueryResponse<T>;
+        }, requestOptions),
+      async execute<T>(request: Parameters<ApplicationCapabilities['data']['execute']>[0], requestOptions = {}) {
+        const status = availability('command', request.operation);
+        if (status.state !== 'ready') return { status: 'unavailable', reason: status.reason };
+        if (request.confirm) {
+          const decision = await confirm(request.confirm, requestOptions);
+          if (decision.status !== 'success') return decision;
+        }
+        const result = await runCapability(status, async () => receipt(await withIdentityInvalidation(() => adapters.data!.execute!<T>(request, requestOptions))), requestOptions, true);
+        if (result.status === 'success' && result.data.status === 'succeeded') {
+          runtime.data.refresh([...new Set([...(request.refresh ?? []), ...(result.data.refresh ?? [])])]);
+        }
+        return result;
+      },
+      refresh(keys) { for (const key of new Set(keys)) for (const listener of queries.get(key) ?? []) listener(); },
+      subscribe(key, listener) {
+        const listeners = queries.get(key) ?? new Set<() => void>();
+        queries.set(key, listeners); listeners.add(listener);
+        return () => { listeners.delete(listener); if (!listeners.size) queries.delete(key); };
+      },
+    },
+    identity: {
+      ...identityReader,
+      getSnapshot: identityState.getSnapshot,
+      subscribe(listener) {
+        if (identitySubscribers++ === 0) unsubscribeIdentity = adapters.identity?.subscribe?.(() => { void identityState.reload(); });
+        const unsubscribe = identityState.subscribe(listener);
+        return () => { unsubscribe(); if (--identitySubscribers === 0) { unsubscribeIdentity?.(); unsubscribeIdentity = undefined; } };
+      },
+      refresh() { adapters.identity?.refresh?.(); void identityState.reload(); },
+      async signIn(requestOptions = {}) {
+        const result = await runCapability(availability('signIn'), () => adapters.identity!.signIn!(requestOptions), requestOptions, true);
+        void identityState.reload(); return result;
+      },
+      async signOut(requestOptions = {}) {
+        const result = await runCapability(availability('signOut'), () => adapters.identity!.signOut!(requestOptions), requestOptions, true);
+        void identityState.reload(); return result;
+      },
+      checkAction: (request, requestOptions = {}) => runCapability(availability('permission', request.operation), () => adapters.identity!.checkAction!(request, requestOptions), requestOptions),
+    },
+    attachments: {
+      select: (request = {}, requestOptions = {}) => runCapability(availability('attachment.select'), () => selectedFiles(request, requestOptions), requestOptions),
+      upload: (request, requestOptions = {}) => runCapability(availability('attachment.upload'), async () => {
+        const value: AttachmentReference = await adapters.attachments!.upload!(request, requestOptions);
+        if (!value || typeof value.id !== 'string' || !value.id.trim()) throw Object.assign(new Error('存储服务没有返回附件标识，不能视为已上传。'), { outcomeUnknown: true });
+        return value;
+      }, requestOptions, true),
+      link: (request, requestOptions = {}) => runCapability(availability('attachment.link'), async () => receipt(await adapters.attachments!.link!(request, requestOptions)), requestOptions, true),
+      preview: (attachment, requestOptions = {}) => runCapability(availability('attachment.preview'), async () => access(await adapters.attachments!.preview!(attachment, requestOptions)), requestOptions),
+      download: (attachment, requestOptions = {}) => runCapability(availability('attachment.download'), async () => access(await adapters.attachments!.download!(attachment, requestOptions)), requestOptions),
+    },
+    extensions: {
+      invoke: <T,>(name: string, request: Parameters<ApplicationCapabilities['extensions']['invoke']>[1], requestOptions = {}) =>
+        runCapability(availability(`extension.${name}`, request.operation), async () => ({
+          value: await adapters.extensions![name].invoke<T>(request, requestOptions),
+          connection: availability(`extension.${name}`, request.operation),
+        }), requestOptions, true),
+    },
+  };
+  return runtime;
+}

package/codebase/template/src/integrations/application.ts

@@ -0,0 +1,25 @@
+export { ApplicationProvider, useApplicationCapabilities } from './application-provider';
+export {
+  ApplicationBreadcrumbs, useApplicationLocation, useCapabilityAvailability,
+  useApplicationQuery, useApplicationCommand, useApplicationSession, useApplicationAccess, useApplicationAuth, useActionAvailability,
+} from './application-hooks';
+export type { CapabilityRequestState } from './application-hooks';
+export type {
+  ApplicationAdapters, ApplicationCapabilities, ApplicationRoute, ApplicationNavigation,
+  ApplicationAccess, ApplicationIdentityContext, ApplicationIdentitySDK, ApplicationIdentityState, IdentityRequestState,
+  NavigationTarget, NavigationLocation, NavigationBreadcrumb, ReturnPoint,
+  BusinessContext, ObjectReference, VersionedObjectReference, JsonValue, JsonObject,
+  CapabilityName, CapabilityAvailability, CapabilityResult, RequestOptions,
+  QueryRequest, QueryResponse, CommandRequest, CommandReceipt, ConfirmationRequest,
+  ActionRequest, ActionAvailability, DataAdapter, IdentityAdapter, AttachmentAdapter,
+  AttachmentReference, AttachmentAccess, ExtensionAdapter, ExtensionRequest,
+} from './application-contract';
+export { createHttpPlatformIntegration, createPlatformDataAdapter, createPlatformIdentityAdapter } from './platform';
+export type { PlatformIntegration } from './platform';
+export { createPlatformSDKDataAdapter } from './platform-data-adapter';
+export type { PlatformApplicationSDK } from './platform-data-adapter';
+export { CapabilityUnavailableError } from './capability-result';
+
+export { createDefaultApplicationAdapters, canAccessApplicationPage, filterApplicationRoleEntries } from './application-identity';
+export type { ApplicationIdentityConfiguration, DefaultApplicationAdapterOptions } from './application-identity';
+export { ApplicationSignIn, ApplicationAccessGuard, ApplicationAccountMenu, ApplicationWorkspaceShell } from './application-access';

package/codebase/template/src/integrations/capability-result.ts

@@ -0,0 +1,43 @@
+import type { CapabilityAvailability, CapabilityResult, RequestOptions } from './application-contract';
+
+export const ready: CapabilityAvailability = { state: 'ready' };
+export const notBound = (reason = '此能力尚未接入实际服务。'): CapabilityAvailability => ({ state: 'unavailable', reason });
+export const cancelled = (outcomeUnknown = false): CapabilityResult<never> => ({ status: 'cancelled', reason: '操作已取消。', outcomeUnknown });
+
+export class CapabilityUnavailableError extends Error {
+  constructor(message: string) { super(message); this.name = 'CapabilityUnavailableError'; }
+}
+
+export async function runCapability<T>(
+  availability: CapabilityAvailability,
+  operation: () => Promise<T>,
+  options: RequestOptions = {},
+  write = false,
+): Promise<CapabilityResult<T>> {
+  if (options.signal?.aborted) return cancelled();
+  if (availability.state !== 'ready') return { status: 'unavailable', reason: availability.reason };
+  let abort: (() => void) | undefined;
+  try {
+    const work = operation();
+    const data = options.signal ? await Promise.race([
+      work,
+      new Promise<never>((_, reject) => {
+        abort = () => reject(new DOMException('操作已取消。', 'AbortError'));
+        options.signal!.addEventListener('abort', abort, { once: true });
+        if (options.signal!.aborted) abort();
+      }),
+    ]) : await work;
+    return { status: 'success', data };
+  } catch (error) {
+    if (error instanceof CapabilityUnavailableError) return { status: 'unavailable', reason: error.message };
+    const detail = error as { code?: string; message?: string; name?: string; status?: number; outcomeUnknown?: boolean } | null;
+    const knownRejection = typeof detail?.status === 'number' && detail.status >= 400 && detail.status < 500 && detail.status !== 408;
+    const outcomeUnknown = detail?.outcomeUnknown ?? (write && !knownRejection);
+    if (options.signal?.aborted || detail?.name === 'AbortError') return cancelled(outcomeUnknown);
+    return { status: 'error', error: {
+      code: detail?.code ?? 'request_failed', message: detail?.message || '请求失败，请检查服务状态。', outcomeUnknown,
+    } };
+  } finally {
+    if (abort) options.signal?.removeEventListener('abort', abort);
+  }
+}

package/codebase/template/src/integrations/platform-data-adapter.ts

@@ -0,0 +1,65 @@
+import type { CapabilityResult, CommandReceipt, CommandRequest, DataAdapter, JsonObject, QueryRequest, QueryResponse, RequestOptions } from './application-contract';
+import { CapabilityUnavailableError, notBound, ready, runCapability } from './capability-result';
+
+export interface PlatformApplicationSDK {
+  context(): Promise<unknown>;
+  callAction(action: string, payload?: Record<string, unknown>, options?: { idempotencyKey?: string }): Promise<unknown>;
+}
+type QueryBinding = { action: string; payload?(request: QueryRequest): JsonObject; decode(value: unknown): QueryResponse<unknown> };
+type CommandBinding = { action: string; payload?(request: CommandRequest): JsonObject; decode(value: unknown): CommandReceipt };
+
+export function createPlatformSDKDataAdapter(options: {
+  getSDK(): PlatformApplicationSDK | undefined;
+  queries?: Readonly<Record<string, QueryBinding>>;
+  commands?: Readonly<Record<string, CommandBinding>>;
+}): DataAdapter & { connect(options?: RequestOptions): Promise<CapabilityResult<void>>; disconnect(): void } {
+  const listeners = new Set<() => void>();
+  let sdk: PlatformApplicationSDK | undefined;
+  let actions: Record<string, { kind: string }> = {};
+  let connecting = false;
+  let connectionError = '';
+  const publish = () => { for (const listener of listeners) listener(); };
+  const payload = (value: unknown): JsonObject => JSON.parse(JSON.stringify(value)) as JsonObject;
+  return {
+    availability(kind, operation) {
+      if (connecting) return { state: 'connecting', reason: '正在读取宿主声明的数据动作。' };
+      if (connectionError) return { state: 'error', reason: connectionError };
+      if (!sdk || options.getSDK() !== sdk) return notBound('尚未连接实际应用宿主。');
+      const bindings = kind === 'query' ? options.queries : options.commands;
+      const selected = operation ? bindings?.[operation] : Object.values(bindings ?? {})[0];
+      if (!selected || !actions[selected.action]) return notBound('当前应用没有完成此逻辑操作到宿主动作的映射。');
+      if (kind === 'query' && !['list', 'get', 'compute'].includes(actions[selected.action].kind)) return notBound('写动作不能作为只读查询调用。');
+      return ready;
+    },
+    subscribe(listener) { listeners.add(listener); return () => { listeners.delete(listener); }; },
+    async connect(requestOptions = {}) {
+      if (connecting) return { status: 'unavailable', reason: '宿主连接正在处理中。' };
+      const candidate = options.getSDK();
+      if (!candidate) return { status: 'unavailable', reason: '当前页面没有提供 MetaFormApp 数据桥。' };
+      connecting = true; connectionError = ''; publish();
+      const result = await runCapability(ready, async () => {
+        const context = await candidate.context() as { binding?: { actions?: Record<string, { kind: string }> } };
+        if (!context?.binding?.actions || typeof context.binding.actions !== 'object') throw new Error('宿主未返回可验证的数据动作声明。');
+        return context.binding.actions;
+      }, requestOptions);
+      connecting = false;
+      if (result.status === 'success') { sdk = candidate; actions = result.data; }
+      else { sdk = undefined; actions = {}; connectionError = result.status === 'error' ? result.error.message : ''; }
+      publish();
+      return result.status === 'success' ? { status: 'success', data: undefined } : result;
+    },
+    disconnect() { sdk = undefined; actions = {}; connectionError = ''; publish(); },
+    async query<T>(request: QueryRequest) {
+      const binding = options.queries?.[request.operation];
+      if (!sdk || !binding) throw new CapabilityUnavailableError('查询动作尚未映射。');
+      const result = await sdk.callAction(binding.action, binding.payload?.(request) ?? payload({ object: request.object, conditions: request.conditions, page: request.page, sort: request.sort, context: request.context }));
+      return binding.decode(result) as QueryResponse<T>;
+    },
+    async execute<T>(request: CommandRequest) {
+      const binding = options.commands?.[request.operation];
+      if (!sdk || !binding) throw new CapabilityUnavailableError('提交动作尚未映射。');
+      const result = await sdk.callAction(binding.action, binding.payload?.(request) ?? payload({ object: request.object, input: request.input, context: request.context }), { idempotencyKey: request.idempotencyKey });
+      return binding.decode(result) as CommandReceipt<T>;
+    },
+  };
+}

package/codebase/template/src/integrations/platform.ts

@@ -1,70 +1,52 @@
-import { httpClient } from '../lib/http-client';
+import { HttpClient, httpClient } from '../lib/http-client';
+import type { CommandReceipt, DataAdapter, IdentityAdapter, RequestOptions } from './application-contract';
+import { CapabilityUnavailableError } from './capability-result';
 
-/**
- * 平台集成接口
- * 提供统一的认证、查询和操作能力
- */
 export interface PlatformIntegration {
-  getSession(): Promise<{ actorId: string } | null>;
-  query<T>(operation: string, input: unknown): Promise<T>;
-  execute<T>(operation: string, input: unknown): Promise<T>;
+  getSession(options?: RequestOptions): Promise<{ actorId: string; name?: string } | null>;
+  query<T>(operation: string, input: unknown, options?: RequestOptions): Promise<T>;
+  execute<T>(operation: string, input: unknown, options?: RequestOptions): Promise<T>;
 }
 
-/**
- * 默认平台集成实现
- * 使用 HTTP 客户端与后端通信
- */
-class DefaultPlatformIntegration implements PlatformIntegration {
-  async getSession(): Promise<{ actorId: string } | null> {
-    try {
-      const response = await httpClient.get<{ actorId: string }>('/auth/session');
+export function createHttpPlatformIntegration(options: {
+  endpoints: { session: string; query: string; execute: string };
+  client?: HttpClient;
+}): PlatformIntegration {
+  const client = options.client ?? httpClient;
+  return {
+    async getSession(request = {}) {
+      const response = await client.get<{ actorId: string; name?: string } | null>(options.endpoints.session, undefined, request);
+      if (response.data !== null && (!response.data || typeof response.data.actorId !== 'string')) throw new Error('身份服务返回了无效的会话数据。');
       return response.data;
-    } catch (error) {
-      console.warn('Failed to get session:', error);
-      return null;
-    }
-  }
-
-  async query<T>(operation: string, input: unknown): Promise<T> {
-    const response = await httpClient.post<T>('/query', {
-      operation,
-      input,
-    });
-    return response.data;
-  }
-
-  async execute<T>(operation: string, input: unknown): Promise<T> {
-    const response = await httpClient.post<T>('/execute', {
-      operation,
-      input,
-    });
-    return response.data;
-  }
+    },
+    async query<T>(operation: string, input: unknown, request: RequestOptions = {}) {
+      return (await client.post<T>(options.endpoints.query, { operation, input }, request)).data;
+    },
+    async execute<T>(operation: string, input: unknown, request: RequestOptions = {}) {
+      return (await client.post<T>(options.endpoints.execute, { operation, input }, request)).data;
+    },
+  };
 }
 
-/**
- * Mock 平台集成(用于开发和测试)
- */
-class MockPlatformIntegration implements PlatformIntegration {
-  async getSession(): Promise<{ actorId: string } | null> {
-    // 模拟已登录用户
-    return { actorId: 'mock-user-001' };
-  }
-
-  async query<T>(operation: string, input: unknown): Promise<T> {
-    console.log('[Mock Query]', operation, input);
-    // 返回模拟数据
-    return {} as T;
-  }
+export function createPlatformDataAdapter(integration: PlatformIntegration, availability: DataAdapter['availability']): DataAdapter {
+  return {
+    availability,
+    query: (request, options) => integration.query(request.operation, request, options),
+    execute: <T,>(request: Parameters<NonNullable<DataAdapter['execute']>>[0], options: RequestOptions) =>
+      integration.execute<CommandReceipt<T>>(request.operation, { object: request.object, input: request.input, context: request.context, idempotencyKey: request.idempotencyKey }, options),
+  };
+}
 
-  async execute<T>(operation: string, input: unknown): Promise<T> {
-    console.log('[Mock Execute]', operation, input);
-    return {} as T;
-  }
+export function createPlatformIdentityAdapter(integration: PlatformIntegration, availability: IdentityAdapter['availability']): IdentityAdapter {
+  return {
+    availability,
+    async getSession(options) {
+      const session = await integration.getSession(options);
+      return session ? { status: 'authenticated', user: { id: session.actorId, name: session.name ?? session.actorId } } : { status: 'anonymous' };
+    },
+  };
 }
 
-// 根据环境变量选择实现
-const useMock = (import.meta as { env?: { VITE_USE_MOCK_API?: string } }).env?.VITE_USE_MOCK_API === 'true';
-export const platform: PlatformIntegration = useMock
-  ? new MockPlatformIntegration()
-  : new DefaultPlatformIntegration();
+// 保留旧入口的类型兼容；未配置真实服务时不能返回 mock 成功。
+const unbound = async (): Promise<never> => { throw new CapabilityUnavailableError('平台服务尚未绑定，请在 ApplicationProvider 中配置实际适配器。'); };
+export const platform: PlatformIntegration = { getSession: unbound, query: unbound, execute: unbound };

package/codebase/template/src/layouts/role-workspace-account.tsx

@@ -41,6 +41,8 @@ export function WorkspaceAccount({
   menu?: ReactNode;
 }) {
   const session = model.session;
+  if (session?.status === 'unavailable')
+    return <span data-session-status="unavailable" className="text-xs text-muted-foreground" title={session.reason}>身份服务待接入</span>;
   if (session?.status === 'loading')
     return (
       <div

package/codebase/template/src/layouts/role-workspace-icons.tsx

@@ -1,6 +1,7 @@
 const paths = {
   'value-panorama': 'M4 7h6v6H4z M10 10h5a4 4 0 0 1 4 4v3 M16 14l3 3 3-3 M7 13v4',
   'my-value': 'M12 2c1 7 3 9 10 10-7 1-9 3-10 10-1-7-3-9-10-10 7-1 9-3 10-10z',
+  'my-tasks': 'M4 4h16v16H4z M8 8h9 M8 12h9 M8 16h9',
   inbox: 'M22 12a10 10 0 1 1-20 0 10 10 0 0 1 20 0 M12 6v6h5',
   'enterprise-tasks': 'M3 3h18v18H3z M3 9h18 M3 15h18 M9 3v18 M15 3v18',
 };

package/codebase/template/src/layouts/role-workspace-routes.ts

@@ -2,6 +2,7 @@
 export const DEFAULT_WORKSPACE_ROUTES = [
   { id: 'value-panorama', label: '价值全景', group: 'value' },
   { id: 'my-value', label: '我的价值', group: 'value' },
+  { id: 'my-tasks', label: '我的任务', group: 'tasks' },
   { id: 'inbox', label: '待办事项', group: 'inbox' },
   { id: 'enterprise-tasks', label: '企业任务总览', group: 'enterprise' },
 ] as const;