@dsh-workbench/adapter-probe 1.1.14-beta.1 → 1.1.14

package/dist/bootstrap-run.d.ts

@@ -0,0 +1,31 @@
+import type { Seam, ShellKind } from '@dsh-workbench/shared/host';
+export interface BootstrapEnvOptions {
+    readonly opencliRoot?: string | undefined;
+    readonly realHome?: string | undefined;
+    readonly parent?: NodeJS.ProcessEnv | undefined;
+    readonly shellKind?: ShellKind | undefined;
+}
+export interface BootstrapSpawnOptions {
+    readonly env: Readonly<Record<string, string>>;
+    readonly timeout: number;
+}
+export interface BootstrapSpawnResult {
+    readonly exitCode: number | null;
+    readonly timedOut?: boolean | undefined;
+    readonly stdout: string;
+    readonly stderr: string;
+}
+export type BootstrapSpawn = (file: string, args: readonly string[], options: BootstrapSpawnOptions) => Promise<BootstrapSpawnResult>;
+export interface BootstrapRunOptions {
+    readonly timeoutMs: number;
+    readonly env?: Readonly<Record<string, string>> | undefined;
+    readonly shellKind?: ShellKind | undefined;
+    readonly spawn?: BootstrapSpawn | undefined;
+    readonly seam?: Seam | undefined;
+}
+export interface BootstrapRunResult {
+    readonly ok: boolean;
+    readonly detail: string;
+}
+export declare function bootstrapEnv(options?: BootstrapEnvOptions): Record<string, string>;
+export declare function runBootstrapCommand(line: string, options: BootstrapRunOptions): Promise<BootstrapRunResult>;

package/dist/bootstrap-run.js

@@ -0,0 +1,59 @@
+import { homedir } from 'node:os';
+import { isolatedRoot } from '@dsh-workbench/adapter-runtime';
+import { bootstrapEnvOf, tailLines } from '@dsh-workbench/shared/host';
+import { desktopRuntimeEnvPath } from './desktop-runtime.js';
+import { currentShellKind } from './platform.js';
+export function bootstrapEnv(options = {}) {
+    const parent = options.parent ?? process.env;
+    return bootstrapEnvOf({
+        root: options.opencliRoot ?? isolatedRoot(),
+        realHome: options.realHome ?? homedir(),
+        shellKind: options.shellKind ?? currentShellKind(),
+        parent,
+        path: desktopRuntimeEnvPath(parent.PATH),
+    });
+}
+function commandArgsOf(line, shellKind) {
+    return shellKind === 'pwsh'
+        ? { file: 'pwsh', args: ['-NoProfile', '-NonInteractive', '-Command', line] }
+        : { file: 'bash', args: ['-c', line] };
+}
+async function seamSpawn(seam, line, shellKind, env, timeoutMs) {
+    if (seam === undefined)
+        throw new Error('没有执行缝，自举命令起不来');
+    const result = await seam.run({
+        command: line,
+        shellKind,
+        intent: { kind: 'host' },
+        env,
+        timeoutMs,
+    });
+    return {
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        stdout: result.stdout,
+        stderr: result.stderr,
+    };
+}
+export async function runBootstrapCommand(line, options) {
+    const shellKind = options.shellKind ?? currentShellKind();
+    const env = { ...bootstrapEnv({ shellKind }), ...(options.env ?? {}) };
+    const command = commandArgsOf(line, shellKind);
+    try {
+        const result = options.spawn === undefined
+            ? await seamSpawn(options.seam, line, shellKind, env, options.timeoutMs)
+            : await options.spawn(command.file, command.args, { env, timeout: options.timeoutMs });
+        if (result.timedOut === true)
+            return { ok: false, detail: `超时（${String(options.timeoutMs)} ms）：${line}` };
+        if (result.exitCode === 0)
+            return { ok: true, detail: tailLines(result.stdout, 1) };
+        const detail = tailLines(result.stderr || result.stdout, 4);
+        return {
+            ok: false,
+            detail: detail === '' ? `没跑通（退出码 ${String(result.exitCode)}）：${line}` : detail,
+        };
+    }
+    catch (error) {
+        return { ok: false, detail: `${String(error)}：${line}` };
+    }
+}

package/dist/browser-wake.d.ts

@@ -1,11 +1,11 @@
-import type { DshShell } from '@dsh-workbench/shared';
+import { type Seam } from '@dsh-workbench/shared/host';
 import type { WakeBrowserReply } from '@dsh-workbench/shared/contract/protocol/preflight-wake';
 export interface DesktopBrowser {
     observe(): Promise<void>;
     wake(): Promise<WakeBrowserReply>;
 }
 export declare function createDesktopBrowser(options: {
-    shell: DshShell;
+    seam: Seam;
     command: string;
     stateFile: string;
     platform?: string;

package/dist/browser-wake.js

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join, win32 } from 'node:path';
+import { join, win32 } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
-import { quoteShellArg, runShell } from '@dsh-workbench/shared/host';
+import { noWrite, now, quoteShellArg, writeJsonFile } from '@dsh-workbench/shared/host';
 const BROWSER_IDS = ['chrome', 'edge', 'brave', 'chromium', 'vivaldi'];
 const BROWSERS = [
     {
@@ -62,13 +62,10 @@ export function createDesktopBrowser(options) {
     const pollMs = options.pollMs ?? POLL_MS;
     const command = options.command;
     async function run(line, timeoutMs) {
-        try {
-            const result = await runShell(options.shell, line, { timeoutMs });
-            return { ok: result.exitCode === 0 && !result.timedOut, stdout: result.stdout };
-        }
-        catch {
-            return { ok: false, stdout: '' };
-        }
+        const result = await options.seam
+            .run({ command: line, intent: noWrite(), retry: 'safe', timeoutMs, bestEffort: true })
+            .catch(() => undefined);
+        return { ok: result !== undefined && result.exitCode === 0 && !result.timedOut, stdout: result?.stdout ?? '' };
     }
     function winCandidates(id) {
         const programFiles = env.ProgramFiles ?? env.PROGRAMFILES ?? 'C:\\Program Files';
@@ -116,8 +113,7 @@ export function createDesktopBrowser(options) {
     }
     function save(id) {
         try {
-            mkdirSync(dirname(options.stateFile), { recursive: true });
-            writeFileSync(options.stateFile, `${JSON.stringify({ browser: id }, null, 2)}\n`, 'utf8');
+            writeJsonFile(options.stateFile, { browser: id });
         }
         catch {
             return;
@@ -172,13 +168,13 @@ export function createDesktopBrowser(options) {
         return 'unknown';
     }
     async function waitConnected(ms) {
-        const deadline = Date.now() + ms;
+        const deadline = now() + ms;
         for (;;) {
             if ((await daemonStatus()) === 'connected')
                 return true;
-            if (Date.now() >= deadline)
+            if (now() >= deadline)
                 return false;
-            await delay(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+            await delay(Math.min(pollMs, Math.max(0, deadline - now())));
         }
     }
     function pickTarget(now) {

package/dist/desktop-runtime.d.ts

@@ -0,0 +1,14 @@
+export interface PnpmProcess {
+    readonly versions: {
+        readonly electron?: string | undefined;
+        readonly node?: string | undefined;
+    };
+    readonly resourcesPath?: string | undefined;
+}
+export declare function desktopResourcesDir(proc?: PnpmProcess): string | undefined;
+export declare function desktopPnpmPath(proc?: PnpmProcess, exists?: (path: string) => boolean): string | undefined;
+export declare function desktopBundledBins(proc?: PnpmProcess, exists?: (path: string) => boolean): readonly string[];
+export declare function desktopNodeExecutable(proc?: PnpmProcess, exists?: (path: string) => boolean): string | undefined;
+export declare function desktopRuntimeEnvPath(parentPath: string | undefined, proc?: PnpmProcess, exists?: (path: string) => boolean, separator?: string): string | undefined;
+export declare function desktopRuntimeEnv(parent?: NodeJS.ProcessEnv, proc?: PnpmProcess, exists?: (path: string) => boolean): Record<string, string>;
+export declare function desktopPnpmVersion(proc?: PnpmProcess, exists?: (path: string) => boolean): string | undefined;

package/dist/desktop-runtime.js

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { inheritedEnvOf, pathWithBinsOf } from '@dsh-workbench/shared/host';
+import { hostSurface } from './platform.js';
+export function desktopResourcesDir(proc = process) {
+    if (hostSurface({ proc }).deployment !== 'desktop')
+        return undefined;
+    const declared = proc.resourcesPath;
+    return declared === undefined || declared === '' ? undefined : declared;
+}
+export function desktopPnpmPath(proc = process, exists = existsSync) {
+    const resources = desktopResourcesDir(proc);
+    if (resources === undefined)
+        return undefined;
+    const path = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'pnpm', 'bin', 'pnpm.cjs');
+    return exists(path) ? path : undefined;
+}
+export function desktopBundledBins(proc = process, exists = existsSync) {
+    const resources = desktopResourcesDir(proc);
+    if (resources === undefined)
+        return [];
+    const dependencies = join(resources, 'runtime', 'primary-runtime', 'dependencies');
+    return [join(dependencies, 'node', 'bin'), join(dependencies, 'pnpm', 'bin')].filter((dir) => exists(dir));
+}
+export function desktopNodeExecutable(proc = process, exists = existsSync) {
+    const resources = desktopResourcesDir(proc);
+    if (resources === undefined)
+        return undefined;
+    const bin = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'node', 'bin');
+    return ['node.exe', 'node'].map((name) => join(bin, name)).find((path) => exists(path));
+}
+export function desktopRuntimeEnvPath(parentPath, proc = process, exists = existsSync, separator = delimiter) {
+    const bins = desktopBundledBins(proc, exists);
+    if (bins.length === 0)
+        return undefined;
+    const parts = (parentPath ?? '').split(separator).filter((part) => part !== '' && !bins.includes(part));
+    return [...bins, ...parts].join(separator);
+}
+export function desktopRuntimeEnv(parent = process.env, proc = process, exists = existsSync) {
+    const bins = desktopBundledBins(proc, exists);
+    if (bins.length === 0)
+        return {};
+    return { ...inheritedEnvOf(parent), PATH: pathWithBinsOf(parent.PATH, bins) };
+}
+export function desktopPnpmVersion(proc = process, exists = existsSync) {
+    const resources = desktopResourcesDir(proc);
+    if (resources === undefined)
+        return undefined;
+    const manifest = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'pnpm', 'package.json');
+    if (!exists(manifest))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(manifest, 'utf8'));
+        return typeof parsed.version === 'string' ? parsed.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/diy-preset-health.js

@@ -1,3 +1,4 @@
+import { now } from '@dsh-workbench/shared/host';
 import { DIY_PRESET_ID } from '@dsh-workbench/shared/contract/protocol/diy';
 export const DIY_UPGRADE_COMMAND = 'npm i -g @deepseek-ai/dsh@latest';
 export function brokenRowsOf(detail) {
@@ -29,7 +30,7 @@ export function createDiyPresetProbe(ctx, options = {}) {
         const registry = ctx.get('agentPresets');
         if (registry === undefined || typeof registry.list !== 'function')
             return undefined;
-        const until = Date.now() + deadlineMs;
+        const until = now() + deadlineMs;
         for (;;) {
             const rows = await registry.list().catch(() => undefined);
             if (rows === undefined)
@@ -37,7 +38,7 @@ export function createDiyPresetProbe(ctx, options = {}) {
             const verdict = diyPresetVerdictOf(rows);
             if (verdict !== undefined)
                 return verdict;
-            if (Date.now() >= until)
+            if (now() >= until)
                 return undefined;
             await new Promise((resolve) => setTimeout(resolve, everyMs));
         }

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+export * from './bootstrap-run.js';
 export * from './browser-wake.js';
 export * from './diy-preset-health.js';
 export * from './platform.js';
@@ -8,6 +9,7 @@ export * from './probe-libs.js';
 export * from './probe-units.js';
 export * from './probe-verdict.js';
 export * from './runtime-seed.js';
+export * from './desktop-runtime.js';
 export * from './toolchain.js';
 export * from './toolchain-probe.js';
 export * from './version-range.js';

package/dist/index.js

@@ -1,3 +1,4 @@
+export * from './bootstrap-run.js';
 export * from './browser-wake.js';
 export * from './diy-preset-health.js';
 export * from './platform.js';
@@ -8,6 +9,7 @@ export * from './probe-libs.js';
 export * from './probe-units.js';
 export * from './probe-verdict.js';
 export * from './runtime-seed.js';
+export * from './desktop-runtime.js';
 export * from './toolchain.js';
 export * from './toolchain-probe.js';
 export * from './version-range.js';

package/dist/platform.d.ts

@@ -1,3 +1,5 @@
+import type { ShellKind } from '@dsh-workbench/shared/host';
 import type { HostOs } from '@dsh-workbench/shared/contract/protocol/platform';
-export { hostOsOf, hostSurface, profileNameOf, type HostSurfaceInput } from '@dsh-workbench/shared/host';
+export { hostOsOf, hostSurface, profileNameOf, shellKindOf, type HostSurfaceInput } from '@dsh-workbench/shared/host';
 export declare function currentHostOs(): HostOs;
+export declare function currentShellKind(): ShellKind;

package/dist/platform.js

@@ -1,5 +1,8 @@
-import { hostOsOf } from '@dsh-workbench/shared/host';
-export { hostOsOf, hostSurface, profileNameOf } from '@dsh-workbench/shared/host';
+import { hostOsOf, shellKindOf } from '@dsh-workbench/shared/host';
+export { hostOsOf, hostSurface, profileNameOf, shellKindOf } from '@dsh-workbench/shared/host';
 export function currentHostOs() {
     return hostOsOf(process.platform);
 }
+export function currentShellKind() {
+    return shellKindOf(process.platform);
+}

package/dist/preflight-route.d.ts

@@ -1,10 +1,11 @@
-import type { DshHostContext, DshShell, RuntimeCapabilities } from '@dsh-workbench/shared';
+import type { DshHostContext, RuntimeCapabilities } from '@dsh-workbench/shared';
 import type { RouteTable } from '@dsh-workbench/shared/host';
+import { type Seam } from '@dsh-workbench/shared/host';
 import { type DesktopBrowser } from './browser-wake.js';
 export declare function registerPreflight(input: {
     routes: RouteTable;
     ctx: DshHostContext;
-    shell: DshShell;
+    seam: Seam;
     runtimeCommands: Readonly<Record<string, string>>;
     runtimeCapabilities?: RuntimeCapabilities | undefined;
     runtimeCheck?: (() => Promise<{

package/dist/preflight-route.js

@@ -1,7 +1,9 @@
 import { basename, join } from 'node:path';
-import { INSTALL_TIMEOUT_MS, preflightHandler, runShell, tailLines, workbenchRoot } from '@dsh-workbench/shared/host';
+import { PREFLIGHT_INSTALL_TIMEOUT_MS, preflightHandler, workbenchRoot } from '@dsh-workbench/shared/host';
 import { WAKE_BROWSER_ROUTE } from '@dsh-workbench/shared/contract/protocol/preflight-wake';
+import { runBootstrapCommand } from './bootstrap-run.js';
 import { createDiyPresetProbe } from './diy-preset-health.js';
+import { opencliInstallCommand } from './install.js';
 import { hostSurface } from './platform.js';
 import { createPreflight } from './preflight.js';
 import { probeDesktopToolchain } from './toolchain-probe.js';
@@ -15,7 +17,7 @@ function desktopBrowserOf(input) {
     if (!surface.capabilities.browserWake)
         return undefined;
     return createDesktopBrowser({
-        shell: input.shell,
+        seam: input.seam,
         command: input.command,
         stateFile: join(workbenchRoot(), 'browser.json'),
         ...(input.ctx.logger === undefined ? {} : { logger: input.ctx.logger }),
@@ -23,24 +25,31 @@ function desktopBrowserOf(input) {
 }
 export function registerPreflight(input) {
     const command = input.runtimeCommands['opencli'] ?? Object.values(input.runtimeCommands)[0] ?? 'opencli';
-    const installCommand = process.env.DSH_WORKBENCH_OPENCLI_INSTALL;
+    const configuredInstall = process.env.DSH_WORKBENCH_OPENCLI_INSTALL;
+    const installCommand = configuredInstall === undefined || configuredInstall === ''
+        ? opencliInstallCommand()
+        : configuredInstall;
     const desktopBrowser = input.desktopBrowser ??
         desktopBrowserOf({
             ctx: input.ctx,
-            shell: input.shell,
+            seam: input.seam,
             command,
         });
     const preflight = createPreflight({
-        shell: input.shell,
+        seam: input.seam,
         command,
-        ...(installCommand === undefined || installCommand === '' ? {} : { installCommand }),
+        installCommand,
+        install: () => runBootstrapCommand(installCommand, {
+            timeoutMs: PREFLIGHT_INSTALL_TIMEOUT_MS,
+            seam: input.seam,
+        }),
         logger: input.ctx.logger,
         warmReads: input.warmReads,
         ...(input.runtimeCapabilities === undefined ? {} : { capabilities: input.runtimeCapabilities }),
         ...(input.runtimeCheck === undefined ? {} : { runtimeCheck: input.runtimeCheck }),
         ...(input.runtimeLabel === undefined ? {} : { runtimeLabel: input.runtimeLabel }),
         probeDiy: createDiyPresetProbe(input.ctx),
-        probeToolchain: () => probeDesktopToolchain(input.shell),
+        probeToolchain: () => probeDesktopToolchain(input.seam),
         provisionPnpm: async () => {
             const root = runtimeSeedRootOf(input.ctx);
             if (root === null)
@@ -49,13 +58,10 @@ export function registerPreflight(input) {
                 root,
                 pnpm: process.env.DSH_WB_PNPM?.trim() || 'pnpm',
                 npm: 'npm',
-                run: async (command) => {
-                    const ran = await runShell(input.shell, command, { timeoutMs: INSTALL_TIMEOUT_MS });
-                    return {
-                        ok: ran.exitCode === 0 && !ran.timedOut,
-                        detail: tailLines(ran.stderr || ran.stdout, 3),
-                    };
-                },
+                run: (command) => runBootstrapCommand(command, {
+                    timeoutMs: PREFLIGHT_INSTALL_TIMEOUT_MS,
+                    seam: input.seam,
+                }),
             });
             if (result.ok && result.binDir !== undefined) {
                 prependPath(result.binDir);

package/dist/preflight.d.ts

@@ -1,4 +1,5 @@
-import type { DshShell, RuntimeCapabilities } from '@dsh-workbench/shared';
+import type { RuntimeCapabilities } from '@dsh-workbench/shared';
+import { type Seam } from '@dsh-workbench/shared/host';
 import type { DiyPresetVerdict } from './diy-preset-health.js';
 import { type LocalNpmProvision, type LocalPnpmProvision } from './toolchain.js';
 import type { ToolchainReport } from './toolchain-probe.js';
@@ -55,7 +56,7 @@ export declare function canWarm(bridge: {
     issues: readonly PreflightBridgeIssue[];
 }): boolean;
 export declare function createPreflight(options: {
-    shell: DshShell;
+    seam: Seam;
     command?: string;
     installCommand?: string;
     logger?: {

package/dist/preflight.js

@@ -1,7 +1,7 @@
-import { INSTALL_TIMEOUT_MS, OPENCLI_TIMEOUT_MS, PREFLIGHT_FRESH_MS, PREFLIGHT_VERSION_TIMEOUT_MS, WARM_TIMEOUT_MS, } from '@dsh-workbench/shared/host';
+import { PREFLIGHT_DOCTOR_TIMEOUT_MS, PREFLIGHT_FRESH_MS, PREFLIGHT_INSTALL_TIMEOUT_MS, PREFLIGHT_VERSION_TIMEOUT_MS, WARM_TIMEOUT_MS, now } from '@dsh-workbench/shared/host';
 import { tailLines } from '@dsh-workbench/shared/host';
 import { opencliCommandLine } from '@dsh-workbench/adapter-runtime';
-import { runShell } from '@dsh-workbench/shared/host';
+import { productWrite } from '@dsh-workbench/shared/host';
 import { DIY_UPGRADE_COMMAND } from './diy-preset-health.js';
 import { opencliInstallCommand } from './install.js';
 import { LOCAL_PNPM_VERSION } from './toolchain.js';
@@ -29,7 +29,7 @@ function step(id, label) {
     return { id, status: 'pending', ...(label === undefined || label === '' ? {} : { label }) };
 }
 export function createPreflight(options) {
-    const { shell, command = 'opencli', logger } = options;
+    const { seam, command = 'opencli', logger } = options;
     const capabilities = options.capabilities ?? { console: true, pluginMarket: true, browserBridge: true };
     const withConsole = capabilities.console;
     const withBridge = capabilities.browserBridge;
@@ -66,14 +66,14 @@ export function createPreflight(options) {
     let current = {
         phase: 'idle',
         steps: steps(),
-        at: Date.now(),
+        at: now(),
         log: [],
         ...(options.desktopBrowser === undefined ? {} : { canWakeBrowser: true }),
     };
     let running = null;
     let shellStalled = false;
     function set(next) {
-        current = { ...current, ...next, log: [...logLines], at: Date.now() };
+        current = { ...current, ...next, log: [...logLines], at: now() };
         return current;
     }
     function patchStep(id, patch) {
@@ -82,13 +82,13 @@ export function createPreflight(options) {
     function hostFailure(detail) {
         return set({ phase: 'failed', error: detail, failure: 'host', guidance: 'host' });
     }
-    async function exec(stepId, commandLine, timeoutMs) {
+    async function exec(stepId, commandLine, timeoutMs, retry = 'safe') {
         if (shellStalled) {
             return { kind: 'stalled', detail: `前一条命令就没交回结果，这一步没跑：${commandLine}` };
         }
         appendLog(stepId, `> ${commandLine}`);
         try {
-            const result = await runShell(shell, commandLine, { timeoutMs });
+            const result = await seam.run({ command: commandLine, intent: productWrite(), timeoutMs, retry });
             if (result.stalled) {
                 shellStalled = true;
                 appendLog(stepId, `没返回：${commandLine}`);
@@ -124,7 +124,7 @@ export function createPreflight(options) {
         };
     }
     async function probeBridge() {
-        const result = await exec('bridge', `${command} doctor`, OPENCLI_TIMEOUT_MS);
+        const result = await exec('bridge', `${command} doctor`, PREFLIGHT_DOCTOR_TIMEOUT_MS);
         if (result.kind === 'stalled') {
             return { ok: false, detail: result.detail, issues: ['unknown'], stalled: true };
         }
@@ -143,7 +143,7 @@ export function createPreflight(options) {
                 appendLog('cli', installed.detail);
             return installed;
         }
-        const result = await exec('cli', installCommand, INSTALL_TIMEOUT_MS);
+        const result = await exec('cli', installCommand, PREFLIGHT_INSTALL_TIMEOUT_MS, 'never');
         if (result.kind !== 'ok')
             return { ok: false, detail: result.detail };
         return { ok: true, detail: tailLines(result.stdout, 1) };
@@ -222,6 +222,8 @@ export function createPreflight(options) {
             }));
         if (toolchain !== undefined && toolchain.detail.trim() !== '')
             appendLog('toolchain', toolchain.detail);
+        for (const line of toolchain?.diagnostics ?? [])
+            appendLog('toolchain', line);
         if (toolchain !== undefined && toolchain.ok && toolchain.pnpmProblem && options.provisionPnpm !== undefined) {
             set({ phase: 'installing' });
             patchStep('toolchain', { status: 'running', action: `装本地 pnpm@${LOCAL_PNPM_VERSION}` });
@@ -249,7 +251,7 @@ export function createPreflight(options) {
                 action: undefined,
             });
             if (!toolchain.ok || toolchain.pnpmProblem) {
-                return toolchain.stalled === true
+                return toolchain.stalled === true || toolchain.hostBroken === true
                     ? hostFailure(toolchain.detail)
                     : set({ phase: 'failed', error: toolchain.detail, failure: 'missing', guidance: 'install' });
             }
@@ -358,7 +360,7 @@ export function createPreflight(options) {
         });
     }
     function freshReady() {
-        return current.phase === 'ready' && Date.now() - current.at < PREFLIGHT_FRESH_MS;
+        return current.phase === 'ready' && now() - current.at < PREFLIGHT_FRESH_MS;
     }
     async function start(runOptions = {}) {
         if (running !== null)

package/dist/probe-cache.js

@@ -1,7 +1,8 @@
+import { now as clockNow } from '@dsh-workbench/shared/host';
 export function createTimedMemo(ttlMs) {
     const entries = new Map();
     return {
-        get(key, now = Date.now()) {
+        get(key, now = clockNow()) {
             const hit = entries.get(key);
             if (hit === undefined)
                 return undefined;
@@ -9,7 +10,7 @@ export function createTimedMemo(ttlMs) {
                 return undefined;
             return hit.value;
         },
-        set(key, value, now = Date.now()) {
+        set(key, value, now = clockNow()) {
             entries.set(key, { at: now, value });
         },
         clear() {

package/dist/probe-libs.d.ts

@@ -1,9 +1,8 @@
-import type { DshShell } from '@dsh-workbench/shared';
-import type { LibNeed, NeedState, SupplyIndex } from '@dsh-workbench/shared/host';
+import type { LibNeed, NeedState, Seam, SupplyIndex } from '@dsh-workbench/shared/host';
 export declare function installedLibVersion(name: string): string | undefined;
 export declare function probeLibs(options: {
     readonly needs: readonly LibNeed[];
-    readonly shell: DshShell;
+    readonly seam: Seam;
     readonly force: boolean;
     readonly index?: SupplyIndex | undefined;
 }): Promise<ReadonlyMap<string, NeedState>>;

package/dist/probe-libs.js

@@ -28,7 +28,7 @@ function stateOf(need, status, detail, extra = {}) {
     };
 }
 export async function probeLibs(options) {
-    const { needs, shell, force, index } = options;
+    const { needs, seam, force, index } = options;
     const found = new Map();
     for (const need of needs) {
         if (found.has(need.name))
@@ -52,7 +52,7 @@ export async function probeLibs(options) {
         const registry = source === undefined ? undefined : npmRegistryOf(source, process.env);
         const latest = registry === undefined || !registry.ok
             ? undefined
-            : await latestVersion({ shell, name: need.name, registry: registry.value, force });
+            : await latestVersion({ seam, name: need.name, registry: registry.value, force });
         const behind = latest !== undefined && isNewerVersion(latest, installed);
         found.set(need.name, stateOf(need, behind ? 'outdated' : 'ok', behind ? `装的 ${installed}，源上最新 ${latest ?? ''}` : `${installed} 版本对`, {
             installed,

package/dist/probe-units.d.ts

@@ -1,15 +1,14 @@
-import type { DshShell } from '@dsh-workbench/shared';
-import { type NeedProbeInput, type UnitCapability } from '@dsh-workbench/shared/host';
+import { type Seam, type NeedProbeInput, type UnitCapability } from '@dsh-workbench/shared/host';
 export type { NeedProbeInput, NeedState, UnitCapability, } from '@dsh-workbench/shared/host';
 export declare function parsePluginList(stdout: string): unknown[] | undefined;
 export declare function probeUnits(options: {
-    shell: DshShell;
+    seam: Seam;
     runtimeCommands: Readonly<Record<string, string>>;
     units: readonly NeedProbeInput[];
     force?: boolean;
 }): Promise<UnitCapability[]>;
 export declare function probeUnitCommands(options: {
-    shell: DshShell;
+    seam: Seam;
     runtimeCommands?: Readonly<Record<string, string>> | undefined;
     unit: NeedProbeInput;
     force?: boolean;