@dsh-workbench/adapter-probe 0.0.0-stage → 1.0.0-beta.1

package/dist/self-update.js

@@ -0,0 +1,277 @@
+import writeFileAtomic from 'write-file-atomic';
+import { quoteShellArg } from '@dsh-workbench/shared/host';
+import { hostSurface } from './platform.js';
+import { chmodSync, 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';
+export { SELF_UPDATE_STATES };
+const PATH_DSH = { file: 'dsh', args: [], env: {} };
+function isPathDsh(cli) {
+    return cli.file === PATH_DSH.file && cli.args.length === 0 && Object.keys(cli.env).length === 0;
+}
+function quoted(value) {
+    return quoteShellArg(value);
+}
+function cliCommand(cli) {
+    const env = Object.entries(cli.env)
+        .map(([key, value]) => `${key}=${quoted(value)}`)
+        .join(' ');
+    const command = [cli.file, ...cli.args].map(quoted).join(' ');
+    return env === '' ? command : `env ${env} ${command}`;
+}
+export function desktopSelfUpdateCli(proc = process, exists = existsSync) {
+    if (hostSurface({ proc }).deployment !== 'desktop')
+        return undefined;
+    const entry = proc.argv[1];
+    if (entry === undefined || !/dsh-desktop-host[\\/]lib[\\/]index\.js$/.test(entry))
+        return undefined;
+    const cli = join(dirname(entry), 'cli.js');
+    if (!exists(cli))
+        return undefined;
+    return {
+        file: proc.execPath,
+        args: ['--expose-internals', cli],
+        env: { ELECTRON_RUN_AS_NODE: '1' },
+    };
+}
+export function selfUpdateCliFor(profile, proc = process, exists = existsSync) {
+    const surface = hostSurface({ proc, profile });
+    if (surface.capabilities.selfUpdateCli !== 'desktop-cli')
+        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;
+    return {
+        dir,
+        script: join(dir, platform === 'win32' ? 'self-update.mjs' : 'self-update.sh'),
+        marker: join(dir, 'self-update.json'),
+        log: join(dir, 'self-update.log'),
+    };
+}
+export function recoveryCommand(input) {
+    const cli = input.cli ?? PATH_DSH;
+    const command = isPathDsh(cli) ? 'dsh' : cliCommand(cli);
+    return `${command} plugin --profile ${input.profile} add ${input.pkg}@${input.version}`;
+}
+export function selfUpdateMarker(request, state, version, at) {
+    return { ...request, state, version, at };
+}
+export function selfUpdateScript(request, paths, cli = selfUpdateCliFor(request.profile)) {
+    const rescue = recoveryCommand({
+        profile: request.profile,
+        pkg: request.pkg,
+        version: request.from,
+        cli,
+    });
+    const lastsOne = recoveryCommand({
+        profile: request.profile,
+        pkg: request.pkg,
+        version: request.to === '' ? 'latest' : request.to,
+        cli,
+    });
+    const target = request.to === '' ? 'latest' : request.to;
+    const landed = request.to === '' ? 'is_other' : 'is_to';
+    const restart = isPathDsh(cli) ? '重启一次 dsh' : '退出并重开 Desktop';
+    const install = isPathDsh(cli)
+        ? 'install() { dsh plugin --profile "$PROFILE" add "$PKG@$1" >>"$LOG" 2>&1; }'
+        : `install() { ${cliCommand(cli)} plugin --profile "$PROFILE" add "$PKG@$1" >>"$LOG" 2>&1; }`;
+    const guard = isPathDsh(cli)
+        ? 'if ! command -v dsh >/dev/null 2>&1; then'
+        : `if ! command -v ${quoted(cli.file)} >/dev/null 2>&1; then`;
+    const missing = isPathDsh(cli)
+        ? `say "PATH 上没有 dsh —— 这一跳没跑。救法：${rescue}"`
+        : `say ${quoted(`找不到 Desktop 的 dsh（${cli.file}）—— 这一跳没跑。救法：${rescue}`)}`;
+    return `#!/usr/bin/env bash
+set -uo pipefail
+DSH_HOME=${quoted(request.dshHome)}
+export DSH_HOME
+PKG=${quoted(request.pkg)}
+PROFILE=${quoted(request.profile)}
+FROM=${quoted(request.from)}
+TO=${quoted(target)}
+MARKER=${quoted(paths.marker)}
+LOG=${quoted(paths.log)}
+PROFILE_DIR="$DSH_HOME/profiles/$PROFILE"
+say() { printf '%s %s\\n' "$(date '+%F %T')" "$*" >>"$LOG"; }
+on_disk() {
+  node -e 'const p=process.argv[1];try{process.stdout.write(require(p).version)}catch(e){}' \\
+    "$PROFILE_DIR/node_modules/$PKG/package.json" 2>/dev/null
+}
+write_marker() {
+  printf '{"pkg":"%s","profile":"%s","from":"%s","to":"%s","state":"%s","version":"%s","at":"%s"}\\n' \\
+    "$PKG" "$PROFILE" "$FROM" "$TO" "$1" "$2" "$(date -u '+%FT%TZ')" >"$MARKER"
+}
+${install}
+is_to() { [ "$(on_disk)" = "$TO" ]; }
+is_other() { [ -n "$(on_disk)" ] && [ "$(on_disk)" != "$FROM" ]; }
+${guard}
+  ${missing}
+  write_marker failed "$FROM"
+  exit 1
+fi
+say "开始 \${FROM} -> \${TO}（不卸任何一行）"
+write_marker running "$FROM"
+if install "$TO" && ${landed}; then
+  say "换好了：$(on_disk) 在盘上（目标 \${TO}），${restart} 才用得上"
+  write_marker ok "$(on_disk)"
+  exit 0
+fi
+say "换版没成（盘上 $(on_disk)）—— 把 \${FROM} 装回去"
+if install "$FROM" && [ "$(on_disk)" = "$FROM" ]; then
+  say "已回滚：\${FROM} 还在盘上，工作台这一行没被动过"
+  write_marker rolled-back "$FROM"
+  exit 0
+fi
+say "回滚也没成。救法：${rescue}（或 ${lastsOne}）"
+write_marker failed "$(on_disk)"
+exit 1
+`;
+}
+export function selfUpdateNodeScript(request, paths, cli = selfUpdateCliFor(request.profile)) {
+    const target = request.to === '' ? 'latest' : request.to;
+    const restart = isPathDsh(cli) ? '重启一次 dsh' : '退出并重开 Desktop';
+    const rescue = recoveryCommand({ profile: request.profile, pkg: request.pkg, version: request.from, cli });
+    const last = recoveryCommand({ profile: request.profile, pkg: request.pkg, version: target, cli });
+    const missing = isPathDsh(cli)
+        ? `PATH 上没有 dsh —— 这一跳没跑。救法：${rescue}`
+        : `找不到 Desktop 的 dsh（${cli.file}）—— 这一跳没跑。救法：${rescue}`;
+    return [
+        '#!/usr/bin/env node',
+        "import { spawnSync } from 'node:child_process';",
+        "import { appendFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs';",
+        "import { delimiter, join } from 'node:path';",
+        `const DSH_HOME = ${JSON.stringify(request.dshHome)};`,
+        `const PKG = ${JSON.stringify(request.pkg)};`,
+        `const PROFILE = ${JSON.stringify(request.profile)};`,
+        `const FROM = ${JSON.stringify(request.from)};`,
+        `const TO = ${JSON.stringify(target)};`,
+        `const MARKER = ${JSON.stringify(paths.marker)};`,
+        `const LOG = ${JSON.stringify(paths.log)};`,
+        `const CLI = ${JSON.stringify(cli)};`,
+        'const say = (message) => appendFileSync(LOG, `${new Date().toISOString()} ${message}\\n`);',
+        "const onDisk = () => { try { const read = JSON.parse(readFileSync(join(DSH_HOME, 'profiles', PROFILE, 'node_modules', PKG, 'package.json'), 'utf8')); return typeof read.version === 'string' ? read.version : ''; } catch { return ''; } };",
+        'const writeMarker = (state, version) => writeFileSync(MARKER, JSON.stringify({ pkg: PKG, profile: PROFILE, from: FROM, to: TO, state, version, at: new Date().toISOString() }) + \'\\n\');',
+        "const install = (version) => { const result = spawnSync(CLI.file, [...CLI.args, 'plugin', '--profile', PROFILE, 'add', `${PKG}@${version}`], { env: { ...process.env, ...CLI.env }, encoding: 'utf8' }); if (result.stdout) say(result.stdout.trim()); if (result.stderr) say(result.stderr.trim()); if (result.error) say(String(result.error)); return result.status === 0; };",
+        "const canRun = () => { if (CLI.file.includes('/') || (CLI.file.length > 2 && CLI.file[1] === ':')) return existsSync(CLI.file); const exts = process.platform === 'win32' ? (process.env.PATHEXT ?? '.EXE;.CMD;.BAT').split(';') : ['']; return (process.env.PATH ?? '').split(delimiter).some((dir) => exts.some((ext) => existsSync(join(dir, CLI.file + ext)))); };",
+        'const isTo = () => onDisk() === TO;',
+        "const isOther = () => { const version = onDisk(); return version !== '' && version !== FROM; };",
+        `say(\`开始 \${FROM} -> \${TO}（不卸任何一行）\`);`,
+        "writeMarker('running', FROM);",
+        `if (!canRun()) { say(${JSON.stringify(missing)}); writeMarker('failed', FROM); process.exit(1); }`,
+        "if (install(TO) && (TO === 'latest' ? isOther() : isTo())) {",
+        '  say(`换好了：${onDisk()} 在盘上（目标 ${TO}），' + restart + ' 才用得上`);',
+        "  writeMarker('ok', onDisk());",
+        '  process.exit(0);',
+        '}',
+        'say(`换版没成（盘上 ${onDisk()}）—— 把 ${FROM} 装回去`);',
+        "if (install(FROM) && onDisk() === FROM) {",
+        '  say(`已回滚：${FROM} 还在盘上，工作台这一行没被动过`);',
+        "  writeMarker('rolled-back', FROM);",
+        '  process.exit(0);',
+        '}',
+        `say(${JSON.stringify(`回滚也没成。救法：${rescue}（或 ${last}）`)});`,
+        "writeMarker('failed', onDisk());",
+        'process.exit(1);',
+        '',
+    ].join('\n');
+}
+export function planSelfUpdate(request, now = new Date(), cli = selfUpdateCliFor(request.profile), platform = process.platform) {
+    const paths = selfUpdatePaths(request.dshHome, platform);
+    const windows = platform === 'win32';
+    return {
+        paths,
+        script: windows ? selfUpdateNodeScript(request, paths, cli) : selfUpdateScript(request, paths, cli),
+        marker: selfUpdateMarker(request, 'running', request.from, now.toISOString()),
+        command: windows
+            ? {
+                file: process.execPath,
+                args: [paths.script],
+                env: hostSurface().runtime === 'electron' ? { ELECTRON_RUN_AS_NODE: '1' } : {},
+                log: paths.log,
+            }
+            : { 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);
+    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);
+    const forward = recoveryCommand({
+        profile: request.profile,
+        pkg: request.pkg,
+        version: request.to === '' ? 'latest' : request.to,
+        cli,
+    });
+    return { started: true, paths: plan.paths, forward };
+}
+function asText(value) {
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+function readTail(file) {
+    try {
+        const info = statSync(file);
+        if (!info.isFile() || info.size === 0)
+            return undefined;
+        const start = Math.max(0, info.size - 4096);
+        const length = info.size - start;
+        const buffer = Buffer.alloc(length);
+        const fd = openSync(file, 'r');
+        try {
+            readSync(fd, buffer, 0, length, start);
+        }
+        finally {
+            closeSync(fd);
+        }
+        const lines = buffer
+            .toString('utf8')
+            .split('\n')
+            .map((line) => line.trim())
+            .filter((line) => line !== '');
+        if (lines.length === 0)
+            return undefined;
+        return lines.slice(-4).join(' / ').slice(0, 800);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readSelfUpdateView(home, profile) {
+    const paths = selfUpdatePaths(home);
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(paths.marker, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof raw !== 'object' || raw === null)
+        return undefined;
+    const record = raw;
+    const state = asText(record.state);
+    if (state === undefined || !SELF_UPDATE_STATES.includes(state))
+        return undefined;
+    const owner = asText(record.profile);
+    if (profile !== undefined && owner !== undefined && owner !== profile)
+        return undefined;
+    const from = asText(record.from);
+    const to = asText(record.to);
+    const version = asText(record.version);
+    const at = asText(record.at);
+    const tail = readTail(paths.log);
+    return {
+        state: state,
+        ...(owner === undefined ? {} : { profile: owner }),
+        ...(from === undefined ? {} : { from }),
+        ...(to === undefined ? {} : { to }),
+        ...(version === undefined ? {} : { version }),
+        ...(at === undefined ? {} : { at }),
+        ...(tail === undefined ? {} : { tail }),
+    };
+}
+export { runningVersionOf } from '@dsh-workbench/shared/host';

package/dist/toolchain.d.ts

@@ -0,0 +1,83 @@
+export interface ToolchainProcess {
+    readonly versions: {
+        readonly electron?: string | undefined;
+        readonly node?: string | undefined;
+    };
+    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 interface ToolchainOptions {
+    readonly root: string;
+    readonly proc?: ToolchainProcess | undefined;
+    readonly platform?: NodeJS.Platform | undefined;
+    readonly log?: ((message: string) => void) | undefined;
+}
+export interface ToolchainResult {
+    readonly pathDir?: string | undefined;
+    readonly npmDir?: string | undefined;
+    readonly pnpmDir?: string | undefined;
+    readonly files: readonly string[];
+}
+export declare const LOCAL_NPM_VERSION: string;
+export declare const LOCAL_PNPM_VERSION: string;
+export declare function localNpmRoot(root: string): string;
+export declare function localNpmBin(root: string): string;
+export declare function localNpmCache(root: string): string;
+export declare function localNpmCommand(root: string, platform?: NodeJS.Platform): string;
+export declare function localNpmInstallCommand(root: string, proc?: PnpmProcess, exists?: (path: string) => boolean, platform?: NodeJS.Platform): string | undefined;
+export interface LocalNpmProvision {
+    readonly ok: boolean;
+    readonly detail: string;
+    readonly binDir?: string | undefined;
+}
+export declare function provisionLocalNpm(options: {
+    readonly root: string;
+    readonly run: (command: string) => Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+    readonly installed?: (() => boolean) | undefined;
+    readonly platform?: NodeJS.Platform | undefined;
+    readonly proc?: PnpmProcess | undefined;
+    readonly exists?: ((path: string) => boolean) | undefined;
+}): Promise<LocalNpmProvision>;
+export declare function localPnpmRoot(root: string): string;
+export declare function localPnpmBin(root: string): string;
+export declare function localPnpmCommand(root: string, platform?: NodeJS.Platform): string;
+export declare function localPnpmInstallCommand(root: string, proc?: PnpmProcess, exists?: (path: string) => boolean, platform?: NodeJS.Platform): string | undefined;
+export interface LocalPnpmProvision {
+    readonly ok: boolean;
+    readonly detail: string;
+    readonly binDir?: string | undefined;
+}
+export declare function provisionLocalPnpm(options: {
+    readonly root: string;
+    readonly run: (command: string) => Promise<{
+        ok: boolean;
+        detail: string;
+    }>;
+    readonly installed?: (() => boolean) | undefined;
+    readonly platform?: NodeJS.Platform | undefined;
+    readonly proc?: PnpmProcess | undefined;
+    readonly exists?: ((path: string) => boolean) | 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;
+export declare function ensureToolchain(options: ToolchainOptions): ToolchainResult;

package/dist/toolchain.js

@@ -0,0 +1,197 @@
+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 { join } from 'node:path';
+import { quoteShellArg, quoteShellArgFor } from '@dsh-workbench/shared/host';
+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 const LOCAL_NPM_VERSION = [10, 9, 4].join('.');
+export const LOCAL_PNPM_VERSION = [10, 32, 1].join('.');
+export function localNpmRoot(root) {
+    return join(root, 'npm');
+}
+export function localNpmBin(root) {
+    return join(localNpmRoot(root), 'node_modules', '.bin');
+}
+export function localNpmCache(root) {
+    return join(root, 'npm-cache');
+}
+export function localNpmCommand(root, platform = process.platform) {
+    return join(localNpmBin(root), platform === 'win32' ? 'npm.cmd' : 'npm');
+}
+export function localNpmInstallCommand(root, proc = process, exists = existsSync, platform = process.platform) {
+    const pnpm = desktopPnpmPath(proc, exists);
+    if (pnpm === undefined)
+        return undefined;
+    return (`node ${quoteShellArgFor(pnpm, platform)} add --dir ${quoteShellArgFor(localNpmRoot(root), platform)} ` +
+        `npm@${LOCAL_NPM_VERSION} --store-dir ${quoteShellArgFor(join(root, 'npm-store'), platform)}`);
+}
+export async function provisionLocalNpm(options) {
+    const command = localNpmInstallCommand(options.root, options.proc ?? process, options.exists ?? existsSync);
+    if (command === undefined)
+        return { ok: false, detail: '找不到 Desktop 自带 pnpm，装不了本地 npm' };
+    try {
+        mkdirSync(localNpmRoot(options.root), { recursive: true });
+    }
+    catch (error) {
+        return { ok: false, detail: `建不了 ${localNpmRoot(options.root)}：${String(error)}` };
+    }
+    const result = await options.run(command);
+    if (!result.ok)
+        return { ok: false, detail: result.detail };
+    const platform = options.platform ?? process.platform;
+    const installed = options.installed?.() ?? existsSync(localNpmCommand(options.root, platform));
+    if (!installed)
+        return { ok: false, detail: 'pnpm 跑完但本地 npm 不在' };
+    return {
+        ok: true,
+        binDir: localNpmBin(options.root),
+        detail: `npm@${LOCAL_NPM_VERSION} 装到 ${localNpmRoot(options.root)}`,
+    };
+}
+export function localPnpmRoot(root) {
+    return join(root, 'pnpm-10');
+}
+export function localPnpmBin(root) {
+    return join(localPnpmRoot(root), 'node_modules', '.bin');
+}
+export function localPnpmCommand(root, platform = process.platform) {
+    return join(localPnpmBin(root), platform === 'win32' ? 'pnpm.cmd' : 'pnpm');
+}
+export function localPnpmInstallCommand(root, proc = process, exists = existsSync, platform = process.platform) {
+    const pnpm = desktopPnpmPath(proc, exists);
+    if (pnpm === undefined)
+        return undefined;
+    return (`node ${quoteShellArgFor(pnpm, platform)} add --dir ${quoteShellArgFor(localPnpmRoot(root), platform)} ` +
+        `pnpm@${LOCAL_PNPM_VERSION} --store-dir ${quoteShellArgFor(join(root, 'pnpm-store'), platform)}`);
+}
+export async function provisionLocalPnpm(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)}` };
+    }
+    const result = await options.run(command);
+    if (!result.ok)
+        return { ok: false, detail: result.detail };
+    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)}`,
+    };
+}
+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: process.env, 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');
+    }
+    catch {
+        return null;
+    }
+}
+export function desktopNodeBinary(proc = process, platform = process.platform, 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', 'node', 'bin', platform === 'win32' ? 'node.exe' : 'node');
+    return exists(path) ? path : undefined;
+}
+export function desktopNodeShim(proc = process, platform = process.platform, exists = existsSync) {
+    if (proc.versions.electron === undefined)
+        return undefined;
+    const node = desktopNodeBinary(proc, platform, exists);
+    if (platform === 'win32') {
+        return node === undefined
+            ? `@echo off\r\nset ELECTRON_RUN_AS_NODE=1\r\n"${proc.execPath}" %*\r\n`
+            : `@echo off\r\n"${node}" %*\r\n`;
+    }
+    return node === undefined
+        ? `#!/bin/sh\nexec env ELECTRON_RUN_AS_NODE=1 ${quoteShellArg(proc.execPath)} "$@"\n`
+        : `#!/bin/sh\nexec ${quoteShellArg(node)} "$@"\n`;
+}
+export function toolchainBinDir(root) {
+    return join(root, 'bin', 'desktop');
+}
+export function ensureToolchain(options) {
+    const platform = options.platform ?? process.platform;
+    const shim = desktopNodeShim(options.proc ?? process, platform);
+    if (shim === undefined)
+        return { files: [] };
+    const pathDir = toolchainBinDir(options.root);
+    const file = join(pathDir, platform === 'win32' ? 'node.cmd' : 'node');
+    const files = [];
+    let release;
+    try {
+        mkdirSync(pathDir, { recursive: true });
+        release = lockfile.lockSync(pathDir, { realpath: false });
+        if (readText(file) !== shim) {
+            rmSync(file, { force: true });
+            writeFileAtomic.sync(file, shim, 'utf8');
+            chmodSync(file, 0o755);
+            files.push(file);
+        }
+    }
+    catch (error) {
+        options.log?.(`工具链 shim 没写成：${String(error)}`);
+        return { files };
+    }
+    finally {
+        release?.();
+    }
+    const npmDir = existsSync(localNpmCommand(options.root, platform)) ? localNpmBin(options.root) : undefined;
+    const pnpmDir = existsSync(localPnpmCommand(options.root, platform)) ? localPnpmBin(options.root) : undefined;
+    return {
+        pathDir,
+        ...(npmDir === undefined ? {} : { npmDir }),
+        ...(pnpmDir === undefined ? {} : { pnpmDir }),
+        files,
+    };
+}

package/dist/version-range.d.ts

@@ -0,0 +1 @@
+export { checkVersionRange, type VersionVerdict } from '@dsh-workbench/shared/host';

package/dist/version-range.js

@@ -0,0 +1 @@
+export { checkVersionRange } from '@dsh-workbench/shared/host';

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@dsh-workbench/adapter-probe",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0-beta.1",
+  "description": "Workbench adapter-probe adapter.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "execa": "^10.2.0",
+    "proper-lockfile": "^4.1.2",
+    "write-file-atomic": "^8.0.0",
+    "@dsh-workbench/adapter-profile": "1.0.0-beta.1",
+    "@dsh-workbench/adapter-runtime": "1.0.0-beta.1",
+    "@dsh-workbench/shared": "1.0.0-beta.1",
+    "@dsh-workbench/adapter-supply": "1.0.0-beta.1"
+  },
+  "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"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run --testTimeout=20000",
+    "arch": "arch-guard",
+    "check:runtimes": "node ../../scripts/check-adapter-package.mjs --runtime",
+    "coverage": "vitest run --coverage --coverage.reporter=text-summary --testTimeout=20000"
+  }
 }