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

package/dist/probe-units.js

@@ -0,0 +1,190 @@
+import { OPENCLI_TIMEOUT_MS, PROBE_TTL_MS, buildSupplyIndex, NEED_KIND_SPECS, needIdOf, commandNamesMatch, npmSourceOf, parseJsonLoose, quoteShellArg, runShell, } from '@dsh-workbench/shared/host';
+import { npmRegistryOf } from '@dsh-workbench/adapter-supply';
+import { probeRelease } from '@dsh-workbench/adapter-profile';
+import { createTimedMemo } from './probe-cache.js';
+import { probeLibs } from './probe-libs.js';
+import { aggregate, binStateOf, envStateOf, extensionStateOf } from './probe-verdict.js';
+const BINARY_PROBE_TIMEOUT_MS = 5_000;
+const KNOWN_RUNTIMES = ['opencli'];
+export function parsePluginList(stdout) {
+    const parsed = parseJsonLoose(stdout);
+    if (Array.isArray(parsed))
+        return parsed;
+    return /no plugins? installed/i.test(stdout) ? [] : undefined;
+}
+async function probeBinary(shell, 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);
+    return result?.exitCode === 0;
+}
+async function runtimeList(options) {
+    if (!options.needsPlugins)
+        return {};
+    const result = await runShell(options.shell, `${options.command} plugin list -f json`, {
+        timeoutMs: OPENCLI_TIMEOUT_MS,
+    }).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);
+    return list === undefined ? { failure: 'plugin list 的输出读不懂（不是 JSON 数组）' } : { list };
+}
+function conflictOf(index, need) {
+    const entry = index.entryOf(need.kind, need.name);
+    if (entry?.conflicted !== true)
+        return undefined;
+    const conflict = index.conflicts.find((item) => item.names.includes(need.name) && item.key === entry.key);
+    return conflict?.detail ?? '来源声明有冲突';
+}
+async function releasesOf(index, options) {
+    const found = new Map();
+    for (const entry of index.entries.values()) {
+        if (entry.kind !== 'extension' || entry.conflicted)
+            continue;
+        const source = npmSourceOf(entry.sources);
+        if (source === undefined)
+            continue;
+        const registry = npmRegistryOf(source, process.env);
+        const signal = await probeRelease({
+            shell: options.shell,
+            package: entry.package,
+            ...(registry.ok ? { registry: registry.value } : {}),
+            force: options.force,
+        });
+        if (signal === undefined)
+            continue;
+        for (const name of entry.names)
+            found.set(`${entry.runtime ?? 'opencli'}:${name}`, signal);
+    }
+    return found;
+}
+const pendingProbes = new Map();
+function cacheKeyOf(commandKey, units, unit) {
+    const scope = units.map((one) => one.unit).sort().join('|');
+    return `${commandKey}:${scope}:${unit}`;
+}
+function runtimeCommandOf(need, runtimeCommands) {
+    const resolved = runtimeCommands[need.runtime];
+    if (resolved !== undefined && resolved.trim() !== '')
+        return resolved;
+    return KNOWN_RUNTIMES.includes(need.runtime) ? need.runtime : undefined;
+}
+export async function probeUnits(options) {
+    const { shell, 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)) {
+        return hits;
+    }
+    const key = `${commandKey}:${units.map((unit) => unit.unit).join('|')}`;
+    if (!force) {
+        const shared = pendingProbes.get(key);
+        if (shared !== undefined)
+            return shared;
+    }
+    const task = loadCapabilities({ shell, runtimeCommands, units, force });
+    pendingProbes.set(key, task);
+    try {
+        return await task;
+    }
+    finally {
+        if (pendingProbes.get(key) === task)
+            pendingProbes.delete(key);
+    }
+}
+async function loadCapabilities(options) {
+    const { shell, runtimeCommands, units, force } = options;
+    const index = buildSupplyIndex(units.map((unit) => ({ id: unit.unit, needs: unit.needs })));
+    const binNames = [
+        ...new Set(units.flatMap((unit) => unit.needs.filter((need) => need.kind === 'bin').map((need) => need.name.trim()).filter((name) => name !== ''))),
+    ];
+    const binaries = new Map();
+    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));
+    }));
+    const extensionNeeds = units.flatMap((unit) => unit.needs.filter((need) => need.kind === 'extension'));
+    const runtimes = [...new Set(extensionNeeds.map((need) => need.runtime))];
+    const lists = new Map();
+    await Promise.all(runtimes.map(async (runtime) => {
+        const command = runtimeCommands[runtime] ?? (KNOWN_RUNTIMES.includes(runtime) ? runtime : undefined);
+        if (command === undefined) {
+            lists.set(runtime, { failure: `工作台还不认识运行时 ${runtime}（没有对应的探法）` });
+            return;
+        }
+        const needsPlugins = extensionNeeds.some((need) => need.runtime === runtime && conflictOf(index, need) === undefined);
+        lists.set(runtime, await runtimeList({ shell, 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 statesOfUnit = (unit) => unit.needs.map((need) => {
+        const conflict = need.kind === 'extension' || need.kind === 'lib' ? conflictOf(index, need) : undefined;
+        if (conflict !== undefined) {
+            return {
+                id: needIdOf(need),
+                kind: need.kind,
+                name: need.name,
+                status: 'unchecked',
+                detail: `来源冲突：${conflict}`,
+            };
+        }
+        const probeClass = NEED_KIND_SPECS[need.kind].probe;
+        if (probeClass === 'bin' && need.kind === 'bin')
+            return binStateOf(need, binaries.get(need.name) === true);
+        if (probeClass === 'env' && need.kind === 'env')
+            return envStateOf(need, process.env[need.name]);
+        if (probeClass === 'package' && need.kind === 'lib') {
+            return (libStates.get(need.name) ?? {
+                id: needIdOf(need),
+                kind: 'lib',
+                name: need.name,
+                status: 'unchecked',
+                detail: '这个共用依赖没进这一轮探测',
+            });
+        }
+        if (need.kind !== 'extension') {
+            return {
+                id: needIdOf(need),
+                kind: need.kind,
+                name: need.name,
+                status: 'unchecked',
+                detail: '这个种类没有对应的探法 —— 升级工作台',
+            };
+        }
+        const probe = lists.get(need.runtime) ?? { failure: '没跑这一轮探测' };
+        const command = runtimeCommandOf(need, runtimeCommands) ?? need.runtime;
+        const hit = probe.list?.find((item) => typeof item === 'object' && item !== null && String(item.name) === need.name);
+        return extensionStateOf({
+            need,
+            ...(probe.list === undefined ? {} : { hit }),
+            ...(probe.failure === undefined ? {} : { failure: probe.failure }),
+            command,
+            ...(releases.get(`${need.runtime}:${need.name}`) === undefined
+                ? {}
+                : { release: releases.get(`${need.runtime}:${need.name}`) }),
+            sources: index.sourcesOf('extension', need.name),
+        });
+    });
+    return units.map((unit) => {
+        const capability = aggregate(unit.unit, unit.needs, statesOfUnit(unit));
+        unitCache.set(cacheKeyOf(Object.values(runtimeCommands).sort().join('|'), units, unit.unit), capability);
+        return capability;
+    });
+}
+export async function probeUnitCommands(options) {
+    const units = options.catalog === undefined ? [options.unit] : options.catalog;
+    const all = await probeUnits({
+        shell: options.shell,
+        runtimeCommands: options.runtimeCommands ?? {},
+        units,
+        ...(options.force === undefined ? {} : { force: options.force }),
+    });
+    const found = all.find((item) => item.unit === options.unit.unit);
+    return (found ?? aggregate(options.unit.unit, options.unit.needs, []));
+}
+const unitCache = createTimedMemo(PROBE_TTL_MS);
+export const resetProbeCache = () => {
+    unitCache.clear();
+    pendingProbes.clear();
+};

package/dist/probe-verdict.d.ts

@@ -0,0 +1,16 @@
+import type { BinNeed, EnvNeed, ExtensionNeed, Need, NeedState, PluginRelease, SupplySource, UnitCapability } from '@dsh-workbench/shared/host';
+export declare function pluginUpdateCommand(plugin: string | undefined): string | undefined;
+export declare function upgradeLine(need: ExtensionNeed, command: string, latest: string, sources: readonly SupplySource[]): string | undefined;
+export declare function extensionStateOf(options: {
+    readonly need: ExtensionNeed;
+    readonly hit?: {
+        readonly commands?: unknown;
+    } | undefined;
+    readonly failure?: string | undefined;
+    readonly command: string;
+    readonly release?: PluginRelease | undefined;
+    readonly sources: readonly SupplySource[];
+}): NeedState;
+export declare function binStateOf(need: BinNeed, present: boolean): NeedState;
+export declare function envStateOf(need: EnvNeed, value: string | undefined): NeedState;
+export declare function aggregate(unit: string, needs: readonly Need[], states: readonly NeedState[]): UnitCapability;

package/dist/probe-verdict.js

@@ -0,0 +1,126 @@
+import { needIdOf, quoteShellArg } from '@dsh-workbench/shared/host';
+import { resolvePluginSource } from '@dsh-workbench/adapter-supply';
+import { isNewerVersion } from '@dsh-workbench/adapter-profile';
+const RANK = {
+    ok: 0,
+    unchecked: 1,
+    outdated: 2,
+    unsatisfied: 3,
+    missing: 4,
+};
+export function pluginUpdateCommand(plugin) {
+    return plugin === undefined
+        ? undefined
+        : `${quoteShellArg('opencli')} plugin update ${quoteShellArg(plugin)}`;
+}
+export function upgradeLine(need, command, latest, sources) {
+    for (const source of sources) {
+        const resolved = resolvePluginSource(source, process.env, {
+            command,
+            plugin: need.name,
+            version: latest,
+            mode: 'update',
+        });
+        if (resolved.ok)
+            return resolved.line;
+    }
+    return undefined;
+}
+function firstResolvable(need, command, sources) {
+    let problem = 'not-declared';
+    for (const source of sources) {
+        const resolved = resolvePluginSource(source, process.env, { command, plugin: need.name });
+        if (resolved.ok)
+            return { provision: 'ready', command: resolved.line };
+        problem = resolved.problem;
+    }
+    return { provision: problem };
+}
+export function extensionStateOf(options) {
+    const base = { id: needIdOf(options.need), kind: 'extension', name: options.need.name };
+    if (options.failure !== undefined) {
+        return { ...base, status: 'unchecked', detail: options.failure };
+    }
+    if (options.hit === undefined) {
+        const resolved = firstResolvable(options.need, options.command, options.sources);
+        return {
+            ...base,
+            status: 'missing',
+            detail: `已装插件里没有 ${options.need.name}`,
+            provision: resolved.provision,
+            ...(resolved.command === undefined ? {} : { command: resolved.command }),
+        };
+    }
+    const available = new Set((Array.isArray(options.hit.commands) ? options.hit.commands : []).map(String));
+    const missing = (options.need.commands ?? []).filter((name) => !available.has(name));
+    const release = options.release;
+    const behind = release?.latest !== undefined && isNewerVersion(release.latest, release.installed);
+    const outdated = missing.length > 0 || behind;
+    const upgrade = behind && release?.latest !== undefined
+        ? upgradeLine(options.need, options.command, release.latest, options.sources)
+        : undefined;
+    return {
+        ...base,
+        status: outdated ? 'outdated' : 'ok',
+        detail: outdated
+            ? missing.length > 0
+                ? `${options.need.name} 缺 ${missing.length} 条命令：${missing.join('、')}`
+                : `${options.need.name} 装的是 ${release?.installed ?? '未知'}，源上最新 ${release?.latest ?? '未知'}`
+            : `${options.need.name} 的命令都在`,
+        ...(missing.length === 0 ? {} : { missing }),
+        ...(release?.installed === undefined ? {} : { installed: release.installed }),
+        ...(release?.latest === undefined ? {} : { latest: release.latest }),
+        ...(outdated || behind
+            ? {
+                command: upgrade ?? pluginUpdateCommand(options.need.name),
+            }
+            : {}),
+    };
+}
+export function binStateOf(need, present) {
+    return {
+        id: needIdOf(need),
+        kind: 'bin',
+        name: need.name,
+        status: present ? 'ok' : 'missing',
+        detail: present ? `${need.name} 命令在` : `这台机器上找不到 ${need.name} 命令（PATH 里没有）`,
+    };
+}
+export function envStateOf(need, value) {
+    const present = value !== undefined && value.trim() !== '';
+    return {
+        id: needIdOf(need),
+        kind: 'env',
+        name: need.name,
+        status: present ? 'ok' : 'missing',
+        detail: present
+            ? `${need.name} 已设置`
+            : `环境变量 ${need.name} 没设${need.secret === true ? '（值不会被任何界面回显）' : ''}`,
+        ...(need.secret === true ? { secret: true } : {}),
+    };
+}
+export function aggregate(unit, needs, states) {
+    const required = new Set(needs.filter((need) => need.required !== false).map((need) => needIdOf(need)));
+    let worst = 'ok';
+    for (const state of states) {
+        if (!required.has(state.id))
+            continue;
+        if (RANK[state.status] > RANK[worst])
+            worst = state.status;
+    }
+    const optionalGap = states.some((state) => state.status !== 'ok' && !required.has(state.id));
+    const status = worst === 'ok'
+        ? optionalGap
+            ? 'degraded'
+            : 'ok'
+        : worst === 'missing' || worst === 'unsatisfied'
+            ? 'missing'
+            : worst;
+    const first = states.find((state) => state.status !== 'ok');
+    return {
+        unit,
+        status,
+        needs: [...states],
+        detail: first === undefined ? '依赖都齐了' : first.detail,
+    };
+}

package/dist/runtime-seed.d.ts

@@ -0,0 +1,43 @@
+import type { spawn } from 'node:child_process';
+import type { DshHostContext } from '@dsh-workbench/shared';
+export type SeedLog = (message: string) => void;
+export interface RuntimeSeedPaths {
+    readonly root: string;
+    readonly entryDir: string;
+    readonly opencliRoot: string;
+    readonly opencliBinDir: string;
+    readonly opencliBin: string;
+    readonly opencliHome: string;
+    readonly workshop: string;
+    readonly workshopPackages: string;
+    readonly workshopManifest: string;
+}
+export interface RuntimeSeedOptions {
+    readonly root: string;
+    readonly home: string;
+    readonly packageRoot: string;
+    readonly platform?: NodeJS.Platform | undefined;
+    readonly log?: SeedLog;
+}
+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 packageRootOf(moduleUrl: string): string;
+export declare function isInstalledCopy(packageRoot: string): boolean;
+export declare function opencliWrapperScript(packageRoot: string, home: string, platform?: NodeJS.Platform): string;
+export interface SeedCommand {
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+    readonly log: string;
+}
+export declare function workshopSeedPlan(packageRoot: string, home: string, root: string, platform?: NodeJS.Platform): {
+    readonly entry: SeedCommand;
+    readonly full: SeedCommand;
+};
+export declare function runDetached(command: SeedCommand, onError: SeedLog, spawnImpl?: typeof spawn): void;
+export declare function prependPath(entryDir: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function seedWorkbenchToolchain(root: string, log: SeedLog): void;
+export declare function seedRuntimeFiles(options: RuntimeSeedOptions): readonly string[];

package/dist/runtime-seed.js

@@ -0,0 +1,178 @@
+import { execa } from 'execa';
+import writeFileAtomic from 'write-file-atomic';
+import { chmodSync, closeSync, mkdirSync, openSync, readFileSync, rmSync, } from 'node:fs';
+import { delimiter, dirname, join, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { quoteShellArg } from '@dsh-workbench/shared/host';
+import { ensureToolchain, localNpmCache, provisionLocalPnpmSync } from './toolchain.js';
+export function opencliBinName(platform = process.platform) {
+    return platform === 'win32' ? 'opencli.cmd' : 'opencli';
+}
+export function runtimeSeedPaths(root, platform = process.platform) {
+    const opencliRoot = join(root, 'opencli');
+    const opencliBinDir = join(opencliRoot, 'bin');
+    const workshop = join(root, 'diy');
+    return {
+        root,
+        entryDir: join(root, 'bin'),
+        opencliRoot,
+        opencliBinDir,
+        opencliBin: join(opencliBinDir, opencliBinName(platform)),
+        opencliHome: join(opencliRoot, 'home'),
+        workshop,
+        workshopPackages: join(workshop, 'packages'),
+        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 packageRootOf(moduleUrl) {
+    return dirname(dirname(dirname(fileURLToPath(moduleUrl))));
+}
+export function isInstalledCopy(packageRoot) {
+    return packageRoot.split(sep).includes('node_modules');
+}
+export function opencliWrapperScript(packageRoot, home, platform = process.platform) {
+    const script = join(packageRoot, 'bin', 'opencli-isolated.mjs');
+    if (platform === 'win32') {
+        return `@echo off\r\nset "DSH_HOME=${home}"\r\nnode "${script}" %*\r\n`;
+    }
+    return `#!/bin/sh\nexport DSH_HOME=${quoteShellArg(home)}\nexec node ${quoteShellArg(script)} "$@"\n`;
+}
+export function workshopSeedPlan(packageRoot, home, root, platform = process.platform) {
+    const script = join(packageRoot, 'scripts', 'seed-workshop.sh');
+    const env = { DSH_HOME: home, DSH_WB_SHELL_ROOT: packageRoot };
+    const log = join(root, 'seed.log');
+    if (platform === 'win32') {
+        const launcher = join(packageRoot, 'bin', 'seed-workshop-windows.mjs');
+        const windowsEnv = { ...env, ELECTRON_RUN_AS_NODE: '1' };
+        return {
+            entry: { file: process.execPath, args: [launcher, 'entry', script], env: windowsEnv, log },
+            full: { file: process.execPath, args: [launcher, 'full', script], env: windowsEnv, log },
+        };
+    }
+    return {
+        entry: { file: 'bash', args: [script, 'entry'], env, log },
+        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;
+    try {
+        fd = openSync(command.log, 'a');
+        const child = spawnImpl(command.file, [...command.args], {
+            env: { ...process.env, ...command.env },
+            detached: true,
+            stdio: ['ignore', fd, fd],
+        });
+        child.on('error', (error) => onError(`自举脚本没跑起来（${command.file}）：${String(error)}`));
+        child.unref();
+    }
+    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);
+    return true;
+}
+export function seedWorkbenchToolchain(root, log) {
+    const toolchain = ensureToolchain({ root, log });
+    for (const file of toolchain.files)
+        log(`工具链写下 ${file}`);
+    if (toolchain.pathDir !== undefined && prependPath(toolchain.pathDir)) {
+        log(`PATH 前插 ${toolchain.pathDir}`);
+    }
+    if (toolchain.npmDir !== undefined) {
+        if (prependPath(toolchain.npmDir))
+            log(`PATH 前插 ${toolchain.npmDir}`);
+        if (process.env.npm_config_cache === undefined) {
+            process.env.npm_config_cache = localNpmCache(root);
+        }
+    }
+    if (toolchain.pnpmDir !== undefined) {
+        if (prependPath(toolchain.pnpmDir))
+            log(`PATH 前插 ${toolchain.pnpmDir}`);
+    }
+    else if (toolchain.pathDir !== undefined) {
+        const installed = provisionLocalPnpmSync({ root });
+        if (installed.ok && installed.binDir !== undefined) {
+            if (prependPath(installed.binDir))
+                log(`PATH 前插 ${installed.binDir}`);
+            log(`工具链 provision ${installed.detail}`);
+        }
+        else {
+            log(`本地 pnpm 10 没装成：${installed.detail}`);
+        }
+    }
+}
+export function seedRuntimeFiles(options) {
+    const platform = options.platform ?? process.platform;
+    const paths = runtimeSeedPaths(options.root, platform);
+    const done = [];
+    try {
+        for (const dir of [paths.entryDir, paths.opencliBinDir, paths.opencliHome, paths.workshopPackages]) {
+            mkdirSync(dir, { recursive: 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);
+            done.push(paths.opencliBin);
+        }
+    }
+    catch (error) {
+        options.log?.(`自举没做完：${String(error)}`);
+    }
+    return done;
+}
+function readText(file) {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/self-update.d.ts

@@ -0,0 +1,63 @@
+import type { spawn } from 'node:child_process';
+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 };
+export interface SelfUpdateCli {
+    readonly file: string;
+    readonly args: readonly string[];
+    readonly env: Readonly<Record<string, string>>;
+}
+export interface SelfUpdateProcess {
+    readonly execPath: string;
+    readonly argv: readonly string[];
+    readonly versions: {
+        readonly electron?: string | undefined;
+        readonly node?: string | undefined;
+    };
+}
+export declare function desktopSelfUpdateCli(proc?: SelfUpdateProcess, exists?: (path: string) => boolean): SelfUpdateCli | undefined;
+export declare function selfUpdateCliFor(profile: string, proc?: SelfUpdateProcess, exists?: (path: string) => boolean): SelfUpdateCli;
+export interface SelfUpdatePaths {
+    readonly dir: string;
+    readonly script: string;
+    readonly marker: string;
+    readonly log: string;
+}
+export interface SelfUpdateRequest {
+    readonly dshHome: string;
+    readonly profile: string;
+    readonly pkg: string;
+    readonly from: string;
+    readonly to: string;
+    readonly pinned: boolean;
+}
+export interface SelfUpdateMarker extends SelfUpdateRequest {
+    readonly state: SelfUpdateState;
+    readonly version: string;
+    readonly at: string;
+}
+export interface SelfUpdatePlan {
+    readonly paths: SelfUpdatePaths;
+    readonly script: string;
+    readonly marker: SelfUpdateMarker;
+    readonly command: SeedCommand;
+}
+export interface SelfUpdateStart {
+    readonly started: boolean;
+    readonly paths: SelfUpdatePaths;
+    readonly forward: string;
+}
+export declare function selfUpdatePaths(dshHome: string, platform?: NodeJS.Platform): SelfUpdatePaths;
+export declare function recoveryCommand(input: {
+    readonly profile: string;
+    readonly pkg: string;
+    readonly version: string;
+    readonly cli?: SelfUpdateCli | undefined;
+}): string;
+export declare function selfUpdateMarker(request: SelfUpdateRequest, state: SelfUpdateState, version: string, at: string): SelfUpdateMarker;
+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 readSelfUpdateView(home: string, profile?: string): WorkbenchSelfUpdate | undefined;
+export { runningVersionOf } from '@dsh-workbench/shared/host';