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

package/src/{api → contract}/facts.ts

@@ -8,7 +8,7 @@ export interface FactFrame {
 }
 
 /**
- * 范围查法的后缀：cmdb/* 这类名字表示「这个前缀下的一族」，不是一条事实。
+ * 范围查法的后缀：inventory/* 这类名字表示「这个前缀下的一族」，不是一条事实。
  */
 export const FACT_SCOPE_SUFFIX = '*';
 
@@ -31,14 +31,25 @@ export function scopePrefixOf(name: string): string {
 }
 
 /**
- * 事实的来路：start 建连并按帧回调，cursor 报已收到的宿主 rev（断线重连时交给宿主）。
+ * 事实传输层的来路：SSE 直连，或降级成轮询。
+ */
+export type FactTransportMode = 'sse' | 'polling';
+
+/**
+ * 事实的来路：start 建连并按帧回调，cursor 报已收到的宿主 rev（断线重连时交给宿主），
+ * onMode 报这一层现在是哪种传输。
  */
 export interface FactTransport {
-  start(handlers: { readonly onFrame: (frame: FactFrame) => void; readonly cursor: () => number }): () => void;
+  start(handlers: {
+    readonly onFrame: (frame: FactFrame) => void;
+    readonly cursor: () => number;
+    readonly onMode?: ((mode: FactTransportMode) => void) | undefined;
+  }): () => void;
 }
 
 /**
- * 浏览器侧的事实通道：订阅、读版本、手动刷新，帧到了由它分发给订阅者。
+ * 浏览器侧的事实通道：订阅、读版本、手动刷新，帧到了由它分发给订阅者；
+ * mode 是传输层现在走的来路（还没建连就是 null），subscribeMode 听它换档。
  */
 export interface FactChannel {
   subscribe(fact: string, listener: () => void): () => void;
@@ -46,6 +57,8 @@ export interface FactChannel {
   refresh(fact?: string): void;
   applyFrame(frame: FactFrame): void;
   subscriberCount(): number;
+  mode(): FactTransportMode | null;
+  subscribeMode(listener: () => void): () => void;
 }
 
 interface FactEntry {
@@ -60,10 +73,18 @@ interface FactEntry {
  */
 export function createFactChannel(options: { readonly transport: FactTransport }): FactChannel {
   const entries = new Map<string, FactEntry>();
+  const modeListeners = new Set<() => void>();
   let epoch: string | null = null;
   let stopTransport: (() => void) | null = null;
   let hostRev = 0;
   let generation = 0;
+  let mode: FactTransportMode | null = null;
+
+  const setMode = (next: FactTransportMode | null): void => {
+    if (mode === next) return;
+    mode = next;
+    for (const listener of [...modeListeners]) listener();
+  };
 
   const entryOf = (fact: string): FactEntry => {
     const existing = entries.get(fact);
@@ -107,6 +128,7 @@ export function createFactChannel(options: { readonly transport: FactTransport }
     stopTransport = options.transport.start({
       onFrame: (frame) => channel.applyFrame(frame),
       cursor: () => hostRev,
+      onMode: (next) => setMode(next),
     });
   };
 
@@ -114,6 +136,7 @@ export function createFactChannel(options: { readonly transport: FactTransport }
     if (stopTransport === null) return;
     stopTransport();
     stopTransport = null;
+    setMode(null);
   };
 
   const channel: FactChannel = {
@@ -132,6 +155,13 @@ export function createFactChannel(options: { readonly transport: FactTransport }
       for (const entry of entries.values()) count += entry.listeners.size;
       return count;
     },
+    mode: () => mode,
+    subscribeMode(listener) {
+      modeListeners.add(listener);
+      return () => {
+        modeListeners.delete(listener);
+      };
+    },
     refresh(fact) {
       generation += 1;
       if (fact === undefined) {

package/src/contract/needs.ts

@@ -0,0 +1,331 @@
+/**
+ * 模块要的一样东西的类别；v2 只认这四种，加种类在注册表里加，不改这份形状。
+ */
+export const NEED_KINDS = ['bin', 'extension', 'lib', 'env'] as const;
+
+/**
+ * need 的类别。
+ */
+export type NeedKind = (typeof NEED_KINDS)[number];
+
+/**
+ * 一种外部来源；每一种都只说「去哪拿」，装不装、怎么装由宿主决定。
+ */
+export type SupplySource =
+  | {
+      readonly kind: 'npm';
+      readonly package?: string;
+      readonly registryEnv?: string;
+      readonly registryDefault?: string;
+    }
+  | { readonly kind: 'git'; readonly url: string; readonly ref?: string }
+  | { readonly kind: 'local'; readonly path?: string; readonly env?: string };
+
+/**
+ * 协议认得的外部来源种类。
+ */
+export const SUPPLY_SOURCE_KINDS = ['npm', 'git', 'local'] as const;
+
+/**
+ * 外部来源的类别。
+ */
+export type SupplySourceKind = (typeof SUPPLY_SOURCE_KINDS)[number];
+
+/**
+ * 每条 need 都有的字段：为什么需要它、缺了算不算问题。
+ */
+export interface NeedCommon {
+  readonly kind: NeedKind;
+  readonly purpose: string;
+  readonly required?: boolean;
+  readonly id?: string;
+}
+
+/**
+ * 机器上要有一个可执行文件；探法是 `command -v` / `where`。
+ */
+export interface BinNeed extends NeedCommon {
+  readonly kind: 'bin';
+  readonly name: string;
+}
+
+/**
+ * 某个运行时上要有一个扩展（opencli 的插件就是这种），并且要提供这些命令。
+ */
+export interface ExtensionNeed extends NeedCommon {
+  readonly kind: 'extension';
+  readonly runtime: string;
+  readonly name: string;
+  readonly commands?: readonly string[];
+  readonly version?: string;
+  readonly sources?: readonly SupplySource[];
+}
+
+/**
+ * 要在隔离运行时里有一个共用依赖包。
+ */
+export interface LibNeed extends NeedCommon {
+  readonly kind: 'lib';
+  readonly name: string;
+  readonly version?: string;
+  readonly sources?: readonly SupplySource[];
+}
+
+/**
+ * 跑起来时要有这个环境变量；`secret` 为真时任何地方都不回显它的值。
+ */
+export interface EnvNeed extends NeedCommon {
+  readonly kind: 'env';
+  readonly name: string;
+  readonly secret?: boolean;
+}
+
+/**
+ * 模块声明的一条需要。
+ */
+export type Need = BinNeed | ExtensionNeed | LibNeed | EnvNeed;
+
+/**
+ * 一份 needs 校验结果：错误拒收，警告只提醒（未知可选字段就是警告）。
+ */
+export interface NeedsProblems {
+  readonly errors: readonly string[];
+  readonly warnings: readonly string[];
+}
+
+/**
+ * 协议认得的 need 字段；`x-` 前缀的字段留给第三方扩展，直接忽略。
+ */
+export const NEED_KEYS: readonly string[] = [
+  'kind',
+  'purpose',
+  'required',
+  'id',
+  'name',
+  'runtime',
+  'commands',
+  'version',
+  'sources',
+  'secret',
+];
+
+/**
+ * 注册表把「怎么校验、怎么探、能不能代装」收在一处；加一种 kind 只在这里加一行。
+ */
+export interface NeedKindSpec {
+  readonly kind: NeedKind;
+  readonly probe: 'bin' | 'extension' | 'package' | 'env';
+  readonly sources: readonly SupplySourceKind[];
+  readonly validate: (raw: Readonly<Record<string, unknown>>, at: string) => readonly string[];
+}
+
+const SOURCE_KEYS = ['kind', 'package', 'registryEnv', 'registryDefault', 'url', 'ref', 'path', 'env'];
+const REGISTRY_PATTERN = /^(?:https?|file):\/\//;
+
+function text(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+/**
+ * 这个字符串是不是协议认得的 need 类别。
+ * @param value 待判的值。
+ * @returns 是就收窄成 NeedKind。
+ */
+export function isKnownNeedKind(value: unknown): value is NeedKind {
+  return typeof value === 'string' && (NEED_KINDS as readonly string[]).includes(value);
+}
+
+/**
+ * 一条 need 的稳定标识：作者写 `id` 就用它，否则 `kind:name`。
+ * @param need 一条 need。
+ * @returns 标识串。
+ */
+export function needIdOf(need: Need): string {
+  return need.id === undefined || need.id.trim() === '' ? `${need.kind}:${need.name}` : need.id;
+}
+
+function sourceProblemsOf(raw: unknown, at: string): readonly string[] {
+  if (!isRecord(raw)) return [`${at} 要是对象`];
+  const kind = text(raw['kind']);
+  if (!(SUPPLY_SOURCE_KINDS as readonly string[]).includes(kind)) {
+    return [`${at}.kind 不认识 —— ${JSON.stringify(raw['kind'])}（只有 ${SUPPLY_SOURCE_KINDS.join(' / ')}）`];
+  }
+  const errors: string[] = [];
+  for (const key of Object.keys(raw)) {
+    if (SOURCE_KEYS.includes(key) || key.startsWith('x-')) continue;
+    errors.push(`${at} 有不认识的字段 ${key}`);
+  }
+  if (kind === 'npm') {
+    if (raw['package'] !== undefined && text(raw['package']) === '') errors.push(`${at}.package 是空串`);
+    if (raw['registryEnv'] !== undefined && text(raw['registryEnv']) === '') {
+      errors.push(`${at}.registryEnv 是空串`);
+    }
+    if (raw['registryDefault'] !== undefined && !REGISTRY_PATTERN.test(text(raw['registryDefault']))) {
+      errors.push(`${at}.registryDefault 要是 http(s):// 或 file:// 的源地址`);
+    }
+    return errors;
+  }
+  if (kind === 'git') {
+    if (text(raw['url']) === '') errors.push(`${at}.url 没写`);
+    return errors;
+  }
+  if (text(raw['path']) === '' && text(raw['env']) === '') {
+    errors.push(`${at} 是 local，但 path 与 env 都没写`);
+  }
+  return errors;
+}
+
+function sourcesProblemsOf(
+  raw: unknown,
+  at: string,
+  allowed: readonly SupplySourceKind[],
+): readonly string[] {
+  if (raw === undefined) return [];
+  if (!Array.isArray(raw)) return [`${at}.sources 要是数组`];
+  if (raw.length === 0) return [`${at}.sources 是空数组 —— 不代装就整条删掉`];
+  if (allowed.length === 0) {
+    return [`${at} 这种需要不支持 sources —— 它没有「从哪装」这回事`];
+  }
+  const errors: string[] = [];
+  raw.forEach((source, index) => {
+    const one = sourceProblemsOf(source, `${at}.sources[${index}]`);
+    errors.push(...one);
+    if (one.length === 0 && isRecord(source)) {
+      const kind = text(source['kind']) as SupplySourceKind;
+      if (!allowed.includes(kind)) {
+        errors.push(`${at}.sources[${index}].kind 是 ${kind}，这种需要只支持 ${allowed.join(' / ')}`);
+      }
+    }
+  });
+  return errors;
+}
+
+function commonProblemsOf(raw: Readonly<Record<string, unknown>>, at: string): readonly string[] {
+  const errors: string[] = [];
+  if (text(raw['purpose']) === '') errors.push(`${at}.purpose 没写 —— 「为什么要它」是缺失文案的那半句`);
+  if (raw['required'] !== undefined && typeof raw['required'] !== 'boolean') {
+    errors.push(`${at}.required 要是布尔`);
+  }
+  if (raw['id'] !== undefined && text(raw['id']) === '') errors.push(`${at}.id 是空串`);
+  return errors;
+}
+
+function perKindProblemsOf(
+  kind: NeedKind,
+  raw: Readonly<Record<string, unknown>>,
+  at: string,
+): readonly string[] {
+  const errors: string[] = [];
+  if (kind === 'bin' || kind === 'lib' || kind === 'env') {
+    if (text(raw['name']) === '') errors.push(`${at}.name 没写`);
+  }
+  if (kind === 'extension') {
+    if (text(raw['runtime']) === '') errors.push(`${at}.runtime 没写 —— 扩展属于哪个运行时（如 opencli）`);
+    if (text(raw['name']) === '') errors.push(`${at}.name 没写`);
+    if (raw['commands'] !== undefined) {
+      if (!Array.isArray(raw['commands'])) errors.push(`${at}.commands 要是数组`);
+      else if (raw['commands'].some((one) => text(one) === '')) errors.push(`${at}.commands 里有空字符串`);
+    }
+  }
+  if (kind === 'env' && raw['secret'] !== undefined && typeof raw['secret'] !== 'boolean') {
+    errors.push(`${at}.secret 要是布尔`);
+  }
+  return errors;
+}
+
+function validateKind(kind: NeedKind) {
+  return (raw: Readonly<Record<string, unknown>>, at: string): readonly string[] =>
+    perKindProblemsOf(kind, raw, at);
+}
+
+/**
+ * 一张表说了算：每种 kind 的探法、可用来源与校验。
+ */
+export const NEED_KIND_SPECS: Readonly<Record<NeedKind, NeedKindSpec>> = Object.freeze({
+  bin: Object.freeze({
+    kind: 'bin',
+    probe: 'bin',
+    sources: Object.freeze([]) as readonly SupplySourceKind[],
+    validate: validateKind('bin'),
+  }),
+  extension: Object.freeze({
+    kind: 'extension',
+    probe: 'extension',
+    sources: Object.freeze(['npm', 'git', 'local'] as SupplySourceKind[]),
+    validate: validateKind('extension'),
+  }),
+  lib: Object.freeze({
+    kind: 'lib',
+    probe: 'package',
+    sources: Object.freeze(['npm'] as SupplySourceKind[]),
+    validate: validateKind('lib'),
+  }),
+  env: Object.freeze({
+    kind: 'env',
+    probe: 'env',
+    sources: Object.freeze([]) as readonly SupplySourceKind[],
+    validate: validateKind('env'),
+  }),
+});
+
+/**
+ * 校验一条 need；未知类别是错误，未知字段是警告。
+ * @param label 报错时用的主语（模块包名）。
+ * @param raw 这一条 need 的原始值。
+ * @param index 它在 needs 里的下标。
+ * @returns 错误与警告。
+ */
+export function needProblemsOf(label: string, raw: unknown, index: number): NeedsProblems {
+  const at = `${label}.needs[${index}]`;
+  if (!isRecord(raw)) return { errors: [`${at} 要是对象`], warnings: [] };
+  const kind = text(raw['kind']);
+  if (!isKnownNeedKind(kind)) {
+    return {
+      errors: [
+        `${at}.kind 不认识 —— ${JSON.stringify(raw['kind'])}（v2 只认 ${NEED_KINDS.join(' / ')}；` +
+          '要是模块用了更新的工作台才有的种类，升级工作台）',
+      ],
+      warnings: [],
+    };
+  }
+  const warnings: string[] = [];
+  for (const key of Object.keys(raw)) {
+    if (NEED_KEYS.includes(key) || key.startsWith('x-')) continue;
+    warnings.push(`${at} 有不认识的字段 ${key}（宿主会忽略它）`);
+  }
+  const errors = [
+    ...commonProblemsOf(raw, at),
+    ...perKindProblemsOf(kind, raw, at),
+    ...sourcesProblemsOf(raw['sources'], at, NEED_KIND_SPECS[kind].sources),
+  ];
+  return { errors, warnings };
+}
+
+/**
+ * 校验整张 needs 表（没写就是空表）。
+ * @param label 报错时用的主语。
+ * @param raw 声明里的 needs 原始值。
+ * @returns 错误与警告。
+ */
+export function needsProblemsOf(label: string, raw: unknown): NeedsProblems {
+  if (raw === undefined) return { errors: [], warnings: [] };
+  if (!Array.isArray(raw)) return { errors: [`${label}.needs 要是数组`], warnings: [] };
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  const seen = new Set<string>();
+  raw.forEach((one, index) => {
+    const found = needProblemsOf(label, one, index);
+    errors.push(...found.errors);
+    warnings.push(...found.warnings);
+    if (found.errors.length > 0 || !isRecord(one)) return;
+    const kind = text(one['kind']);
+    const id = text(one['id']) === '' ? `${kind}:${text(one['name'])}` : text(one['id']);
+    if (seen.has(id)) errors.push(`${label}.needs 里 ${id} 重复了 —— 每条 need 的 id 要唯一`);
+    seen.add(id);
+  });
+  return { errors, warnings };
+}

package/src/contract/plugin-source.ts

@@ -0,0 +1 @@
+export type ProvisionProblem = 'not-declared' | 'env-missing' | 'malformed';

package/src/contract/protocol/bundle-install.ts

@@ -0,0 +1,198 @@
+export const BUNDLE_REGISTRIES_ROUTE = 'bundle-registries';
+
+export const BUNDLE_INSPECT_ROUTE = 'bundle-inspect';
+
+export const BUNDLE_REGISTRY_DEFAULT = 'default';
+export const MODULE_VERSIONS_ROUTE = 'module-versions';
+
+export type BundleRegistry = string | null;
+
+export interface BundleRegistries {
+  readonly registry: BundleRegistry;
+  readonly fallbackRegistries: readonly BundleRegistry[];
+  readonly resolved: string | null;
+}
+
+export type BundleInspectProblem =
+  | 'invalid-spec'
+  | 'already-installed'
+  | 'not-found'
+  | 'not-a-package'
+  | 'not-a-bundle'
+  | 'not-a-workbench-module'
+  | 'not-a-module-or-plugin'
+  | 'network'
+  | 'unknown';
+
+export type BundleSpecKind = 'registry' | 'path' | 'git' | 'tarball';
+
+export interface BundleInspectionAccepted {
+  readonly status: 'accepted';
+  readonly kind: BundleSpecKind;
+  readonly name?: string;
+  readonly version?: string;
+  readonly description?: string;
+  readonly bundle: boolean | null;
+  readonly registry: BundleRegistry;
+  readonly host?: string;
+}
+
+export interface BundleInspectionRefused {
+  readonly status: 'refused';
+  readonly problem: BundleInspectProblem;
+  readonly reason: string;
+  readonly registries?: readonly BundleRegistry[];
+}
+
+export interface BundleInspectionPlugin {
+  readonly status: 'plugin';
+  readonly pkg: string;
+  readonly registry: BundleRegistry;
+  readonly pluginName?: string;
+  readonly version?: string;
+}
+
+export type BundleInspection =
+  | BundleInspectionAccepted
+  | BundleInspectionRefused
+  | BundleInspectionPlugin;
+
+export interface BundleRegistriesPayload {
+  readonly available: boolean;
+  readonly registries: BundleRegistries | null;
+}
+
+export interface BundleInspectionPayload {
+  readonly inspection: BundleInspection;
+}
+
+export type BundleApplication = 'applied' | 'restart-required' | 'overridden' | 'failed' | 'cancelled';
+
+export const SELF_UPDATE_STATES = ['running', 'ok', 'rolled-back', 'failed'] as const;
+
+export type SelfUpdateState = (typeof SELF_UPDATE_STATES)[number];
+
+export interface WorkbenchSelfUpdate {
+  readonly state: SelfUpdateState;
+  readonly profile?: string;
+  readonly from?: string;
+  readonly to?: string;
+  readonly version?: string;
+  readonly at?: string;
+  readonly tail?: string;
+}
+
+export const RESTART_REASONS = [
+  'no-hmr',
+  'package-moved',
+  'host-module',
+  'unmanaged-plugin',
+  'module-comparison',
+] as const;
+
+export type RestartReason = (typeof RESTART_REASONS)[number];
+
+export type BundleChangeStage = 'install' | 'enable' | 'remove';
+
+export type BundleFailureKind =
+  | 'pnpm-missing'
+  | 'timeout'
+  | 'not-found'
+  | 'no-matching-version'
+  | 'network'
+  | 'disk-full'
+  | 'permission'
+  | 'build-blocked'
+  | 'integrity'
+  | 'unknown';
+
+export interface BundlePackageResult {
+  readonly exitCode: number;
+  readonly output: string;
+  readonly truncated: boolean;
+  readonly logPath: string;
+  readonly kind?: BundleFailureKind;
+}
+
+export interface BundleChange {
+  readonly application: BundleApplication;
+  readonly stage: BundleChangeStage;
+  readonly changed: boolean;
+  readonly target: string;
+  readonly bundle?: string;
+  readonly version?: string;
+  readonly errorCode?: string;
+  readonly errorDetail?: string;
+  readonly packageResult?: BundlePackageResult;
+  readonly pendingBuilds?: readonly string[];
+  readonly restartReason?: RestartReason;
+  readonly failedAt?: 'registry' | 'spec-host';
+}
+
+export interface BundleInstallRequest {
+  readonly spec: string;
+  readonly registry?: BundleRegistry;
+  readonly requestId?: string;
+  readonly approvedBuilds?: readonly string[];
+}
+
+export type BundleCancellation = 'cancelled' | 'too-late' | 'not-running';
+
+export type BundleSupplyState = 'not-a-module' | 'no-needs' | 'installed' | 'failed' | 'pending-restart';
+
+export interface BundleModulePayload {
+  readonly kind: 'module' | 'not-module' | 'unknown';
+  readonly pkg: string;
+  readonly unit?: string;
+  readonly version?: string;
+}
+
+export interface BundleSupplyPayload {
+  readonly state: BundleSupplyState;
+  readonly reason?: string;
+}
+
+export interface BundleInstalledPlugin {
+  readonly kind: 'opencli-plugin';
+  readonly pkg: string;
+  readonly name?: string;
+}
+
+export interface BundleInstallPayload {
+  readonly change: BundleChange;
+  readonly module: BundleModulePayload;
+  readonly supply: BundleSupplyPayload;
+  readonly plugin?: BundleInstalledPlugin;
+}
+
+export interface BundleRemovePayload {
+  readonly change: BundleChange;
+  readonly keptFor: readonly string[];
+}
+
+export interface BundleCancellationPayload {
+  readonly cancellation: BundleCancellation | null;
+}
+
+export interface ModuleVersion {
+  readonly unit: string;
+  readonly pkg: string;
+  readonly installed: string;
+  readonly latest?: string;
+  readonly local?: boolean;
+  readonly refused?: readonly string[];
+}
+
+export interface WorkbenchVersion {
+  readonly pkg: string;
+  readonly installed: string;
+  readonly latest?: string;
+  readonly running?: string;
+  readonly local?: boolean;
+}
+
+export interface ModuleVersionsPayload {
+  readonly modules: readonly ModuleVersion[];
+  readonly workbench?: WorkbenchVersion;
+  readonly selfUpdate?: WorkbenchSelfUpdate;
+}

package/src/contract/protocol/config-sync.ts

@@ -0,0 +1,65 @@
+export const CONFIG_SYNC_ROUTE = 'config-sync';
+
+export const CONFIG_SYNC_RESOURCE = 'configSync';
+
+export type ConfigSyncState = 'new' | 'differs' | 'same';
+
+export type ConfigSyncAssetState = 'missing' | 'differs' | 'same' | 'external';
+
+export interface ConfigSyncAssetFile {
+  readonly path: string;
+  readonly state: ConfigSyncAssetState;
+  readonly bytes: number | null;
+}
+
+export interface ConfigSyncAsset {
+  readonly key: string;
+  readonly path: string;
+  readonly kind: 'file' | 'dir';
+  readonly state: ConfigSyncAssetState;
+  readonly files: readonly ConfigSyncAssetFile[];
+  readonly bytes: number;
+  readonly reason?: string;
+}
+
+export interface ConfigSyncRow {
+  readonly key: string;
+  readonly id: string;
+  readonly insert: boolean;
+  readonly state: ConfigSyncState;
+  readonly body: string;
+  readonly ownBody: string | null;
+  readonly missing: readonly string[];
+  readonly assets: readonly ConfigSyncAsset[];
+}
+
+export interface ConfigSyncProfile {
+  readonly name: string;
+  readonly readable: boolean;
+  readonly candidates: number;
+}
+
+export interface ConfigSyncSnapshot {
+  readonly self: string;
+  readonly home: string;
+  readonly source: string;
+  readonly profiles: readonly ConfigSyncProfile[];
+  readonly rows: readonly ConfigSyncRow[];
+  readonly emptyProviders: boolean;
+  readonly reason?: string;
+}
+
+export interface ConfigSyncApplied {
+  readonly written: readonly string[];
+  readonly skipped: readonly string[];
+  readonly files: readonly string[];
+  readonly verified: boolean;
+}
+
+export interface ConfigSyncRequest {
+  readonly source: string;
+  readonly keys: readonly string[];
+  readonly overwrite: readonly string[];
+  readonly assets?: readonly string[];
+  readonly overwriteAssets?: readonly string[];
+}

package/src/contract/protocol/diy.ts

@@ -0,0 +1,4 @@
+export const DIY_PRESET_ID = 'workbench-diy';
+export const WORKSHOP_RELATIVE = 'workbench/diy';
+export const WORKSHOP_TITLE = '工作台DIY';
+export const WORKSHOP_PAST_TITLES: readonly string[] = ['DIY 工坊', '工作台自带 · DIY 模块住这儿'];