@dsh-workbench/shared 1.1.7 → 1.1.9

package/src/host/market-index.ts

@@ -1,40 +1,26 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
-import type {
-  MarketIndex,
-  MarketIndexEntry,
-  MarketIndexProblem,
-  MarketIndexVersion,
-} from '../contract/protocol/market-index.js';
+import type { MarketIndex, MarketIndexEntry, MarketIndexProblem } from '../contract/protocol/market-index.js';
 import { MARKET_INDEX_DIR, MARKET_INDEX_FORMAT } from '../contract/protocol/market-index.js';
-
-import type {
-  MarketDocFields,
-  MarketEntryDoc,
-  MarketEntryFile,
-  MarketIndexAssemble,
-  MarketMetaDoc,
-  MarketVersionDoc,
-} from './market-index-doc.js';
-import {
-  marketEntryPath,
-  parseMarketEntryDoc,
-  parseMarketIndexJson,
-  sortMarketVersions,
-} from './market-index-parse.js';
+import type { MarketEntryFile, MarketIndexAssemble } from './market-index-doc.js';
+import { entryUnitOf } from './market-index-claim.js';
+import { marketEntryPath, parseMarketEntryJson, parseMarketIndexJson, sortMarketVersions } from './market-index-parse.js';
 
 export const MARKET_ENTRIES_README_LINES: readonly string[] = [
   '# 索引目录',
   '',
-  '一个包一个目录，一个版本一个文件：`market/<包名>/<版本>.json`；产物在 `artifacts/<包名>/<版本>/`。',
+  '一个包一个文件：`market/<包名>.json`，里面是这一个包的元数据与所有版本；',
+  '',
+  '产物在 `artifacts/<包名>/`（只放最新一版，老版本按条目里的 commit 取历史）。',
   '',
-  '`meta-<epoch>-<随机后缀>.json` 是只改标题 / 署名 / 说明时追加的元数据快照，读取时按 epoch 取最新的一份。',
+  '发布时只改自己包的文件；包与包之间不共享文件。',
 ];
 
 export const MARKET_INDEX_README_LINES: readonly string[] = [
   '# 模块市场索引',
   '',
-  '这个仓库给 DeepSeek Harness 工作台当模块市场索引：条目在 `market/<包名>/<版本>.json`，产物在 `artifacts/<包名>/<版本>/`。',
+  '这个仓库给 DeepSeek Harness 工作台当模块市场索引：一个包一个文件 `market/<包名>.json`，',
+  '产物在 `artifacts/<包名>/`；老仓库的 `market.json` 会在第一次发布时自动拆开。',
   '',
   '## 发布模块',
   '',
@@ -44,8 +30,7 @@ export const MARKET_INDEX_README_LINES: readonly string[] = [
   'dsh-wb-module release --index <本仓库地址> --index-policy artifacts-in-repo',
   '```',
   '',
-  '产物会提交到 `artifacts/<包名>/<版本>/`，条目提交到 `market/<包名>/<版本>.json`。',
-  '发布只新增文件、不改已有文件，两台机器同时发也不会冲突；老条目的 `packages/<包名>/` 路径继续可用。',
+  '发布只会改自己包的那一个文件；包与包之间不会碰同一个文件。',
   '',
   '一个包名归第一次发布的人（条目文件里的 `owner`）。换一个署名发同名会被拒；要换人，先把这一条的 `owner` 改成新的人。',
   '同一个市场里，一个模块 id（`metadata.unit`）只能被一个条目使用；另一个包名想用同一个 id / 产物目录也会被拒。',
@@ -56,14 +41,7 @@ export const MARKET_INDEX_README_LINES: readonly string[] = [
   '',
 ];
 export { marketBranchOk, marketInstallTarget, marketText } from '../lib/market-index.js';
-export type {
-  MarketEntryDoc,
-  MarketEntryDocParse,
-  MarketEntryFile,
-  MarketIndexAssemble,
-  MarketMetaDoc,
-  MarketVersionDoc,
-} from './market-index-doc.js';
+export type { MarketEntryFile, MarketIndexAssemble } from './market-index-doc.js';
 export {
   compareSemver,
   filterMarketIndex,
@@ -71,9 +49,8 @@ export {
   httpUrlProblem,
   marketEntryLabels,
   marketEntryPath,
-  marketMetaPath,
   marketSourceKey,
-  parseMarketEntryDoc,
+  parseMarketEntryJson,
   parseMarketIndex,
   parseMarketIndexJson,
   parseSourceConfig,
@@ -82,116 +59,45 @@ export {
 } from './market-index-parse.js';
 export type { SourceConfigParse } from './market-index-parse.js';
 
-
 function problem(kind: MarketIndexProblem['kind'], detail: string, at?: string): MarketIndexProblem {
   return { kind, detail, ...(at === undefined ? {} : { at }) };
 }
 
-function docFieldsFromEntry(entry: MarketIndexEntry): MarketDocFields {
-  return {
-    name: entry.name,
-    ...(entry.title === undefined ? {} : { title: entry.title }),
-    ...(entry.description === undefined ? {} : { description: entry.description }),
-    ...(entry.author === undefined ? {} : { author: entry.author }),
-    ...(entry.owner === undefined ? {} : { owner: entry.owner }),
-    ...(entry.homepage === undefined ? {} : { homepage: entry.homepage }),
-    ...(entry.icon === undefined ? {} : { icon: entry.icon }),
-    ...(entry.metadata === undefined ? {} : { metadata: entry.metadata }),
-  };
-}
-
-export function marketVersionDocOf(entry: MarketIndexEntry, version: MarketIndexVersion): MarketVersionDoc {
-  return { ...docFieldsFromEntry(entry), ...version };
-}
-
-export function marketMetaDocOf(entry: MarketIndexEntry, epoch: number, at: number): MarketMetaDoc {
-  return { ...docFieldsFromEntry(entry), epoch, publishTimestamp: at };
-}
-
 export function assembleMarketIndex(files: readonly MarketEntryFile[]): MarketIndexAssemble {
   const problems: MarketIndexProblem[] = [];
-  interface Group {
-    versions: Map<string, MarketIndexVersion>;
-    meta: { epoch: number; at: number; path: string; doc: MarketEntryDoc } | undefined;
-    fallback: { at: number; path: string; doc: MarketEntryDoc } | undefined;
-  }
-  const groups = new Map<string, Group>();
+  const entries = new Map<string, MarketIndexEntry>();
   const ordered = [...files].sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
   for (const file of ordered) {
-    let raw: unknown;
-    try {
-      raw = JSON.parse(file.text) as unknown;
-    } catch (error) {
-      problems.push(
-        problem('not-json', `JSON 解析失败：${error instanceof Error ? error.message : String(error)}`, file.path),
-      );
-      continue;
-    }
-    const parsed = parseMarketEntryDoc(raw);
+    if (!file.path.endsWith('.json')) continue;
+    const parsed = parseMarketEntryJson(file.text);
     if (!parsed.ok) {
       for (const one of parsed.problems) problems.push({ ...one, at: file.path });
       continue;
     }
-    const doc = parsed.doc;
-    const group =
-      groups.get(doc.name) ?? { versions: new Map<string, MarketIndexVersion>(), meta: undefined, fallback: undefined };
-    const at = doc.publishTimestamp ?? 0;
-    if ('version' in doc) {
-      if (group.versions.has(doc.version)) {
-        problems.push(problem('duplicate-version', `版本重复：${doc.version}`, file.path));
-      }
-      group.versions.set(doc.version, {
-        version: doc.version,
-        source: doc.source,
-        ...(doc.publishTimestamp === undefined ? {} : { publishTimestamp: doc.publishTimestamp }),
-        ...(doc.engines === undefined ? {} : { engines: doc.engines }),
-      });
-      const newerFallback =
-        group.fallback === undefined ||
-        at > group.fallback.at ||
-        (at === group.fallback.at && file.path > group.fallback.path);
-      if (newerFallback) group.fallback = { at, path: file.path, doc };
-    } else {
-      const epoch = doc.epoch ?? 0;
-      const newer =
-        group.meta === undefined ||
-        epoch > group.meta.epoch ||
-        (epoch === group.meta.epoch && at > group.meta.at) ||
-        (epoch === group.meta.epoch && at === group.meta.at && file.path > group.meta.path);
-      if (newer) group.meta = { epoch, at, path: file.path, doc };
+    const entry = parsed.entry;
+    if (entries.has(entry.name)) {
+      problems.push(problem('duplicate-name', `插件名重复：${entry.name}`, file.path));
+      continue;
     }
-    groups.set(doc.name, group);
+    entries.set(entry.name, { ...entry, versions: sortMarketVersions(entry.versions) });
   }
   if (problems.length > 0) return { ok: false, problems };
-  const plugins: MarketIndexEntry[] = [...groups.entries()].map(([name, group]) => {
-    const meta = group.meta?.doc ?? group.fallback?.doc;
-    return {
-      name,
-      versions: sortMarketVersions([...group.versions.values()]),
-      ...(meta?.title === undefined ? {} : { title: meta.title }),
-      ...(meta?.description === undefined ? {} : { description: meta.description }),
-      ...(meta?.author === undefined ? {} : { author: meta.author }),
-      ...(meta?.owner === undefined ? {} : { owner: meta.owner }),
-      ...(meta?.homepage === undefined ? {} : { homepage: meta.homepage }),
-      ...(meta?.icon === undefined ? {} : { icon: meta.icon }),
-      ...(meta?.metadata === undefined ? {} : { metadata: meta.metadata }),
-    };
-  });
-  plugins.sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
+  const plugins = [...entries.values()].sort((left, right) => (left.name < right.name ? -1 : left.name > right.name ? 1 : 0));
   return { ok: true, index: { format: MARKET_INDEX_FORMAT, plugins } };
 }
 
+export function marketEntryFileOf(entry: MarketIndexEntry, dir: string = MARKET_INDEX_DIR): MarketEntryFile {
+  return { path: marketEntryPath(dir, entry.name), text: `${JSON.stringify(entry, null, 2)}\n` };
+}
+
 export function marketEntryFilesOf(index: MarketIndex, dir: string = MARKET_INDEX_DIR): readonly MarketEntryFile[] {
-  const files: MarketEntryFile[] = [];
-  for (const entry of index.plugins) {
-    for (const version of entry.versions) {
-      files.push({
-        path: marketEntryPath(dir, entry.name, version.version),
-        text: `${JSON.stringify(marketVersionDocOf(entry, version), null, 2)}\n`,
-      });
-    }
-  }
-  return files;
+  return index.plugins.map((entry) => marketEntryFileOf(healedUnit(entry), dir));
+}
+
+function healedUnit(entry: MarketIndexEntry): MarketIndexEntry {
+  if (entry.metadata?.unit !== undefined) return entry;
+  const unit = entryUnitOf(entry);
+  return unit === undefined ? entry : { ...entry, metadata: { ...entry.metadata, unit } };
 }
 
 export function collectMarketEntryFiles(dir: string): readonly MarketEntryFile[] {

package/src/host/module-root.ts

@@ -0,0 +1,6 @@
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export function packageRootOf(moduleUrl: string): string {
+  return dirname(dirname(dirname(fileURLToPath(moduleUrl))));
+}

package/src/host/npm-registry.ts

@@ -0,0 +1,21 @@
+function envValue(
+  env: Readonly<Record<string, string | undefined>>,
+  name: string,
+): { readonly ok: true; readonly value: string } | { readonly ok: false } {
+  const value = env[name]?.trim();
+  return value === undefined || value === '' ? { ok: false } : { ok: true, value };
+}
+
+export function npmRegistryOf(
+  source: { readonly registryEnv?: string; readonly registryDefault?: string },
+  env: Readonly<Record<string, string | undefined>>,
+): { readonly ok: true; readonly value: string } | { readonly ok: false; readonly env: string } {
+  const name = source.registryEnv ?? '';
+  if (name !== '') {
+    const fromEnv = envValue(env, name);
+    if (fromEnv.ok) return fromEnv;
+  }
+  const fallback = source.registryDefault?.trim();
+  if (fallback === undefined || fallback === '') return { ok: false, env: name };
+  return { ok: true, value: fallback };
+}

package/src/host/package-content.ts

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import type { DshShell } from '../api/dsh.js';
+import { INSTALL_TIMEOUT_MS } from '../config/constants.js';
+import { parseJsonLoose } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
+import { runShell } from './shell.js';
+import { splitNpmSpec } from './package-kind.js';
+import { localDirOf } from './local-declaration.js';
+
+function cacheFlag(cacheDir: string | undefined): string {
+  return cacheDir === undefined ? '' : ` --cache ${quoteShellArg(cacheDir)}`;
+}
+
+function packedFileFrom(stdout: string, root: string): string | undefined {
+  const parsed = parseJsonLoose(stdout);
+  if (Array.isArray(parsed)) {
+    const first: unknown = parsed[0];
+    const filename =
+      typeof first === 'object' && first !== null ? (first as { filename?: unknown }).filename : undefined;
+    if (typeof filename === 'string' && filename.trim() !== '') {
+      const at = path.join(root, path.basename(filename.trim()));
+      if (fs.existsSync(at)) return at;
+    }
+  }
+  try {
+    const found = fs.readdirSync(root).filter((name) => name.endsWith('.tgz'));
+    return found.length === 1 ? path.join(root, found[0] ?? '') : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function withPackageDir<T>(
+  options: {
+    readonly shell?: DshShell | undefined;
+    readonly spec: string;
+    readonly registry?: string | undefined;
+    readonly cacheDir?: string | undefined;
+  },
+  visit: (dir: string) => T,
+): Promise<T | undefined> {
+  const local = localDirOf(options.spec);
+  if (local !== undefined) return visit(local);
+  if (splitNpmSpec(options.spec) === undefined) return undefined;
+  const shell = options.shell;
+  if (shell === undefined) return undefined;
+
+  let root: string;
+  try {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'wb-package-'));
+  } catch {
+    return undefined;
+  }
+  try {
+    const at = options.registry === undefined ? '' : ` --registry ${quoteShellArg(options.registry)}`;
+    const packed = await runShell(
+      shell,
+      `npm pack ${quoteShellArg(options.spec)} --ignore-scripts --json --pack-destination ${quoteShellArg(root)}${cacheFlag(options.cacheDir)}${at}`,
+      { timeoutMs: INSTALL_TIMEOUT_MS },
+    ).catch(() => undefined);
+    if (packed === undefined || packed.exitCode !== 0) return undefined;
+    const file = packedFileFrom(packed.stdout, root);
+    if (file === undefined) return undefined;
+    const unpacked = await runShell(shell, `tar -xzf ${quoteShellArg(file)} -C ${quoteShellArg(root)}`, {
+      timeoutMs: INSTALL_TIMEOUT_MS,
+    }).catch(() => undefined);
+    if (unpacked === undefined || unpacked.exitCode !== 0) return undefined;
+    const dir = path.join(root, 'package');
+    if (!fs.existsSync(dir)) return undefined;
+    return visit(dir);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}

package/src/host/package-kind.ts

@@ -0,0 +1,63 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export { splitNpmSpec } from './spec.js';
+export type { NpmRef } from './spec.js';
+import { dshRecordOf, packageManifestOf, packageNameOf } from './local-declaration.js';
+import { pluginAt } from './plugin.js';
+
+export type PackageKind = 'runtime-plugin' | 'dsh-bundle' | 'both' | 'neither';
+
+export interface PackageVerdict {
+  readonly kind: PackageKind;
+  readonly pkg?: string;
+  readonly pluginName?: string;
+}
+
+function asRecord(value: unknown): Readonly<Record<string, unknown>> | undefined {
+  return typeof value === 'object' && value !== null ? (value as Readonly<Record<string, unknown>>) : undefined;
+}
+
+export function isCommandFile(name: string): boolean {
+  if (name.endsWith('.d.ts') || name.endsWith('.test.ts')) return false;
+  if (name.endsWith('.d.js')) return false;
+  return name.endsWith('.ts') || name.endsWith('.js');
+}
+
+export function pluginManifestOf(dir: string, manifestFile: string): Readonly<Record<string, unknown>> | undefined {
+  try {
+    const parsed: unknown = JSON.parse(fs.readFileSync(path.join(dir, manifestFile), 'utf8'));
+    if (Array.isArray(parsed)) return undefined;
+    return asRecord(parsed);
+  } catch {
+    return undefined;
+  }
+}
+
+export function hasCommandFile(dir: string): boolean {
+  try {
+    return fs.readdirSync(dir).some(isCommandFile);
+  } catch {
+    return false;
+  }
+}
+
+export function dshMarkersOf(raw: unknown): boolean {
+  const record = asRecord(raw);
+  return record !== undefined && ('bundle' in record || 'workbench' in record);
+}
+
+export function verdictOf(dir: string, manifestFile: string): PackageVerdict | undefined {
+  const plugin = pluginAt(dir, manifestFile);
+  if (packageManifestOf(dir) === undefined && plugin === undefined) return undefined;
+  const dsh = dshMarkersOf(dshRecordOf(dir));
+  const kind: PackageKind =
+    plugin !== undefined && dsh ? 'both' : plugin !== undefined ? 'runtime-plugin' : dsh ? 'dsh-bundle' : 'neither';
+  const pkg = packageNameOf(dir);
+  return {
+    kind,
+    ...(pkg === undefined ? {} : { pkg }),
+    ...(plugin?.name === undefined ? {} : { pluginName: plugin.name }),
+  };
+}
+
+

package/src/host/package-route.ts

@@ -0,0 +1,93 @@
+import type { DshShell } from '../api/dsh.js';
+import { VERSION_CHECK_TTL_MS } from '../config/constants.js';
+import { dshMarkersOf, splitNpmSpec, verdictOf, type PackageVerdict } from './package-kind.js';
+import { withPackageDir } from './package-content.js';
+import { localDirOf } from './local-declaration.js';
+
+export type PackageRouteKind = 'runtime-plugin' | 'dsh-bundle' | 'neither';
+
+export interface PackageRoute {
+  readonly kind: PackageRouteKind;
+  readonly pkg?: string;
+  readonly pluginName?: string;
+}
+
+function routeOfVerdict(verdict: PackageVerdict, fallback?: string): PackageRoute {
+  const pkg = verdict.pkg ?? fallback;
+  if (verdict.kind === 'neither') return { kind: 'neither', ...(pkg === undefined ? {} : { pkg }) };
+  if (verdict.kind === 'dsh-bundle' || verdict.kind === 'both') return { kind: 'dsh-bundle' };
+  return {
+    kind: 'runtime-plugin',
+    ...(pkg === undefined ? {} : { pkg }),
+    ...(verdict.pluginName === undefined ? {} : { pluginName: verdict.pluginName }),
+  };
+}
+
+export interface PackageRouter {
+  packageRouteOf(options: RouteOptions): Promise<PackageRoute | undefined>;
+  reset(): void;
+}
+
+interface RouteOptions {
+  readonly spec: string;
+  readonly shell?: DshShell | undefined;
+  readonly registry?: string | undefined;
+  readonly force?: boolean;
+}
+
+export interface PackageRouterOptions {
+  readonly manifestFile: string;
+  readonly cacheDir?: string | undefined;
+  readonly dshLookup?: ((options: { shell: DshShell; name: string; registry: string }) => Promise<{ readable: boolean; raw: unknown }>) | undefined;
+}
+
+export function createPackageRouter(options: PackageRouterOptions): PackageRouter {
+  const cache = new Map<string, { at: number; route: PackageRoute | null }>();
+  return {
+    packageRouteOf: (routeOptions) => routeOf(cache, options, routeOptions),
+    reset: () => {
+      cache.clear();
+    },
+  };
+}
+
+async function routeOf(
+  cache: Map<string, { at: number; route: PackageRoute | null }>,
+  options: PackageRouterOptions,
+  routeOptions: RouteOptions,
+): Promise<PackageRoute | undefined> {
+  const local = localDirOf(routeOptions.spec);
+  if (local !== undefined) {
+    const verdict = verdictOf(local, options.manifestFile);
+    return verdict === undefined ? undefined : routeOfVerdict(verdict, splitNpmSpec(routeOptions.spec)?.name);
+  }
+
+  const ref = splitNpmSpec(routeOptions.spec);
+  if (ref === undefined) return undefined;
+  const shell = routeOptions.shell;
+  const registry = routeOptions.registry;
+  if (shell === undefined || registry === undefined) return undefined;
+
+  const key = `${registry}|${routeOptions.spec}`;
+  const hit = cache.get(key);
+  if (routeOptions.force !== true && hit !== undefined && Date.now() - hit.at < VERSION_CHECK_TTL_MS) {
+    return hit.route ?? undefined;
+  }
+
+  const found =
+    options.dshLookup === undefined
+      ? { readable: false, raw: undefined }
+      : await options.dshLookup({ shell, name: routeOptions.spec, registry });
+  let route: PackageRoute | undefined;
+  if (found.readable && dshMarkersOf(found.raw)) {
+    route = { kind: 'dsh-bundle' };
+  } else {
+    const verdict = await withPackageDir(
+      { shell, spec: routeOptions.spec, registry, ...(options.cacheDir === undefined ? {} : { cacheDir: options.cacheDir }) },
+      (dir) => verdictOf(dir, options.manifestFile),
+    );
+    route = verdict === undefined ? undefined : routeOfVerdict(verdict, ref.name);
+  }
+  cache.set(key, { at: Date.now(), route: route ?? null });
+  return route;
+}

package/src/host/paths.ts

@@ -1,55 +1,30 @@
-import { delimiter } from 'node:path';
 import { workbenchRoot } from './data-root.js';
 
-export function isolatedRoot(): string {
-  return `${workbenchRoot()}/opencli`;
-}
-
-export function isolatedHome(): string {
-  return `${isolatedRoot()}/home`;
-}
-
-export function vendorPrefix(): string {
-  return `${isolatedRoot()}/plugins-npm`;
-}
-
-export function vendorPluginsDir(): string {
-  return `${vendorPrefix()}/node_modules`;
-}
-
-export function libsPrefix(): string {
-  return `${isolatedRoot()}/libs`;
-}
-
-export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
-
-export function toolchainOpencliDir(): string {
-  return `${isolatedRoot()}/toolchain/node_modules/${OPENCLI_NPM_PACKAGE}`;
-}
-
-export function vendorPeerLink(): { readonly dir: string; readonly parent: string } {
-  const base = `${vendorPrefix()}/node_modules`;
-  const [scope] = OPENCLI_NPM_PACKAGE.split('/');
-  return { dir: `${base}/${OPENCLI_NPM_PACKAGE}`, parent: `${base}/${scope}` };
-}
-
-export function npmCacheDir(): string {
-  return `${isolatedRoot()}/npm-cache`;
-}
-
-export function libsBinDir(): string {
-  return `${libsPrefix()}/node_modules/.bin`;
-}
-
-/**
- * 把隔离运行时的共用依赖 bin 目录放到 PATH 最前面（可执行文件都从这儿找）。
- * @param env 改哪份环境（默认当前进程）。
- * @returns 真的插进去了就 `true`；已经在里面就 `false`。
- */
-export function ensureLibsBinOnPath(env: NodeJS.ProcessEnv = process.env): boolean {
-  const dir = libsBinDir();
-  const parts = (env.PATH ?? '').split(delimiter).filter((one) => one !== '');
-  if (parts.includes(dir)) return false;
-  env.PATH = [dir, ...parts].join(delimiter);
-  return true;
+export interface RuntimeLayout {
+  readonly root: string;
+  readonly home: string;
+  readonly vendorPrefix: string;
+  readonly vendorPluginsDir: string;
+  readonly libsPrefix: string;
+  readonly libsBinDir: string;
+  readonly npmCacheDir: string;
+}
+
+export function runtimeRootOf(id: string): string {
+  return `${workbenchRoot()}/${id}`;
+}
+
+export function runtimeLayoutOf(id: string): RuntimeLayout {
+  const root = runtimeRootOf(id);
+  const vendorPrefix = `${root}/plugins-npm`;
+  const libsPrefix = `${root}/libs`;
+  return {
+    root,
+    home: `${root}/home`,
+    vendorPrefix,
+    vendorPluginsDir: `${vendorPrefix}/node_modules`,
+    libsPrefix,
+    libsBinDir: `${libsPrefix}/node_modules/.bin`,
+    npmCacheDir: `${root}/npm-cache`,
+  };
 }

package/src/host/platform.ts

@@ -41,7 +41,7 @@ export function hostSurface(input: HostSurfaceInput = {}): HostSurface {
     restartHint: deployment === 'desktop' ? '退出并重开 Desktop' : '重启一次 dsh',
     toolchain: {
       node: { source: deployment === 'desktop' ? 'desktop-shim' : 'path' },
-      npm: { neededFor: 'opencli-install' },
+      npm: { neededFor: 'runtime-install' },
       pnpm: { neededFor: 'workshop', expectedMajor: 10 },
     },
   };