@dsh-workbench/shared 0.3.11 → 1.0.0-beta.1

package/src/lib/blocker-action.ts

@@ -20,4 +20,3 @@ export interface BlockerLabelState {
   readonly running: string | null;
   readonly copied: string | null;
 }
-

package/src/{api → lib}/dsh-client.ts

@@ -23,6 +23,7 @@ export interface WorkspaceSnapshot {
 
 /**
  * 会话一行的来源（标题、空会话、在跑与否、被谁留住）；retainedBy 按视图名记留住它的份数，mainView 大于 0 即正被主视图占着。
+ * projectionValues 是 dsh 的会话投影，外壳只读 `agentPreset` 一位（没选过模式时没有这一位）。
  */
 export interface SessionSummary {
   readonly id: string;
@@ -32,6 +33,7 @@ export interface SessionSummary {
   readonly updatedAt: number;
   readonly origin?: string;
   readonly retainedBy: Readonly<Partial<Record<string, number>>>;
+  readonly projectionValues?: Readonly<Record<string, unknown>>;
 }
 
 /**
@@ -298,10 +300,19 @@ export interface DshSessionsRemote {
 }
 
 /**
- * dsh 客户端的远端写口集合；目前只有会话一家。
+ * remote.agentPresets 写口：给还没开跑的会话挑模式（同一件事就是模式选择器点一下）；
+ * 会话发出第一条消息后 dsh 会拒（模式已锁）。
+ */
+export interface DshAgentPresetsRemote {
+  select(sessionId: string, presetId: string): Promise<unknown>;
+}
+
+/**
+ * dsh 客户端的远端写口集合；会话与模式两家。
  */
 export interface DshClientRemote {
   readonly sessions: DshSessionsRemote;
+  readonly agentPresets?: DshAgentPresetsRemote;
 }
 
 /**

package/src/lib/market-index.ts

@@ -0,0 +1,36 @@
+import type { MarketIndexSource, MarketLocalizedText } from '../contract/protocol/market-index.js';
+
+const BRANCH = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+
+export function marketBranchOk(value: string): boolean {
+  const branch = value.trim();
+  return (
+    BRANCH.test(branch) &&
+    !branch.includes('..') &&
+    !branch.endsWith('/') &&
+    !branch.endsWith('.') &&
+    !branch.includes('@{')
+  );
+}
+
+export function marketText(value: MarketLocalizedText | undefined, locale: string): string {
+  if (value === undefined) return '';
+  const zh = value.zh ?? '';
+  const en = value.en ?? '';
+  return locale.toLowerCase().startsWith('zh') ? zh || en : en || zh;
+}
+
+export function marketInstallTarget(
+  name: string,
+  version: string,
+  source: MarketIndexSource,
+): { readonly spec: string; readonly registry?: string } {
+  if (source.type === 'npm') {
+    const registry = (source.registry ?? '').trim();
+    return { spec: `${name}@${version}`, ...(registry === '' ? {} : { registry }) };
+  }
+  const base = `git+${source.url.trim().replace(/^git\+/, '')}#${source.commit}`;
+  const path = (source.path ?? '').trim().replace(/^\/+/, '');
+  return { spec: path === '' ? base : `${base}&path:/${path}` };
+}
+

package/src/lib/react.ts

@@ -2,61 +2,21 @@ import type * as ReactTypes from 'react';
 
 const react = require('react') as typeof ReactTypes;
 
-/**
- * React 的 `createElement` 换个短名字再导出 —— 这套代码用 `h(...)` 写元素。
- */
 export const h = react.createElement;
 
-/**
- * React 的 `Fragment` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const Fragment = react.Fragment;
 
-/**
- * React 的 `Component` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const Component = react.Component;
 
-/**
- * React 的 `createContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const createContext = react.createContext;
-/**
- * React 的 `useContext` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useContext = react.useContext;
 
-/**
- * React 的 `useState` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useState = react.useState;
-/**
- * React 的 `useEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useEffect = react.useEffect;
-/**
- * React 的 `useLayoutEffect` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useLayoutEffect = react.useLayoutEffect;
-/**
- * React 的 `useMemo` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useMemo = react.useMemo;
-/**
- * React 的 `useCallback` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useCallback = react.useCallback;
-/**
- * React 的 `useRef` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useRef = react.useRef;
-/**
- * React 的 `useSyncExternalStore` 原样再导出 —— 共享包的哑组件用它；模块写 JSX 一律直接 import react（这一份不进公开入口）。
- */
 export const useSyncExternalStore = react.useSyncExternalStore;
 
-/**
- * 借来的三个类型从 `react-types.ts` 转一手：那份是**公开面**（模块 `import type` 从根入口拿），
- * 组件内部照旧从这里引，别在两处各写一遍名字。
- */
 export type { ReactNode, CSSProperties, ChangeEvent } from './react-types.js';

package/src/lib/text.test.ts

@@ -16,7 +16,7 @@ describe('parseJsonLoose', () => {
     expect(parseJsonLoose('[1,2]\n完成')).toEqual([1, 2]);
   });
 
-  it('★ 噪音行自己带方括号时也不认错起点（真机：pagoda 的调试命令先打两行带 [] 的话）', () => {
+  it('★ 噪音行自己带方括号时也不认错起点（真机：acme 的调试命令先打两行带 [] 的话）', () => {
     const stdout = [
       '数据源 [dify_dataset] 调试成功',
       '结构类型: 3, 字段: code, name',
@@ -38,7 +38,7 @@ describe('parseJsonLoose', () => {
     ]);
   });
 
-  it('解析不出来给 undefined，让调用方报 coding-bad-output', () => {
+  it('解析不出来给 undefined，让调用方报 demo-bad-output', () => {
     expect(parseJsonLoose('')).toBeUndefined();
     expect(parseJsonLoose('not json at all')).toBeUndefined();
     expect(parseJsonLoose('[1,2')).toBeUndefined();

package/src/lib/ui.test.ts

@@ -1,3 +1,4 @@
+import dayjs from 'dayjs';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   cx,
@@ -15,7 +16,7 @@ const t: TimeTranslate = (key, params) => {
   return `${key}:${String(params.n ?? params.t ?? '')}`;
 };
 
-const NOW = Date.parse('2026-09-27T12:00:00.000Z');
+const NOW = dayjs('2026-09-27T12:00:00.000Z').valueOf();
 
 describe('cx', () => {
   it('拼上真值、丢掉假值', () => {
@@ -55,7 +56,7 @@ describe('relativeTime', () => {
 
     expect(old).not.toContain('time.');
     expect(old.match(/:/g)).toHaveLength(2);
-    expect(old).toContain(String(new Date(NOW).getFullYear()));
+    expect(old).toContain(String(dayjs(NOW).year()));
   });
 
   it('非法时间戳给空串而不是 NaN', () => {
@@ -125,12 +126,12 @@ describe('parseLocalTimestamp', () => {
   it('按本地时区解析 Coding 的时间戳形态', () => {
     const parsed = parseLocalTimestamp('2026-09-27 08:18:36');
     expect(Number.isFinite(parsed)).toBe(true);
-    expect(parsed).toBe(new Date('2026-09-27T08:18:36').getTime());
+    expect(parsed).toBe(dayjs('2026-09-27T08:18:36').valueOf());
   });
 
   it('也接受 ISO 的 T 分隔写法', () => {
     expect(parseLocalTimestamp('2026-09-27T08:18:36')).toBe(
-      new Date('2026-09-27T08:18:36').getTime(),
+      dayjs('2026-09-27T08:18:36').valueOf(),
     );
   });
 
@@ -142,7 +143,7 @@ describe('parseLocalTimestamp', () => {
 
   it('容忍首尾空白', () => {
     expect(parseLocalTimestamp('  2026-09-27 08:18:36  ')).toBe(
-      new Date('2026-09-27T08:18:36').getTime(),
+      dayjs('2026-09-27T08:18:36').valueOf(),
     );
   });
 });

package/src/lib/ui.ts

@@ -1,3 +1,4 @@
+import dayjs from 'dayjs';
 /**
  * 拼类名：只留真值、用空格连接（`false` / `null` / `undefined` / 空串都丢掉）。
  * @param parts - 若干类名或条件值。
@@ -91,14 +92,7 @@ export function relativeTime(epochMs: number, t: TimeTranslate): string {
   if (diff < 60 * MINUTE) return t('time.minutes', { n: Math.floor(diff / MINUTE) });
   if (diff < 24 * 60 * MINUTE) return t('time.hours', { n: Math.floor(diff / (60 * MINUTE)) });
   if (diff < 7 * 24 * 60 * MINUTE) return t('time.days', { n: Math.floor(diff / (24 * 60 * MINUTE)) });
-  return new Date(epochMs).toLocaleString(undefined, {
-    year: 'numeric',
-    month: 'numeric',
-    day: 'numeric',
-    hour: '2-digit',
-    minute: '2-digit',
-    second: '2-digit',
-  });
+  return dayjs(epochMs).format('YYYY/M/D HH:mm:ss');
 }
 
 /**
@@ -122,5 +116,5 @@ const LOCAL_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/;
 export function parseLocalTimestamp(text: string | null | undefined): number {
   const raw = String(text ?? '').trim();
   if (!LOCAL_TIMESTAMP.test(raw)) return Number.NaN;
-  return new Date(raw.replace(' ', 'T')).getTime();
+  return dayjs(raw.replace(' ', 'T')).valueOf();
 }

package/src/testing/__tests__/declaration.test.ts

@@ -19,7 +19,7 @@ afterEach(() => {
 });
 
 const DECLARED = {
-  apiVersion: 1,
+  apiVersion: 2,
   unit: 'demo',
   card: { titleKey: 'demo.cardTitle', order: 7 },
   tools: [{ name: 'workbench_demo_list', writes: false }],

package/src/testing/data.ts

@@ -0,0 +1,66 @@
+import type { CallOverrides, DataReader, DataRequest, RecipeCalls, RecipeResults, RequestRecipe } from '../contract/data.js';
+
+export interface RecipeCall {
+  readonly kind: 'request' | 'submit' | 'many';
+  readonly recipe: RequestRecipe;
+  readonly overrides?: CallOverrides | undefined;
+  readonly calls?: RecipeCalls | undefined;
+}
+
+const NO_DATA = {
+  ok: false as const,
+  error: { code: 'invalid-request' as const, message: '测试没有注入 DataReader' },
+};
+
+function filled(names: readonly string[], value: unknown): RecipeResults {
+  const out: Record<string, unknown> = {};
+  for (const name of names) out[name] = value;
+  return out as RecipeResults;
+}
+
+export function createNoopDataReader(): DataReader {
+  return {
+    read: async () => NO_DATA,
+    request: async () => NO_DATA,
+    requestMany: async <T = unknown>(_recipe: RequestRecipe, calls: RecipeCalls): Promise<RecipeResults<T>> =>
+      filled(Object.keys(calls), NO_DATA) as RecipeResults<T>,
+    submit: async () => NO_DATA,
+  };
+}
+
+export function createFakeDataReader(
+  reply: unknown | ((request: DataRequest, index: number) => unknown) = { ok: true, data: null },
+  recipeReply: unknown | ((call: RecipeCall, index: number) => unknown) = { ok: true, data: null },
+): DataReader & {
+  readonly requests: readonly DataRequest[];
+  readonly calls: readonly RecipeCall[];
+} {
+  const requests: DataRequest[] = [];
+  const calls: RecipeCall[] = [];
+  const answer = (call: RecipeCall): unknown =>
+    typeof recipeReply === 'function' ? recipeReply(call, calls.length - 1) : recipeReply;
+  const reader = {
+    async read(request: DataRequest): Promise<unknown> {
+      requests.push(request);
+      return typeof reply === 'function' ? reply(request, requests.length - 1) : reply;
+    },
+    async request(recipe: RequestRecipe, overrides?: CallOverrides): Promise<unknown> {
+      calls.push({ kind: 'request', recipe, overrides });
+      return answer(calls[calls.length - 1] as RecipeCall);
+    },
+    async requestMany(recipe: RequestRecipe, plan: RecipeCalls): Promise<RecipeResults> {
+      calls.push({ kind: 'many', recipe, calls: plan });
+      const answered = answer(calls[calls.length - 1] as RecipeCall);
+      return typeof answered === 'object' && answered !== null && !('ok' in answered)
+        ? (answered as RecipeResults)
+        : filled(Object.keys(plan), answered);
+    },
+    async submit(recipe: RequestRecipe, overrides?: CallOverrides): Promise<unknown> {
+      calls.push({ kind: 'submit', recipe, overrides });
+      return answer(calls[calls.length - 1] as RecipeCall);
+    },
+  } as unknown as DataReader;
+  return Object.assign(reader, { requests, calls });
+}
+
+export const fakeDataReader = createFakeDataReader;

package/src/testing/declaration.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import type { UnitManifest } from '../api/unit.js';
-import { readDeclaration } from '../host/unit-declaration.js';
+import type { UnitManifest } from '../contract/unit.js';
+import { readDeclaration } from '../contract/unit-declaration.js';
 
 export function declarationOfPackage(pkg: string, packageJson: URL | string): UnitManifest {
   const at = typeof packageJson === 'string' ? packageJson : fileURLToPath(packageJson);

package/src/testing/host-fakes.ts

@@ -1,6 +1,5 @@
 import { setTimeout as delay } from 'node:timers/promises';
 import type { DshShell } from '../api/dsh.js';
-import type { Opencli, OpencliResult } from '../host/opencli.js';
 
 export interface ShellCall {
   command: string;
@@ -66,43 +65,6 @@ export function createFakeShell(replies: ShellReply[] | ((call: ShellCall, index
   };
 }
 
-export interface OpencliCall {
-  args: readonly string[];
-  key?: string;
-  workdir?: string;
-  session?: string;
-  refresh?: boolean;
-}
-
-export function createFakeOpencli(
-  replies: Array<unknown | Error> | ((call: OpencliCall, index: number) => unknown | Error) = [],
-) {
-  const calls: OpencliCall[] = [];
-
-  const opencli: Opencli = {
-    async json(args, options = {}) {
-      const call: OpencliCall = {
-        args,
-        ...(options.key === undefined ? {} : { key: options.key }),
-        ...(options.workdir === undefined ? {} : { workdir: options.workdir }),
-        ...(options.session === undefined ? {} : { session: options.session }),
-      };
-      calls.push(call);
-      const index = calls.length - 1;
-      const reply =
-        typeof replies === 'function' ? replies(call, index) : (replies[index] ?? []);
-
-      if (reply instanceof Error) throw reply;
-      return { value: reply, at: Date.now() } satisfies OpencliResult;
-    },
-  };
-
-  return {
-    opencli,
-    calls,
-    keys: () => calls.map((call) => call.key),
-  };
-}
 
 export function createFakeLogger() {
   const warnings: string[] = [];

package/src/testing/needs.ts

@@ -0,0 +1,80 @@
+import type {
+  BinNeed,
+  EnvNeed,
+  ExtensionNeed,
+  LibNeed,
+  Need,
+  NeedKind,
+  SupplySource,
+} from '../contract/needs.js';
+import type { NeedState } from '../contract/unit-capability.js';
+import type { UnitCapability } from '../contract/unit-capability.js';
+import type { UnitManifest } from '../contract/unit.js';
+
+export const fakeNpmSource: SupplySource = {
+  kind: 'npm',
+  registryEnv: 'WB_TEST_REGISTRY',
+  registryDefault: 'https://registry.invalid/',
+};
+
+export function extensionNeedOf(name: string, extra: Partial<ExtensionNeed> = {}): ExtensionNeed {
+  return {
+    kind: 'extension',
+    runtime: 'opencli',
+    name,
+    commands: [`${name}-read`],
+    purpose: '测试',
+    ...extra,
+  };
+}
+
+export function libNeedOf(name: string, extra: Partial<LibNeed> = {}): LibNeed {
+  return { kind: 'lib', name, purpose: '测试', ...extra };
+}
+
+export function binNeedOf(name: string, extra: Partial<BinNeed> = {}): BinNeed {
+  return { kind: 'bin', name, purpose: '测试', ...extra };
+}
+
+export function envNeedOf(name: string, extra: Partial<EnvNeed> = {}): EnvNeed {
+  return { kind: 'env', name, purpose: '测试', ...extra };
+}
+
+export function manifestOf(
+  options: {
+    readonly id?: string | undefined;
+    readonly needs?: readonly Need[] | undefined;
+    readonly card?: UnitManifest['card'];
+  } = {},
+): UnitManifest {
+  return {
+    id: options.id ?? 'fixture',
+    card: options.card === undefined ? { titleKey: `${options.id ?? 'fixture'}.mine`, order: 10 } : options.card,
+    tools: [],
+    host: { inject: [] },
+    ...(options.needs === undefined ? {} : { needs: options.needs }),
+  };
+}
+
+export function needStateOf(
+  need: Need,
+  status: NeedState['status'] = 'ok',
+  extra: Partial<NeedState> = {},
+): NeedState {
+  return {
+    id: need.id ?? `${need.kind}:${need.name}`,
+    kind: need.kind as NeedKind,
+    name: need.name,
+    status,
+    detail: `测试：${need.name}`,
+    ...extra,
+  };
+}
+
+export function capabilityOf(
+  unit: string,
+  needs: readonly NeedState[] = [],
+  extra: Partial<UnitCapability> = {},
+): UnitCapability {
+  return { unit, status: needs.some((need) => need.status !== 'ok') ? 'missing' : 'ok', needs, ...extra };
+}

package/src/testing.ts

@@ -1,2 +1,4 @@
 export * from './testing/host-fakes.js';
 export * from './testing/declaration.js';
+export * from './testing/needs.js';
+export * from './testing/data.js';

package/dist/api/unit-declaration.d.ts

@@ -1,65 +0,0 @@
-import type { UnitEnvNeeds, UnitHostNeeds, UnitManifest } from './unit.js';
-/**
- * 声明协议当前版本；模块清单的 dsh.workbench.apiVersion 要写这个整数。
- */
-export declare const WORKBENCH_API_VERSION = 1;
-/**
- * 外壳愿意认的协议版本；不在表里的模块当场被拒，不猜语义。
- */
-export declare const SUPPORTED_API_VERSIONS: readonly number[];
-/**
- * 清单里那半张卡片声明：文案键加排序位；卡片默认显不显示不在这里（那是运行期面板配置的事）。
- */
-export interface UnitCardDeclaration {
-    readonly titleKey: string;
-    readonly order: number;
-}
-/**
- * 清单里的一条工具声明：进 dsh 工具表的全名、会不会写，以及生成物里的键名。
- */
-export interface UnitToolDeclaration {
-    readonly name: string;
-    readonly writes: boolean;
-    readonly key?: string;
-}
-/**
- * 模块清单里 dsh.workbench 那一段的完整形状（协议版本、单元 id、卡片、工具、宿主与环境需要）。
- */
-export interface UnitDeclaration {
-    readonly apiVersion: number;
-    readonly unit: string;
-    readonly card: UnitCardDeclaration | null;
-    readonly tools: readonly UnitToolDeclaration[];
-    readonly host: UnitHostNeeds;
-    readonly env?: UnitEnvNeeds;
-}
-/**
- * 协议认得的全部键；写了别的键不会被采纳（外壳静默忽略），所以字段名拼错不会有提示。
- */
-export declare const DECLARATION_KEYS: readonly string[];
-/**
- * 协议要求必写的键；env 不在其中（没有环境需要就不写）。
- */
-export declare const DECLARATION_REQUIRED_KEYS: readonly string[];
-/**
- * 查清单里 dsh.workbench 那一段的形状，回一串给人看的问题（中文，带字段路径）。
- * @param subject 报错时用的主语，一般是包名。
- * @param raw 清单里那段原始值，可能什么都不是。
- * @returns 空数组表示形状过得去；版本不对就当场返回（后面的字段无从判起）。
- */
-export declare function declarationProblemsOf(subject: string, raw: unknown): readonly string[];
-/**
- * 读一份清单的结果：要么带着规整过的声明与 manifest，要么只带一串问题。
- */
-export interface DeclarationRead {
-    readonly declaration?: UnitDeclaration;
-    readonly manifest?: UnitManifest;
-    readonly problems: readonly string[];
-}
-/**
- * 读一份清单：先查形状，过了再把声明规整成 manifest。
- * @param subject 报错时用的主语。
- * @param raw 清单里 dsh.workbench 那段原始值。
- * @returns 有问题时只有 problems；没问题时 declaration 与 manifest 都给，manifest 里的字符串已 trim。
- */
-export declare function readDeclaration(subject: string, raw: unknown): DeclarationRead;

package/dist/api/unit.d.ts

@@ -1,85 +0,0 @@
-/**
- * 一张卡片在清单里的静态声明（文案键加排序位）；默认显不显示由运行期面板配置定。
- */
-export interface UnitCard {
-    readonly titleKey: string;
-    readonly order: number;
-}
-/**
- * 一条工具在清单里的样子：全名加会不会写；审批按 writes 认领。
- */
-export interface UnitTool {
-    readonly name: string;
-    readonly writes: boolean;
-}
-/**
- * 模块要外壳的哪些服务：inject 缺一个就挂不上，optional 缺了照挂。
- */
-export interface UnitHostNeeds {
-    readonly inject: readonly string[];
-    readonly optional?: readonly string[];
-}
-/**
- * 一个 opencli 插件的来源三选一（git / 本地 / npm）；npm 那支的安装源先看 registryEnv 那个环境变量，没设才用 registryDefault。
- */
-export type PluginSource = {
-    readonly kind: 'git';
-    readonly url: string;
-} | {
-    readonly kind: 'local';
-    readonly env: string;
-} | {
-    readonly kind: 'npm';
-    readonly package: string;
-    readonly registryEnv: string;
-    readonly registryDefault?: string;
-};
-/**
- * 模块要的一个 opencli 插件：名字、它得提供的命令，以及装它的来源（没写就是不代装）。
- */
-export interface UnitPluginNeed {
-    readonly name: string;
-    readonly commands?: readonly string[];
-    readonly installSource?: PluginSource;
-}
-/**
- * 模块要的一个共用库：名字、期望范围与它为什么要这个版本（purpose 会进申报文案）。
- */
-export interface UnitLibNeed {
-    readonly name: string;
-    readonly version?: string | undefined;
-    readonly registryEnv: string;
-    readonly registryDefault: string;
-    readonly purpose: string;
-}
-/**
- * 模块的整份环境需要：一条自检命令，加上插件与共用库两张表。
- */
-export interface UnitEnvNeeds {
-    readonly command?: string;
-    readonly plugins?: readonly UnitPluginNeed[];
-    readonly libs?: readonly UnitLibNeed[];
-}
-/**
- * 已装插件与源上最新版那一对，用来判该不该提示升级；latest 缺省表示还没查到。
- */
-export interface PluginRelease {
-    readonly installed: string;
-    readonly latest?: string;
-}
-/**
- * 装配期用的模块清单：单元 id、卡片、工具与宿主 / 环境需要，比声明少一层协议包装。
- */
-export interface UnitManifest {
-    readonly id: string;
-    readonly card: UnitCard | null;
-    readonly tools: readonly UnitTool[];
-    readonly host: UnitHostNeeds;
-    readonly env?: UnitEnvNeeds;
-}
-/**
- * 判这个模块要不要往外装东西。
- * @param manifest 模块清单。
- * @returns 插件与共用库两张表都空时给 false。
- */
-export declare function hasEnvSupply(manifest: UnitManifest): boolean;

package/dist/api/unit.js

@@ -1,8 +0,0 @@
-/**
- * 判这个模块要不要往外装东西。
- * @param manifest 模块清单。
- * @returns 插件与共用库两张表都空时给 false。
- */
-export function hasEnvSupply(manifest) {
-    return (manifest.env?.plugins ?? []).length > 0 || (manifest.env?.libs ?? []).length > 0;
-}

package/dist/api/workbench-contract.d.ts

@@ -1,44 +0,0 @@
-import type { PluginRelease } from '../api/unit.js';
-/**
- * 供给动作的那几档（装 / 升 / 卸，模块、共用依赖与插件各一套）；写口按它分派。
- */
-export type ProvisionAction = 'install' | 'update' | 'uninstall' | 'update-dependency' | 'install-bundle' | 'update-bundle' | 'remove-bundle' | 'cancel-install' | 'update-plugin' | 'uninstall-plugin' | 'update-workbench';
-/**
- * 宿主报的一个 opencli 插件此刻的状态：装没装、缺哪些命令、该不该升，以及怎么升。
- */
-export interface PluginStatePayload {
-    readonly name: string;
-    readonly status: 'ok' | 'outdated' | 'missing';
-    readonly missing: readonly string[];
-    readonly install?: 'ready' | 'not-declared' | 'env-missing' | 'malformed';
-    readonly command?: string;
-    readonly release?: PluginRelease;
-}
-/**
- * 宿主对「这个单元现在能不能用」的那份读数：状态、缺的命令与插件、修复动作和供给细节。
- */
-export interface CapabilityPayload {
-    readonly unit: string;
-    readonly status: 'ok' | 'failed' | 'missing-commands' | 'missing-plugin' | 'unchecked';
-    readonly plugin?: string;
-    readonly required: readonly string[];
-    readonly missing: readonly string[];
-    readonly detail: string;
-    readonly command?: string;
-    readonly fix?: 'install' | 'update';
-    readonly plugins?: readonly PluginStatePayload[];
-    readonly released?: boolean;
-    readonly install?: 'ready' | 'not-declared' | 'env-missing' | 'malformed';
-    readonly libs?: readonly LibStatePayload[];
-}
-/**
- * 宿主报的一个共用库此刻的状态（装没装、版本对不对）与它为什么要这个版本。
- */
-export interface LibStatePayload {
-    readonly name: string;
-    readonly purpose: string;
-    readonly status: 'ok' | 'outdated' | 'missing' | 'unsatisfied';
-    readonly installed?: string;
-    readonly latest?: string;
-    readonly command?: string;
-}