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

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 }),

package/dist/release-port.d.ts

@@ -1,18 +1,18 @@
 export declare const latestVersion: (options: {
-    readonly shell: import("@dsh-workbench/shared").DshShell;
+    readonly seam: import("@dsh-workbench/shared/host").Seam;
     readonly name: string;
     readonly registry: string;
     readonly force?: boolean;
 }) => Promise<string | undefined>;
 export declare const missingReleaseParts: (options: {
-    readonly shell: import("@dsh-workbench/shared").DshShell;
+    readonly seam: import("@dsh-workbench/shared/host").Seam;
     readonly name: string;
     readonly registry: string;
     readonly version: string;
     readonly force?: boolean;
 }) => Promise<readonly string[]>;
 export declare const probeRelease: (options: {
-    readonly shell: import("@dsh-workbench/shared").DshShell;
+    readonly seam: import("@dsh-workbench/shared/host").Seam;
     readonly package: string;
     readonly registry?: string | undefined;
     readonly force?: boolean;

package/dist/release-port.js

@@ -1,6 +1,6 @@
 import { createReleasePort } from '@dsh-workbench/adapter-profile';
-import { npmCacheDir, vendorPrefix } from '@dsh-workbench/adapter-runtime';
-const port = createReleasePort({ cacheDir: npmCacheDir(), prefix: vendorPrefix() });
+import { vendorPrefix } from '@dsh-workbench/adapter-runtime';
+const port = createReleasePort({ prefix: vendorPrefix() });
 export const latestVersion = port.latestVersion;
 export const missingReleaseParts = port.missingReleaseParts;
 export const probeRelease = port.probeRelease;

package/dist/runtime-seed.d.ts

@@ -1,5 +1,5 @@
-import type { spawn } from 'node:child_process';
 import type { DshHostContext } from '@dsh-workbench/shared';
+import type { Seam } from '@dsh-workbench/shared/host';
 export type SeedLog = (message: string) => void;
 export interface RuntimeSeedPaths {
     readonly root: string;
@@ -21,9 +21,7 @@ export interface RuntimeSeedOptions {
 }
 export declare function opencliBinName(platform?: NodeJS.Platform): string;
 export declare function runtimeSeedPaths(root: string, platform?: NodeJS.Platform): RuntimeSeedPaths;
-export declare function runtimeSeedRootOf(ctx: DshHostContext): string | null;
-export declare function coversWritableRoot(workspaceRoot: string, root: string): boolean;
-export declare function warnUnwritableRoot(ctx: DshHostContext): void;
+export declare function runtimeSeedRootOf(_ctx: DshHostContext): string | null;
 export declare function wrapperRootOf(fallbackRoot: string): string;
 export declare function isInstalledCopy(packageRoot: string): boolean;
 export declare function opencliWrapperScript(packageRoot: string, home: string, platform?: NodeJS.Platform): string;
@@ -38,7 +36,7 @@ export declare function workshopSeedPlan(packageRoot: string, home: string, root
     readonly entry: SeedCommand;
     readonly full: SeedCommand;
 };
-export declare function runDetached(command: SeedCommand, onError: SeedLog, spawnImpl?: typeof spawn): void;
+export declare function runDetached(command: SeedCommand, onError: SeedLog, seam?: Seam | undefined): void;
 export declare function prependPath(entryDir: string, env?: NodeJS.ProcessEnv): boolean;
-export declare function seedWorkbenchToolchain(root: string, log: SeedLog): void;
+export declare function seedWorkbenchToolchain(root: string, log: SeedLog, seam?: Seam | undefined): Promise<void>;
 export declare function seedRuntimeFiles(options: RuntimeSeedOptions): readonly string[];

package/dist/runtime-seed.js

@@ -1,11 +1,9 @@
-import { execa } from 'execa';
 import { toolchainManifestOf } from '@dsh-workbench/adapter-runtime';
 import { createRequire } from 'node:module';
-import writeFileAtomic from 'write-file-atomic';
-import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, rmSync, } from 'node:fs';
+import { mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { delimiter, dirname, join, sep } from 'node:path';
-import { quoteShellArg, quoteShellArgFor } from '@dsh-workbench/shared/host';
-import { desktopPnpmPath, desktopPnpmVersion, ensureToolchain, localNpmCache, localPnpmCommand, provisionLocalPnpmSync, } from './toolchain.js';
+import { pathWithBinsOf, quoteShellArg, quoteShellArgFor, workbenchRoot, writeTextFile } from '@dsh-workbench/shared/host';
+import { desktopBundledBins, desktopNodeExecutable, desktopPnpmPath, desktopPnpmVersion, ensureToolchain, localNpmCache, localPnpmCommand, provisionLocalPnpm, } from './toolchain.js';
 export function opencliBinName(platform = process.platform) {
     return platform === 'win32' ? 'opencli.cmd' : 'opencli';
 }
@@ -25,32 +23,8 @@ export function runtimeSeedPaths(root, platform = process.platform) {
         workshopManifest: join(workshop, 'package.json'),
     };
 }
-export function runtimeSeedRootOf(ctx) {
-    const configured = process.env.DSH_WORKBENCH_HOME?.trim();
-    if (configured !== undefined && configured !== '')
-        return configured;
-    const homePath = ctx.get('dshHomePath');
-    if (typeof homePath !== 'function')
-        return null;
-    try {
-        return homePath('workbench');
-    }
-    catch {
-        return null;
-    }
-}
-export function coversWritableRoot(workspaceRoot, root) {
-    const prefix = workspaceRoot.endsWith(sep) ? workspaceRoot : `${workspaceRoot}${sep}`;
-    return root === workspaceRoot || root.startsWith(prefix);
-}
-export function warnUnwritableRoot(ctx) {
-    const root = runtimeSeedRootOf(ctx);
-    if (root === null)
-        return;
-    const workspaceRoot = ctx.get('sandboxPolicy')?.workspaceRoot;
-    if (workspaceRoot === undefined || coversWritableRoot(workspaceRoot, root))
-        return;
-    ctx.logger?.warn?.(`[dsh-workbench] 可写根 ${workspaceRoot} 盖不住 ${root}：市场装插件、自举命令可能被沙箱挡（把 profile/sandbox.patch.yml 那一行写进这个 profile 的 cordis.patch.yml 再重启）`);
+export function runtimeSeedRootOf(_ctx) {
+    return workbenchRoot();
 }
 export function wrapperRootOf(fallbackRoot) {
     try {
@@ -88,49 +62,46 @@ export function workshopSeedPlan(packageRoot, home, root, platform = process.pla
         full: { file: 'bash', args: [script], env, log },
     };
 }
-const execaSpawn = ((file, args, options) => execa(file, [...args], { ...options, reject: false }));
-export function runDetached(command, onError, spawnImpl = execaSpawn) {
-    let fd = null;
+export function runDetached(command, onError, seam) {
+    if (seam === undefined) {
+        onError(`自举脚本没跑起来（${command.file}）：宿主没给执行缝`);
+        return;
+    }
     try {
-        fd = openSync(command.log, 'a');
-        const child = spawnImpl(command.file, [...command.args], {
-            env: { ...process.env, ...command.env },
-            detached: true,
-            stdio: ['ignore', fd, fd],
+        const handle = seam.spawn({
+            target: { argv: [command.file, ...command.args] },
+            intent: { kind: 'host' },
+            lifetime: 'host',
+            logFile: command.log,
+            env: command.env,
+            label: 'seed',
         });
-        child.on('error', (error) => onError(`自举脚本没跑起来（${command.file}）：${String(error)}`));
-        child.unref();
+        handle.onError((error) => onError(`自举脚本没跑起来（${command.file}）：${String(error)}`));
     }
     catch (error) {
         onError(`自举脚本没跑起来（${command.file}）：${String(error)}`);
     }
-    finally {
-        if (fd !== null)
-            closeQuietly(fd);
-    }
-}
-function closeQuietly(fd) {
-    try {
-        closeSync(fd);
-    }
-    catch {
-        return;
-    }
 }
 export function prependPath(entryDir, env = process.env) {
     const parts = (env.PATH ?? '').split(delimiter).filter((part) => part !== '');
     if (parts.includes(entryDir))
         return false;
-    env.PATH = [entryDir, ...parts].join(delimiter);
+    env.PATH = pathWithBinsOf(env.PATH, [entryDir]);
     return true;
 }
-export function seedWorkbenchToolchain(root, log) {
+export async function seedWorkbenchToolchain(root, log, seam) {
+    for (const dir of desktopBundledBins()) {
+        if (prependPath(dir))
+            log(`PATH 前插 Desktop 自带 ${dir}`);
+    }
     const bundledPnpm = desktopPnpmPath();
     const bundledMajor = Number(desktopPnpmVersion()?.split('.')[0] ?? '0');
     const bundledUsable = bundledPnpm !== undefined && bundledMajor >= 10;
     if (bundledPnpm !== undefined && bundledUsable) {
-        process.env.DSH_WB_PNPM = `node ${quoteShellArgFor(bundledPnpm, process.platform)}`;
-        log(`pnpm 用 Desktop 自带的：${bundledPnpm}`);
+        const bundledNode = desktopNodeExecutable();
+        const nodePrefix = bundledNode === undefined ? 'node' : quoteShellArgFor(bundledNode, process.platform);
+        process.env.DSH_WB_PNPM = `${nodePrefix} ${quoteShellArgFor(bundledPnpm, process.platform)}`;
+        log(`pnpm 用 Desktop 自带的：${bundledPnpm}（node: ${nodePrefix}）`);
     }
     else if (bundledPnpm !== undefined) {
         log(`Desktop 自带 pnpm 版本低于 10，优先用 PATH 上的 pnpm`);
@@ -155,7 +126,7 @@ export function seedWorkbenchToolchain(root, log) {
             process.env.DSH_WB_PNPM = localPnpmCommand(root);
     }
     else if (!bundledUsable && toolchain.pathDir !== undefined) {
-        const installed = provisionLocalPnpmSync({ root });
+        const installed = await provisionLocalPnpm({ root, seam });
         if (installed.ok && installed.binDir !== undefined) {
             if (prependPath(installed.binDir))
                 log(`PATH 前插 ${installed.binDir}`);
@@ -178,15 +149,14 @@ export function seedRuntimeFiles(options) {
         const manifest = join(paths.opencliRoot, 'toolchain', 'package.json');
         mkdirSync(dirname(manifest), { recursive: true });
         if (readText(manifest) !== toolchainManifestOf()) {
-            writeFileAtomic.sync(manifest, toolchainManifestOf(), 'utf8');
+            writeTextFile(manifest, toolchainManifestOf());
             done.push(manifest);
         }
         rmSync(join(paths.opencliRoot, 'toolchain', 'pnpm-workspace.yaml'), { force: true });
         const wanted = opencliWrapperScript(options.packageRoot, options.home, platform);
         if (readText(paths.opencliBin) !== wanted) {
             rmSync(paths.opencliBin, { force: true });
-            writeFileAtomic.sync(paths.opencliBin, wanted, 'utf8');
-            chmodSync(paths.opencliBin, 0o755);
+            writeTextFile(paths.opencliBin, wanted, { mode: 0o755 });
             done.push(paths.opencliBin);
         }
     }

package/dist/self-update.d.ts

@@ -1,4 +1,4 @@
-import type { spawn } from 'node:child_process';
+import type { Seam } from '@dsh-workbench/shared/host';
 import { type SeedCommand } from './runtime-seed.js';
 import { SELF_UPDATE_STATES, type SelfUpdateState, type WorkbenchSelfUpdate } from '@dsh-workbench/shared/contract/protocol/bundle-install';
 export { SELF_UPDATE_STATES, type SelfUpdateState };
@@ -47,7 +47,7 @@ export interface SelfUpdateStart {
     readonly paths: SelfUpdatePaths;
     readonly forward: string;
 }
-export declare function selfUpdatePaths(dshHome: string, platform?: NodeJS.Platform): SelfUpdatePaths;
+export declare function selfUpdatePaths(_dshHome: string, platform?: NodeJS.Platform): SelfUpdatePaths;
 export declare function recoveryCommand(input: {
     readonly profile: string;
     readonly pkg: string;
@@ -58,6 +58,6 @@ export declare function selfUpdateMarker(request: SelfUpdateRequest, state: Self
 export declare function selfUpdateScript(request: SelfUpdateRequest, paths: SelfUpdatePaths, cli?: SelfUpdateCli): string;
 export declare function selfUpdateNodeScript(request: SelfUpdateRequest, paths: SelfUpdatePaths, cli?: SelfUpdateCli): string;
 export declare function planSelfUpdate(request: SelfUpdateRequest, now?: Date, cli?: SelfUpdateCli, platform?: NodeJS.Platform): SelfUpdatePlan;
-export declare function startSelfUpdate(request: SelfUpdateRequest, onError: (message: string) => void, spawnImpl?: typeof spawn, cli?: SelfUpdateCli): SelfUpdateStart;
+export declare function startSelfUpdate(request: SelfUpdateRequest, onError: (message: string) => void, seam?: Seam | undefined, cli?: SelfUpdateCli): SelfUpdateStart;
 export declare function readSelfUpdateView(home: string, profile?: string): WorkbenchSelfUpdate | undefined;
 export { runningVersionOf } from '@dsh-workbench/shared/host';

package/dist/self-update.js

@@ -1,7 +1,6 @@
-import writeFileAtomic from 'write-file-atomic';
-import { quoteShellArg } from '@dsh-workbench/shared/host';
+import { now as clockNow, quoteShellArg, workbenchRoot, writeJsonFile, writeTextFile } from '@dsh-workbench/shared/host';
 import { hostSurface } from './platform.js';
-import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, } from 'node:fs';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, statSync, } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { runDetached } from './runtime-seed.js';
 import { SELF_UPDATE_STATES, } from '@dsh-workbench/shared/contract/protocol/bundle-install';
@@ -41,9 +40,8 @@ export function selfUpdateCliFor(profile, proc = process, exists = existsSync) {
         return PATH_DSH;
     return desktopSelfUpdateCli(proc, exists) ?? PATH_DSH;
 }
-export function selfUpdatePaths(dshHome, platform = process.platform) {
-    const configured = process.env.DSH_WORKBENCH_HOME?.trim();
-    const dir = configured === undefined || configured === '' ? join(dshHome, 'workbench') : configured;
+export function selfUpdatePaths(_dshHome, platform = process.platform) {
+    const dir = workbenchRoot();
     return {
         dir,
         script: join(dir, platform === 'win32' ? 'self-update.mjs' : 'self-update.sh'),
@@ -178,7 +176,7 @@ export function selfUpdateNodeScript(request, paths, cli = selfUpdateCliFor(requ
         '',
     ].join('\n');
 }
-export function planSelfUpdate(request, now = new Date(), cli = selfUpdateCliFor(request.profile), platform = process.platform) {
+export function planSelfUpdate(request, now = new Date(clockNow()), cli = selfUpdateCliFor(request.profile), platform = process.platform) {
     const paths = selfUpdatePaths(request.dshHome, platform);
     const windows = platform === 'win32';
     return {
@@ -195,13 +193,12 @@ export function planSelfUpdate(request, now = new Date(), cli = selfUpdateCliFor
             : { file: 'bash', args: [paths.script], env: {}, log: paths.log },
     };
 }
-export function startSelfUpdate(request, onError, spawnImpl, cli = selfUpdateCliFor(request.profile)) {
-    const plan = planSelfUpdate(request, new Date(), cli);
+export function startSelfUpdate(request, onError, seam, cli = selfUpdateCliFor(request.profile)) {
+    const plan = planSelfUpdate(request, new Date(clockNow()), cli);
     mkdirSync(plan.paths.dir, { recursive: true });
-    writeFileAtomic.sync(plan.paths.script, plan.script, { mode: 0o755 });
-    chmodSync(plan.paths.script, 0o755);
-    writeFileAtomic.sync(plan.paths.marker, `${JSON.stringify(plan.marker)}\n`);
-    runDetached(plan.command, onError, spawnImpl);
+    writeTextFile(plan.paths.script, plan.script, { mode: 0o755 });
+    writeJsonFile(plan.paths.marker, plan.marker);
+    runDetached(plan.command, onError, seam);
     const forward = recoveryCommand({
         profile: request.profile,
         pkg: request.pkg,

package/dist/supply-port.d.ts

@@ -1,2 +1,5 @@
-import type { SupplyPort } from '@dsh-workbench/shared/host';
-export declare function createSupplyPort(): SupplyPort;
+import type { Seam, SupplyPort } from '@dsh-workbench/shared/host';
+export interface ProbeSupplyOptions {
+    readonly seam?: Seam | undefined;
+}
+export declare function createSupplyPort(options?: ProbeSupplyOptions): SupplyPort;

package/dist/supply-port.js

@@ -7,7 +7,8 @@ import { startSelfUpdate } from './self-update.js';
 import { declarationGaps, declarationRefusalOf, moduleDeclarationOf, packageRouteOf, pathDeclarationOf, pluginInstallPlan, profileDirOf, profileModules, readInstalledModule, readProfilePackage, registryDeclarationOf, resolvePluginSource, splitNpmSpec, } from '@dsh-workbench/adapter-supply';
 import { readBundleManager, refusalReason } from '@dsh-workbench/shared/host';
 import { OPENCLI_MANIFEST_FILE } from '@dsh-workbench/adapter-runtime';
-export function createSupplyPort() {
+export function createSupplyPort(options = {}) {
+    const seam = options.seam;
     const port = {
         isolatedRoot,
         isolatedHome,
@@ -42,7 +43,7 @@ export function createSupplyPort() {
         splitNpmSpec,
         libInstallCommand,
         libUninstallCommand,
-        startSelfUpdate,
+        startSelfUpdate: (request, onError) => startSelfUpdate(request, onError, seam),
     };
     return { ...port, env: port, modules: port };
 }

package/dist/toolchain-probe.d.ts

@@ -1,4 +1,4 @@
-import type { DshShell } from '@dsh-workbench/shared';
+import { type Seam } from '@dsh-workbench/shared/host';
 export interface ToolchainReport {
     readonly ok: boolean;
     readonly detail: string;
@@ -6,5 +6,7 @@ export interface ToolchainReport {
     readonly npmMissing: boolean;
     readonly pnpmProblem: boolean;
     readonly stalled?: boolean | undefined;
+    readonly diagnostics?: readonly string[] | undefined;
+    readonly hostBroken?: boolean | undefined;
 }
-export declare function probeDesktopToolchain(shell: DshShell): Promise<ToolchainReport>;
+export declare function probeDesktopToolchain(seam: Seam): Promise<ToolchainReport>;

package/dist/toolchain-probe.js

@@ -1,28 +1,49 @@
-import { runShell } from '@dsh-workbench/shared/host';
-import { quoteShellArg } from '@dsh-workbench/shared/host';
-import { desktopPnpmPath, desktopPnpmVersion } from './toolchain.js';
+import { productWrite, quoteShellArg } from '@dsh-workbench/shared/host';
+import { delimiter } from 'node:path';
+import { homedir } from 'node:os';
+import { desktopBundledBins, desktopNodeExecutable, desktopPnpmPath, desktopPnpmVersion, desktopResourcesDir, desktopRuntimeEnv, } from './desktop-runtime.js';
 import { hostSurface } from './platform.js';
-async function toolVersion(shell, line) {
+async function toolVersion(seam, line, extra) {
     try {
-        const result = await runShell(shell, line, { timeoutMs: 10_000 });
+        const result = await seam.run({
+            command: line,
+            intent: productWrite(),
+            retry: 'safe',
+            timeoutMs: 10_000,
+            ...(extra?.workdir === undefined ? {} : { workdir: extra.workdir }),
+        });
         const text = (result.stdout || result.stderr).trim().split('\n')[0] ?? '';
-        return { ok: result.exitCode === 0 && !result.timedOut, text, stalled: result.stalled };
+        const fact = seam.facts().filter((entry) => entry.command === line).at(-1);
+        const sandbox = fact === undefined
+            ? '（无）'
+            : `mode=${fact.mode} root=${fact.workspaceRoot}${fact.denial === undefined ? '' : ` denial=${fact.denial.scope}`}`;
+        return {
+            ok: result.exitCode === 0 && !result.timedOut,
+            text,
+            stalled: result.stalled,
+            code: result.exitCode,
+            raw: `${result.stdout ?? ''}${result.stderr ?? ''}`.trim().split('\n').slice(0, 2).join(' / '),
+            sandbox,
+        };
     }
-    catch {
-        return { ok: false, text: '', stalled: false };
+    catch (error) {
+        return { ok: false, text: '', stalled: false, code: null, raw: String(error), sandbox: '（抛错）' };
     }
 }
-export async function probeDesktopToolchain(shell) {
+export async function probeDesktopToolchain(seam) {
+    const bundledNode = desktopNodeExecutable();
     const bundledPnpm = desktopPnpmPath();
     const bundledMajor = desktopPnpmVersion()?.split('.')[0];
     const preferBundled = bundledPnpm !== undefined && Number(bundledMajor ?? '0') >= 10;
+    const nodeCommand = bundledNode === undefined ? 'node' : quoteShellArg(bundledNode);
     const pnpmLine = preferBundled
-        ? `node ${quoteShellArg(bundledPnpm ?? '')} --version`
+        ? `${nodeCommand} ${quoteShellArg(bundledPnpm ?? '')} --version`
         : 'pnpm --version';
+    const path = desktopRuntimeEnv().PATH;
     const [node, npm, pnpm] = await Promise.all([
-        toolVersion(shell, 'node --version'),
-        toolVersion(shell, 'npm --version'),
-        toolVersion(shell, pnpmLine),
+        toolVersion(seam, `${nodeCommand} --version`),
+        toolVersion(seam, 'npm --version'),
+        toolVersion(seam, pnpmLine),
     ]);
     if (node.stalled || npm.stalled || pnpm.stalled) {
         return {
@@ -56,5 +77,50 @@ export async function probeDesktopToolchain(shell) {
                 ? `pnpm ${pnpm.text}（Desktop 自带）`
                 : `pnpm ${pnpm.text}`,
     ];
-    return { ok: !nodeMissing, detail: parts.join(' · '), nodeMissing, npmMissing, pnpmProblem };
+    const control = [];
+    if (nodeMissing) {
+        for (const [label, file] of [
+            ['direct bundled node', desktopNodeExecutable()],
+            ['direct host node', process.execPath],
+        ]) {
+            if (file === undefined) {
+                control.push(`control ${label}: （没有可执行文件）`);
+                continue;
+            }
+            try {
+                const out = await seam.run({
+                    argv: [file, '--version'],
+                    intent: { kind: 'host' },
+                    timeoutMs: 10_000,
+                });
+                control.push(`control ${label}: exit=${String(out.exitCode)} out=${(out.stdout || out.stderr).slice(0, 80)}`);
+            }
+            catch (error) {
+                control.push(`control ${label}: 起不来 ${String(error).slice(0, 120)}`);
+            }
+        }
+        for (const [label, workdir] of [
+            ['default', undefined],
+            ['home', homedir()],
+            ['cwd', process.cwd()],
+        ]) {
+            const probe = await toolVersion(seam, 'echo workbench-probe', { workdir });
+            control.push(`control ${label}: exit=${String(probe.code)} out=${probe.raw.slice(0, 80) || '（空）'}`);
+        }
+    }
+    const hostBroken = control.some((line) => line.includes('exit=3221225794'));
+    const diagnostics = [
+        `deployment=${desktop ? 'desktop' : 'host'} · resources=${desktopResourcesDir() ?? '（无）'} · execPath=${process.execPath}`,
+        `bundled node=${bundledNode ?? '（找不到）'} · bundled pnpm=${bundledPnpm ?? '（找不到）'} · bins=${desktopBundledBins().join('|') || '（无）'}`,
+        `PATH 前两段=${(path ?? '').split(delimiter).slice(0, 2).join('|') || '（空）'}`,
+        `node: exit=${String(node.code)} sandbox=${node.sandbox} out=${node.raw.slice(0, 160) || '（空）'} cmd=${nodeCommand}`,
+        `pnpm: exit=${String(pnpm.code)} sandbox=${pnpm.sandbox} out=${pnpm.raw.slice(0, 160) || '（空）'} cmd=${pnpmLine}`,
+        `npm: exit=${String(npm.code)} sandbox=${npm.sandbox} out=${npm.raw.slice(0, 120) || '（空）'}`,
+        ...control,
+    ];
+    const base = parts.join(' · ');
+    const detail = hostBroken
+        ? `宿主执行通道起不了子进程（0xC0000142 · DLL 初始化失败）——不是没装 node：${base}`
+        : base;
+    return { ok: !nodeMissing, detail, nodeMissing, npmMissing, pnpmProblem, diagnostics, hostBroken };
 }

package/dist/toolchain.d.ts

@@ -1,3 +1,7 @@
+import type { Seam } from '@dsh-workbench/shared/host';
+import type { PnpmProcess } from './desktop-runtime.js';
+export { desktopBundledBins, desktopNodeExecutable, desktopPnpmPath, desktopPnpmVersion, desktopResourcesDir, desktopRuntimeEnv, desktopRuntimeEnvPath } from './desktop-runtime.js';
+export type { PnpmProcess } from './desktop-runtime.js';
 export interface ToolchainProcess {
     readonly versions: {
         readonly electron?: string | undefined;
@@ -6,15 +10,6 @@ export interface ToolchainProcess {
     readonly execPath: string;
     readonly resourcesPath?: string | undefined;
 }
-export interface PnpmProcess {
-    readonly versions: {
-        readonly electron?: string | undefined;
-        readonly node?: string | undefined;
-    };
-    readonly resourcesPath?: string | undefined;
-}
-export declare function desktopPnpmPath(proc?: PnpmProcess, exists?: (path: string) => boolean): string | undefined;
-export declare function desktopPnpmVersion(proc?: PnpmProcess, exists?: (path: string) => boolean): string | undefined;
 export interface ToolchainOptions {
     readonly root: string;
     readonly proc?: ToolchainProcess | undefined;
@@ -61,10 +56,11 @@ export interface LocalPnpmProvision {
 }
 export declare function provisionLocalPnpm(options: {
     readonly root: string;
-    readonly run: (command: string) => Promise<{
+    readonly seam?: Seam | undefined;
+    readonly run?: ((command: string) => Promise<{
         ok: boolean;
         detail: string;
-    }>;
+    }>) | undefined;
     readonly installed?: (() => boolean) | undefined;
     readonly platform?: NodeJS.Platform | undefined;
     readonly proc?: PnpmProcess | undefined;
@@ -72,14 +68,6 @@ export declare function provisionLocalPnpm(options: {
     readonly pnpm?: string | undefined;
     readonly npm?: string | undefined;
 }): Promise<LocalPnpmProvision>;
-export declare function provisionLocalPnpmSync(options: {
-    readonly root: string;
-    readonly run?: ((command: string) => void) | undefined;
-    readonly installed?: (() => boolean) | undefined;
-    readonly platform?: NodeJS.Platform | undefined;
-    readonly proc?: PnpmProcess | undefined;
-    readonly exists?: ((path: string) => boolean) | undefined;
-}): LocalPnpmProvision;
 export declare function desktopNodeBinary(proc?: ToolchainProcess, platform?: NodeJS.Platform, exists?: (path: string) => boolean): string | undefined;
 export declare function desktopNodeShim(proc?: ToolchainProcess, platform?: NodeJS.Platform, exists?: (path: string) => boolean): string | undefined;
 export declare function toolchainBinDir(root: string): string;