@dsh-workbench/adapter-probe 1.1.14-beta.2 → 1.1.15

package/dist/bootstrap-run.d.ts

@@ -1,4 +1,4 @@
-import type { ShellKind } from '@dsh-workbench/shared/host';
+import type { Seam, ShellKind } from '@dsh-workbench/shared/host';
 export interface BootstrapEnvOptions {
     readonly opencliRoot?: string | undefined;
     readonly realHome?: string | undefined;
@@ -8,8 +8,6 @@ export interface BootstrapEnvOptions {
 export interface BootstrapSpawnOptions {
     readonly env: Readonly<Record<string, string>>;
     readonly timeout: number;
-    readonly reject: false;
-    readonly stripFinalNewline: false;
 }
 export interface BootstrapSpawnResult {
     readonly exitCode: number | null;
@@ -23,6 +21,7 @@ export interface BootstrapRunOptions {
     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;

package/dist/bootstrap-run.js

@@ -1,65 +1,43 @@
-import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { execa } from 'execa';
 import { isolatedRoot } from '@dsh-workbench/adapter-runtime';
-import { tailLines } from '@dsh-workbench/shared/host';
+import { bootstrapEnvOf, invocationOf, tailLines } from '@dsh-workbench/shared/host';
+import { desktopRuntimeEnvPath } from './desktop-runtime.js';
 import { currentShellKind } from './platform.js';
 export function bootstrapEnv(options = {}) {
-    const shellKind = options.shellKind ?? currentShellKind();
-    const opencliRoot = options.opencliRoot ?? isolatedRoot();
-    const realHome = options.realHome ?? homedir();
     const parent = options.parent ?? process.env;
-    const env = {};
-    for (const [key, value] of Object.entries(parent)) {
-        if (typeof value === 'string')
-            env[key] = value;
-    }
-    const home = join(opencliRoot, 'home');
-    env['HOME'] = home;
-    if (shellKind === 'pwsh')
-        env['USERPROFILE'] = home;
-    const userConfig = join(realHome, '.npmrc');
-    if (existsSync(userConfig))
-        env['NPM_CONFIG_USERCONFIG'] = userConfig;
-    const cache = join(opencliRoot, 'npm-cache');
-    env['npm_config_cache'] = cache;
-    env['NPM_CONFIG_CACHE'] = cache;
-    env['NO_COLOR'] = '1';
-    env['TERM'] = 'dumb';
-    return env;
-}
-function shellOf(line, shellKind) {
-    return shellKind === 'pwsh'
-        ? { file: 'pwsh', args: ['-NoProfile', '-NonInteractive', '-Command', line] }
-        : { file: 'bash', args: ['-c', line] };
+    return bootstrapEnvOf({
+        root: options.opencliRoot ?? isolatedRoot(),
+        realHome: options.realHome ?? homedir(),
+        shellKind: options.shellKind ?? currentShellKind(),
+        parent,
+        path: desktopRuntimeEnvPath(parent.PATH),
+    });
 }
-const defaultSpawn = async (file, args, options) => {
-    const result = await execa(file, [...args], {
-        env: { ...options.env },
-        timeout: options.timeout,
-        reject: options.reject,
-        stripFinalNewline: options.stripFinalNewline,
+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 ?? null,
-        timedOut: result.timedOut === true,
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
         stdout: result.stdout,
         stderr: result.stderr,
     };
-};
+}
 export async function runBootstrapCommand(line, options) {
     const shellKind = options.shellKind ?? currentShellKind();
-    const spawn = options.spawn ?? defaultSpawn;
     const env = { ...bootstrapEnv({ shellKind }), ...(options.env ?? {}) };
-    const command = shellOf(line, shellKind);
+    const command = invocationOf(shellKind, line);
     try {
-        const result = await spawn(command.file, command.args, {
-            env,
-            timeout: options.timeoutMs,
-            reject: false,
-            stripFinalNewline: false,
-        });
+        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)

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

@@ -9,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

@@ -9,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/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

@@ -17,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 }),
@@ -32,21 +32,24 @@ export function registerPreflight(input) {
     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,
-        install: () => runBootstrapCommand(installCommand, { timeoutMs: PREFLIGHT_INSTALL_TIMEOUT_MS }),
+        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)
@@ -55,7 +58,10 @@ export function registerPreflight(input) {
                 root,
                 pnpm: process.env.DSH_WB_PNPM?.trim() || 'pnpm',
                 npm: 'npm',
-                run: (command) => runBootstrapCommand(command, { timeoutMs: PREFLIGHT_INSTALL_TIMEOUT_MS }),
+                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 { PREFLIGHT_DOCTOR_TIMEOUT_MS, PREFLIGHT_FRESH_MS, PREFLIGHT_INSTALL_TIMEOUT_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}`);
@@ -143,7 +143,7 @@ export function createPreflight(options) {
                 appendLog('cli', installed.detail);
             return installed;
         }
-        const result = await exec('cli', installCommand, PREFLIGHT_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;

package/dist/probe-units.js

@@ -1,5 +1,5 @@
 import { commandNamesMatch } from './command-name.js';
-import { OPENCLI_TIMEOUT_MS, PROBE_TTL_MS, buildSupplyIndex, NEED_KIND_SPECS, needIdOf, npmSourceOf, parseJsonLoose, quoteShellArg, runShell, } from '@dsh-workbench/shared/host';
+import { OPENCLI_TIMEOUT_MS, PROBE_TTL_MS, buildSupplyIndex, NEED_KIND_SPECS, needIdOf, noWrite, npmSourceOf, parseJsonLoose, productWrite, quoteShellArg, } from '@dsh-workbench/shared/host';
 import { npmRegistryOf } from '@dsh-workbench/adapter-supply';
 import { probeRelease } from './release-port.js';
 import { createTimedMemo } from './probe-cache.js';
@@ -13,17 +13,24 @@ export function parsePluginList(stdout) {
         return parsed;
     return /no plugins? installed/i.test(stdout) ? [] : undefined;
 }
-async function probeBinary(shell, name) {
+async function probeBinary(seam, name) {
     const line = process.platform === 'win32' ? `where ${quoteShellArg(name)}` : `command -v ${quoteShellArg(name)}`;
-    const result = await runShell(shell, line, { timeoutMs: BINARY_PROBE_TIMEOUT_MS }).catch(() => undefined);
+    const result = await seam
+        .run({ command: line, intent: noWrite(), retry: 'safe', timeoutMs: BINARY_PROBE_TIMEOUT_MS, bestEffort: true })
+        .catch(() => undefined);
     return result?.exitCode === 0;
 }
 async function runtimeList(options) {
     if (!options.needsPlugins)
         return {};
-    const result = await runShell(options.shell, `${options.command} plugin list -f json`, {
+    const result = await options.seam
+        .run({
+        command: `${options.command} plugin list -f json`,
+        intent: productWrite(),
+        retry: 'safe',
         timeoutMs: OPENCLI_TIMEOUT_MS,
-    }).then((value) => ({ ok: true, stdout: value.exitCode === 0 ? value.stdout : '', stderr: value.stderr }), (error) => ({ ok: false, stdout: '', stderr: String(error) }));
+    })
+        .then((value) => ({ ok: true, stdout: value.exitCode === 0 ? value.stdout : '', stderr: value.stderr }), (error) => ({ ok: false, stdout: '', stderr: String(error) }));
     if (!result.ok)
         return { failure: result.stderr };
     const list = parsePluginList(result.stdout);
@@ -46,7 +53,7 @@ async function releasesOf(index, options) {
             continue;
         const registry = npmRegistryOf(source, process.env);
         const signal = await probeRelease({
-            shell: options.shell,
+            seam: options.seam,
             package: entry.package,
             ...(registry.ok ? { registry: registry.value } : {}),
             force: options.force,
@@ -70,7 +77,7 @@ function runtimeCommandOf(need, runtimeCommands) {
     return KNOWN_RUNTIMES.includes(need.runtime) ? need.runtime : undefined;
 }
 export async function probeUnits(options) {
-    const { shell, runtimeCommands, units, force = false } = options;
+    const { seam, runtimeCommands, units, force = false } = options;
     const commandKey = Object.values(runtimeCommands).sort().join('|');
     const hits = units.map((unit) => unitCache.get(cacheKeyOf(commandKey, units, unit.unit)));
     if (!force && hits.every((hit) => hit !== undefined)) {
@@ -82,7 +89,7 @@ export async function probeUnits(options) {
         if (shared !== undefined)
             return shared;
     }
-    const task = loadCapabilities({ shell, runtimeCommands, units, force });
+    const task = loadCapabilities({ seam, runtimeCommands, units, force });
     pendingProbes.set(key, task);
     try {
         return await task;
@@ -93,7 +100,7 @@ export async function probeUnits(options) {
     }
 }
 async function loadCapabilities(options) {
-    const { shell, runtimeCommands, units, force } = options;
+    const { seam, runtimeCommands, units, force } = options;
     const index = buildSupplyIndex(units.map((unit) => ({ id: unit.unit, needs: unit.needs })), {
         env: process.env,
         packagePrefix: 'opencli-plugin-',
@@ -105,7 +112,7 @@ async function loadCapabilities(options) {
     const runtimeNames = Object.values(runtimeCommands);
     await Promise.all(binNames.map(async (name) => {
         const known = runtimeNames.some((command) => commandNamesMatch(name, command));
-        binaries.set(name, known ? true : await probeBinary(shell, name));
+        binaries.set(name, known ? true : await probeBinary(seam, name));
     }));
     const extensionNeeds = units.flatMap((unit) => unit.needs.filter((need) => need.kind === 'extension'));
     const runtimes = [...new Set(extensionNeeds.map((need) => need.runtime))];
@@ -117,11 +124,11 @@ async function loadCapabilities(options) {
             return;
         }
         const needsPlugins = extensionNeeds.some((need) => need.runtime === runtime && conflictOf(index, need) === undefined);
-        lists.set(runtime, await runtimeList({ shell, command, needsPlugins }));
+        lists.set(runtime, await runtimeList({ seam, command, needsPlugins }));
     }));
     const libNeeds = units.flatMap((unit) => unit.needs.filter((need) => need.kind === 'lib'));
-    const libStates = await probeLibs({ needs: libNeeds, shell, force, index });
-    const releases = await releasesOf(index, { shell, force });
+    const libStates = await probeLibs({ needs: libNeeds, seam, force, index });
+    const releases = await releasesOf(index, { seam, force });
     const statesOfUnit = (unit) => unit.needs.map((need) => {
         const conflict = need.kind === 'extension' || need.kind === 'lib' ? conflictOf(index, need) : undefined;
         if (conflict !== undefined) {
@@ -179,7 +186,7 @@ async function loadCapabilities(options) {
 export async function probeUnitCommands(options) {
     const units = options.catalog === undefined ? [options.unit] : options.catalog;
     const all = await probeUnits({
-        shell: options.shell,
+        seam: options.seam,
         runtimeCommands: options.runtimeCommands ?? {},
         units,
         ...(options.force === undefined ? {} : { force: options.force }),