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

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;

package/dist/toolchain.js

@@ -1,37 +1,11 @@
-import { execaSync } from 'execa';
 import lockfile from 'proper-lockfile';
-import writeFileAtomic from 'write-file-atomic';
-import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { quoteShellArg, quoteShellArgFor } from '@dsh-workbench/shared/host';
-import { bootstrapEnv } from './bootstrap-run.js';
+import { quoteShellArg, quoteShellArgFor, writeTextFile } from '@dsh-workbench/shared/host';
+import { bootstrapEnv, runBootstrapCommand } from './bootstrap-run.js';
 import { hostSurface } from './platform.js';
-export function desktopPnpmPath(proc = process, exists = existsSync) {
-    if (hostSurface({ proc }).deployment !== 'desktop')
-        return undefined;
-    const resources = proc.resourcesPath;
-    if (resources === undefined || resources === '')
-        return undefined;
-    const path = join(resources, 'runtime', 'primary-runtime', 'dependencies', 'pnpm', 'bin', 'pnpm.cjs');
-    return exists(path) ? path : undefined;
-}
-export function desktopPnpmVersion(proc = process, exists = existsSync) {
-    if (hostSurface({ proc }).deployment !== 'desktop')
-        return undefined;
-    const resources = proc.resourcesPath;
-    if (resources === undefined || resources === '')
-        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;
-    }
-}
+import { desktopPnpmPath } from './desktop-runtime.js';
+export { desktopBundledBins, desktopNodeExecutable, desktopPnpmPath, desktopPnpmVersion, desktopResourcesDir, desktopRuntimeEnv, desktopRuntimeEnvPath } from './desktop-runtime.js';
 export const LOCAL_NPM_VERSION = [10, 9, 4].join('.');
 export const LOCAL_PNPM_VERSION = [10, 32, 1].join('.');
 export function localNpmRoot(root) {
@@ -92,6 +66,17 @@ export function localPnpmInstallCommand(root, proc = process, exists = existsSyn
     return (`node ${quoteShellArgFor(pnpm, platform)} add --dir ${quoteShellArgFor(localPnpmRoot(root), platform)} ` +
         `pnpm@${LOCAL_PNPM_VERSION} --store-dir ${quoteShellArgFor(join(root, 'pnpm-store'), platform)}`);
 }
+const LOCAL_PNPM_PROVISION_TIMEOUT_MS = 180_000;
+function hostProvisionRun(root, seam) {
+    return async (command) => {
+        const result = await runBootstrapCommand(command, {
+            timeoutMs: LOCAL_PNPM_PROVISION_TIMEOUT_MS,
+            seam,
+            env: bootstrapEnv({ opencliRoot: join(root, 'opencli') }),
+        });
+        return { ok: result.ok, detail: result.detail };
+    };
+}
 export async function provisionLocalPnpm(options) {
     const platform = options.platform ?? process.platform;
     const bootstrap = options.pnpm?.trim();
@@ -112,8 +97,9 @@ export async function provisionLocalPnpm(options) {
         return { ok: false, detail: `建不了 ${localPnpmRoot(options.root)}：${String(error)}` };
     }
     let detail = '';
+    const run = options.run ?? hostProvisionRun(options.root, options.seam);
     for (const command of commands) {
-        const result = await options.run(command);
+        const result = await run(command);
         if (result.ok) {
             const installed = options.installed?.() ?? existsSync(localPnpmCommand(options.root, platform));
             if (installed) {
@@ -131,41 +117,6 @@ export async function provisionLocalPnpm(options) {
     }
     return { ok: false, detail };
 }
-export function provisionLocalPnpmSync(options) {
-    const command = localPnpmInstallCommand(options.root, options.proc ?? process, options.exists ?? existsSync);
-    if (command === undefined)
-        return { ok: false, detail: '找不到 Desktop 自带 pnpm，装不了本地 pnpm 10' };
-    try {
-        mkdirSync(localPnpmRoot(options.root), { recursive: true });
-    }
-    catch (error) {
-        return { ok: false, detail: `建不了 ${localPnpmRoot(options.root)}：${String(error)}` };
-    }
-    try {
-        const run = options.run ??
-            ((line) => {
-                execaSync(line, {
-                    stdio: 'ignore',
-                    timeout: 180_000,
-                    env: bootstrapEnv({ opencliRoot: join(options.root, 'opencli') }),
-                    shell: true,
-                });
-            });
-        run(command);
-    }
-    catch (error) {
-        return { ok: false, detail: String(error) };
-    }
-    const platform = options.platform ?? process.platform;
-    const installed = options.installed?.() ?? existsSync(localPnpmCommand(options.root, platform));
-    if (!installed)
-        return { ok: false, detail: 'pnpm 跑完但本地 pnpm 10 不在' };
-    return {
-        ok: true,
-        binDir: localPnpmBin(options.root),
-        detail: `pnpm@${LOCAL_PNPM_VERSION} 装到 ${localPnpmRoot(options.root)}`,
-    };
-}
 function readText(file) {
     try {
         return readFileSync(file, 'utf8');
@@ -213,8 +164,7 @@ export function ensureToolchain(options) {
         release = lockfile.lockSync(pathDir, { realpath: false });
         if (readText(file) !== shim) {
             rmSync(file, { force: true });
-            writeFileAtomic.sync(file, shim, 'utf8');
-            chmodSync(file, 0o755);
+            writeTextFile(file, shim, { mode: 0o755 });
             files.push(file);
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-workbench/adapter-probe",
-  "version": "1.1.14-beta.2",
+  "version": "1.1.14",
   "description": "Workbench adapter-probe adapter.",
   "type": "module",
   "exports": {
@@ -13,18 +13,15 @@
     "dist"
   ],
   "dependencies": {
-    "execa": "^10.2.0",
     "proper-lockfile": "^4.1.2",
-    "write-file-atomic": "^8.0.0",
-    "@dsh-workbench/adapter-runtime": "1.1.14-beta.2",
-    "@dsh-workbench/shared": "1.1.14-beta.2",
-    "@dsh-workbench/adapter-profile": "1.1.14-beta.2",
-    "@dsh-workbench/adapter-supply": "1.1.14-beta.2"
+    "@dsh-workbench/adapter-profile": "1.1.14",
+    "@dsh-workbench/shared": "1.1.14",
+    "@dsh-workbench/adapter-runtime": "1.1.14",
+    "@dsh-workbench/adapter-supply": "1.1.14"
   },
   "devDependencies": {
     "@types/node": "^24.19.0",
     "@types/proper-lockfile": "^4.1.4",
-    "@types/write-file-atomic": "^4.0.3",
     "vitest": "^5.0.2",
     "dayjs": "^1.11.23",
     "@vitest/coverage-v8": "^5.0.2"