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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-workbench contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @dsh-workbench/adapter-probe
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+工作台的启动体检与运行时适配器。
+
+## 职责
+
+- preflight / doctor / browser wake
+- opencli 与 pnpm 的隔离安装命令
+- runtime seed、toolchain、版本范围
+- self-update（依赖 runtime seed 与工具链）
+
+## 入口
+
+```ts
+import { createPreflight, probeUnits, startSelfUpdate } from '@dsh-workbench/adapter-probe';
+```
+
+## 边界
+
+这是唯一拥有 `runtime-seed` / `toolchain` / `platform` 的适配器；其他包不得复制这三份实现。
+
+## 验证
+
+```bash
+pnpm --filter @dsh-workbench/adapter-probe run build
+pnpm --filter @dsh-workbench/adapter-probe run test
+```

package/dist/browser-wake.d.ts

@@ -0,0 +1,21 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { WakeBrowserReply } from '@dsh-workbench/shared/contract/protocol/preflight-wake';
+export interface DesktopBrowser {
+    observe(): Promise<void>;
+    wake(): Promise<WakeBrowserReply>;
+}
+export declare function createDesktopBrowser(options: {
+    shell: DshShell;
+    command: string;
+    stateFile: string;
+    platform?: string;
+    home?: string;
+    env?: NodeJS.ProcessEnv;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+    exists?: (path: string) => boolean;
+    waitMs?: number;
+    shortWaitMs?: number;
+    pollMs?: number;
+}): DesktopBrowser;

package/dist/browser-wake.js

@@ -0,0 +1,263 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, win32 } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { quoteShellArg, runShell } from '@dsh-workbench/shared/host';
+const BROWSER_IDS = ['chrome', 'edge', 'brave', 'chromium', 'vivaldi'];
+const BROWSERS = [
+    {
+        id: 'chrome',
+        label: 'Google Chrome',
+        macProcess: 'Google Chrome',
+        linuxBinary: '/usr/bin/google-chrome',
+        linuxProcess: 'chrome',
+    },
+    {
+        id: 'edge',
+        label: 'Microsoft Edge',
+        macProcess: 'Microsoft Edge',
+        linuxBinary: '/usr/bin/microsoft-edge',
+        linuxProcess: 'msedge',
+    },
+    {
+        id: 'brave',
+        label: 'Brave Browser',
+        macProcess: 'Brave Browser',
+        linuxBinary: '/usr/bin/brave-browser',
+        linuxProcess: 'brave',
+    },
+    {
+        id: 'chromium',
+        label: 'Chromium',
+        macProcess: 'Chromium',
+        linuxBinary: '/usr/bin/chromium',
+        linuxProcess: 'chromium',
+    },
+    {
+        id: 'vivaldi',
+        label: 'Vivaldi',
+        macProcess: 'Vivaldi',
+        linuxBinary: '/usr/bin/vivaldi',
+        linuxProcess: 'vivaldi-bin',
+    },
+];
+const WAKE_WAIT_MS = 12_000;
+const SHORT_WAIT_MS = 3_000;
+const POLL_MS = 500;
+const STATUS_TIMEOUT_MS = 5_000;
+const LAUNCH_TIMEOUT_MS = 10_000;
+function isBrowserId(value) {
+    return typeof value === 'string' && BROWSER_IDS.includes(value);
+}
+function specOf(id) {
+    return BROWSERS.find((item) => item.id === id) ?? BROWSERS[0];
+}
+export function createDesktopBrowser(options) {
+    const platform = options.platform ?? process.platform;
+    const home = options.home ?? homedir();
+    const env = options.env ?? process.env;
+    const exists = options.exists ?? existsSync;
+    const waitMs = options.waitMs ?? WAKE_WAIT_MS;
+    const shortWaitMs = options.shortWaitMs ?? SHORT_WAIT_MS;
+    const pollMs = options.pollMs ?? POLL_MS;
+    const command = options.command;
+    async function run(line, timeoutMs) {
+        try {
+            const result = await runShell(options.shell, line, { timeoutMs });
+            return { ok: result.exitCode === 0 && !result.timedOut, stdout: result.stdout };
+        }
+        catch {
+            return { ok: false, stdout: '' };
+        }
+    }
+    function winCandidates(id) {
+        const programFiles = env.ProgramFiles ?? env.PROGRAMFILES ?? 'C:\\Program Files';
+        const programFilesX86 = env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)';
+        const localAppData = env.LOCALAPPDATA ?? join(home, 'AppData', 'Local');
+        const relative = {
+            chrome: ['Google', 'Chrome', 'Application', 'chrome.exe'],
+            edge: ['Microsoft', 'Edge', 'Application', 'msedge.exe'],
+            brave: ['BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe'],
+            chromium: ['Chromium', 'Application', 'chrome.exe'],
+            vivaldi: ['Vivaldi', 'Application', 'vivaldi.exe'],
+        };
+        const bases = id === 'edge' || id === 'chrome' || id === 'brave'
+            ? [programFiles, programFilesX86, localAppData]
+            : [localAppData, programFiles];
+        return bases.map((base) => win32.join(base, ...relative[id]));
+    }
+    function winExecutable(id) {
+        return winCandidates(id).find((path) => exists(path));
+    }
+    function installed() {
+        return BROWSERS.filter((spec) => {
+            if (platform === 'darwin') {
+                return (exists(`/Applications/${spec.label}.app`) ||
+                    exists(join(home, 'Applications', `${spec.label}.app`)));
+            }
+            if (platform === 'linux')
+                return exists(spec.linuxBinary);
+            if (platform === 'win32')
+                return winExecutable(spec.id) !== undefined;
+            return false;
+        }).map((spec) => spec.id);
+    }
+    function readSaved() {
+        try {
+            const raw = JSON.parse(readFileSync(options.stateFile, 'utf8'));
+            if (typeof raw !== 'object' || raw === null)
+                return undefined;
+            const value = raw.browser;
+            return isBrowserId(value) ? value : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function save(id) {
+        try {
+            mkdirSync(dirname(options.stateFile), { recursive: true });
+            writeFileSync(options.stateFile, `${JSON.stringify({ browser: id }, null, 2)}\n`, 'utf8');
+        }
+        catch {
+            return;
+        }
+    }
+    async function running() {
+        if (platform === 'darwin' || platform === 'linux') {
+            const names = BROWSERS.map((spec) => quoteShellArg(platform === 'darwin' ? spec.macProcess : spec.linuxProcess));
+            const result = await run(`pgrep -lx ${names.join(' ')}`, STATUS_TIMEOUT_MS);
+            const found = [];
+            for (const line of result.stdout.split('\n')) {
+                const match = /^\s*\d+\s+(.+?)\s*$/.exec(line);
+                const name = match?.[1];
+                if (name === undefined)
+                    continue;
+                const spec = BROWSERS.find((item) => item.macProcess === name || item.linuxProcess === name);
+                if (spec !== undefined && !found.includes(spec.id))
+                    found.push(spec.id);
+            }
+            return found;
+        }
+        if (platform === 'win32') {
+            const result = await run('tasklist /FO CSV /NH', STATUS_TIMEOUT_MS);
+            const found = [];
+            for (const line of result.stdout.split('\n')) {
+                const name = /^"([^"]+)"/.exec(line)?.[1]?.toLowerCase();
+                if (name === 'chrome.exe')
+                    found.push('chrome');
+                if (name === 'msedge.exe')
+                    found.push('edge');
+                if (name === 'brave.exe')
+                    found.push('brave');
+                if (name === 'chromium.exe')
+                    found.push('chromium');
+                if (name === 'vivaldi.exe')
+                    found.push('vivaldi');
+            }
+            return [...new Set(found)];
+        }
+        return [];
+    }
+    async function daemonStatus() {
+        const result = await run(`${command} daemon status`, STATUS_TIMEOUT_MS);
+        if (!result.ok)
+            return 'unknown';
+        if (/^Daemon: not running/m.test(result.stdout))
+            return 'down';
+        if (/^Extension: connected/m.test(result.stdout))
+            return 'connected';
+        if (/^Extension:/m.test(result.stdout))
+            return 'disconnected';
+        return 'unknown';
+    }
+    async function waitConnected(ms) {
+        const deadline = Date.now() + ms;
+        for (;;) {
+            if ((await daemonStatus()) === 'connected')
+                return true;
+            if (Date.now() >= deadline)
+                return false;
+            await delay(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+        }
+    }
+    function pickTarget(now) {
+        const have = installed();
+        if (have.length === 0)
+            return undefined;
+        const saved = readSaved();
+        if (saved !== undefined && have.includes(saved))
+            return saved;
+        const awake = have.filter((id) => now.includes(id));
+        if (awake.length === 1)
+            return awake[0];
+        return have[0];
+    }
+    function appPath(id) {
+        const label = specOf(id).label;
+        const local = `/Applications/${label}.app`;
+        return exists(local) ? local : join(home, 'Applications', `${label}.app`);
+    }
+    async function launch(id) {
+        if (platform === 'darwin') {
+            const result = await run(`open -g -j -a ${quoteShellArg(appPath(id))}`, LAUNCH_TIMEOUT_MS);
+            return result.ok;
+        }
+        if (platform === 'linux') {
+            const binary = quoteShellArg(specOf(id).linuxBinary);
+            const result = await run(`setsid ${binary} --no-startup-window >/dev/null 2>&1 < /dev/null &`, LAUNCH_TIMEOUT_MS);
+            return result.ok;
+        }
+        if (platform === 'win32') {
+            const exe = winExecutable(id);
+            if (exe === undefined)
+                return false;
+            const result = await run(`cmd /d /s /c start "" ${quoteShellArg(exe)}`, LAUNCH_TIMEOUT_MS);
+            return result.ok;
+        }
+        return false;
+    }
+    async function observe() {
+        const now = await running();
+        if (now.length === 0)
+            return;
+        const saved = readSaved();
+        if (saved !== undefined && now.includes(saved))
+            return;
+        if (now.length === 1) {
+            save(now[0]);
+            return;
+        }
+        if (now.includes('chrome'))
+            save('chrome');
+    }
+    async function wake() {
+        if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32')
+            return { status: 'unsupported' };
+        const before = await daemonStatus();
+        if (before === 'connected') {
+            await observe();
+            return { status: 'connected' };
+        }
+        if (before !== 'disconnected')
+            return { status: 'unknown' };
+        const now = await running();
+        const target = pickTarget(now);
+        if (target === undefined)
+            return { status: 'no-browser' };
+        if (now.includes(target)) {
+            if (await waitConnected(shortWaitMs))
+                return { status: 'connected', browser: target };
+            return { status: 'browser-open', browser: target };
+        }
+        if (!(await launch(target)))
+            return { status: 'launch-failed', browser: target };
+        if (await waitConnected(waitMs)) {
+            save(target);
+            options.logger?.warn?.(`[dsh-workbench] Desktop：已打开 ${specOf(target).label}`);
+            return { status: 'connected', browser: target };
+        }
+        return { status: 'not-connected', browser: target };
+    }
+    return { observe, wake };
+}

package/dist/diy-preset-health.d.ts

@@ -0,0 +1,13 @@
+import type { DshAgentPresetRow, DshHostContext } from '@dsh-workbench/shared';
+export declare const DIY_UPGRADE_COMMAND = "npm i -g @deepseek-ai/dsh@latest";
+export interface DiyPresetVerdict {
+    readonly ok: boolean;
+    readonly rows: readonly string[];
+    readonly detail: string;
+}
+export declare function brokenRowsOf(detail: string): readonly string[];
+export declare function diyPresetVerdictOf(presets: readonly DshAgentPresetRow[]): DiyPresetVerdict | undefined;
+export declare function createDiyPresetProbe(ctx: DshHostContext, options?: {
+    deadlineMs?: number;
+    everyMs?: number;
+}): () => Promise<DiyPresetVerdict | undefined>;

package/dist/diy-preset-health.js

@@ -0,0 +1,45 @@
+import { DIY_PRESET_ID } from '@dsh-workbench/shared/contract/protocol/diy';
+export const DIY_UPGRADE_COMMAND = 'npm i -g @deepseek-ai/dsh@latest';
+export function brokenRowsOf(detail) {
+    const rows = [];
+    for (const line of String(detail ?? '').split('\n')) {
+        const text = line.trim();
+        if (text === '')
+            continue;
+        const at = text.indexOf(' (');
+        rows.push(at < 0 ? text : text.slice(0, at));
+    }
+    return rows;
+}
+export function diyPresetVerdictOf(presets) {
+    if (!Array.isArray(presets) || presets.length === 0)
+        return undefined;
+    const mine = presets.find((row) => row?.id === DIY_PRESET_ID);
+    if (mine === undefined)
+        return { ok: false, rows: [], detail: `preset 名单里没有 ${DIY_PRESET_ID}` };
+    const broken = typeof mine.broken === 'string' ? mine.broken.trim() : '';
+    if (broken === '')
+        return { ok: true, rows: [], detail: '' };
+    return { ok: false, rows: brokenRowsOf(broken), detail: broken };
+}
+export function createDiyPresetProbe(ctx, options = {}) {
+    const deadlineMs = options.deadlineMs ?? 15_000;
+    const everyMs = options.everyMs ?? 400;
+    return async () => {
+        const registry = ctx.get('agentPresets');
+        if (registry === undefined || typeof registry.list !== 'function')
+            return undefined;
+        const until = Date.now() + deadlineMs;
+        for (;;) {
+            const rows = await registry.list().catch(() => undefined);
+            if (rows === undefined)
+                return undefined;
+            const verdict = diyPresetVerdictOf(rows);
+            if (verdict !== undefined)
+                return verdict;
+            if (Date.now() >= until)
+                return undefined;
+            await new Promise((resolve) => setTimeout(resolve, everyMs));
+        }
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './browser-wake.js';
+export * from './diy-preset-health.js';
+export * from './platform.js';
+export * from './preflight-route.js';
+export * from './preflight.js';
+export * from './probe-cache.js';
+export * from './probe-libs.js';
+export * from './probe-units.js';
+export * from './probe-verdict.js';
+export * from './runtime-seed.js';
+export * from './toolchain.js';
+export * from './version-range.js';
+export * from './install.js';
+export * from './self-update.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+export * from './browser-wake.js';
+export * from './diy-preset-health.js';
+export * from './platform.js';
+export * from './preflight-route.js';
+export * from './preflight.js';
+export * from './probe-cache.js';
+export * from './probe-libs.js';
+export * from './probe-units.js';
+export * from './probe-verdict.js';
+export * from './runtime-seed.js';
+export * from './toolchain.js';
+export * from './version-range.js';
+export * from './install.js';
+export * from './self-update.js';

package/dist/install.d.ts

@@ -0,0 +1,2 @@
+import { type PnpmProcess } from './toolchain.js';
+export declare function opencliInstallCommand(proc?: PnpmProcess, exists?: (path: string) => boolean): string;

package/dist/install.js

@@ -0,0 +1,7 @@
+import { existsSync } from 'node:fs';
+import { isolatedInstallCommand, isolatedPnpmInstallCommand } from '@dsh-workbench/adapter-runtime';
+import { desktopPnpmPath } from './toolchain.js';
+export function opencliInstallCommand(proc = process, exists = existsSync) {
+    const pnpm = desktopPnpmPath(proc, exists);
+    return pnpm === undefined ? isolatedInstallCommand() : isolatedPnpmInstallCommand(pnpm);
+}

package/dist/platform.d.ts

@@ -0,0 +1 @@
+export { hostOsOf, hostSurface, profileNameOf, type HostSurfaceInput } from '@dsh-workbench/shared/host';

package/dist/platform.js

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

package/dist/preflight-route.d.ts

@@ -0,0 +1,12 @@
+import type { DshHostContext, DshShell } from '@dsh-workbench/shared';
+import type { RouteTable } from '@dsh-workbench/shared/host';
+import { type DesktopBrowser } from './browser-wake.js';
+export declare function registerPreflight(input: {
+    routes: RouteTable;
+    ctx: DshHostContext;
+    shell: DshShell;
+    opencliCommand: string;
+    installCommand?: string | undefined;
+    warmReads: () => readonly (readonly string[])[];
+    desktopBrowser?: DesktopBrowser | undefined;
+}): void;

package/dist/preflight-route.js

@@ -0,0 +1,93 @@
+import { basename, join } from 'node:path';
+import { INSTALL_TIMEOUT_MS, preflightHandler, runShell, tailLines, workbenchRoot } from '@dsh-workbench/shared/host';
+import { WAKE_BROWSER_ROUTE } from '@dsh-workbench/shared/contract/protocol/preflight-wake';
+import { createDiyPresetProbe } from './diy-preset-health.js';
+import { hostSurface } from './platform.js';
+import { createPreflight, probeDesktopToolchain } from './preflight.js';
+import { createDesktopBrowser } from './browser-wake.js';
+import { profileDirOf } from '@dsh-workbench/adapter-supply';
+import { prependPath, runtimeSeedRootOf } from './runtime-seed.js';
+import { localNpmCache, provisionLocalNpm, provisionLocalPnpm } from './toolchain.js';
+function desktopBrowserOf(input) {
+    const dir = profileDirOf(input.ctx);
+    const surface = hostSurface({ profile: dir === null ? undefined : basename(dir) });
+    if (!surface.capabilities.browserWake)
+        return undefined;
+    return createDesktopBrowser({
+        shell: input.shell,
+        command: input.command,
+        stateFile: join(workbenchRoot(), 'browser.json'),
+        ...(input.ctx.logger === undefined ? {} : { logger: input.ctx.logger }),
+    });
+}
+export function registerPreflight(input) {
+    const desktopBrowser = input.desktopBrowser ??
+        desktopBrowserOf({
+            ctx: input.ctx,
+            shell: input.shell,
+            command: input.opencliCommand,
+        });
+    const profileDir = profileDirOf(input.ctx);
+    const surface = hostSurface({ profile: profileDir === null ? undefined : basename(profileDir) });
+    const preflight = createPreflight({
+        shell: input.shell,
+        command: input.opencliCommand,
+        ...(input.installCommand === undefined ? {} : { installCommand: input.installCommand }),
+        logger: input.ctx.logger,
+        warmReads: input.warmReads,
+        probeDiy: createDiyPresetProbe(input.ctx),
+        ...(surface.deployment === 'desktop'
+            ? {
+                probeToolchain: () => probeDesktopToolchain(input.shell),
+                provisionNpm: async () => {
+                    const root = runtimeSeedRootOf(input.ctx);
+                    if (root === null)
+                        return { ok: false, detail: '找不到工作台根' };
+                    const result = await provisionLocalNpm({
+                        root,
+                        run: async (command) => {
+                            const ran = await runShell(input.shell, command, { timeoutMs: INSTALL_TIMEOUT_MS });
+                            return {
+                                ok: ran.exitCode === 0 && !ran.timedOut,
+                                detail: tailLines(ran.stderr || ran.stdout, 3),
+                            };
+                        },
+                    });
+                    if (result.ok && result.binDir !== undefined) {
+                        prependPath(result.binDir);
+                        if (process.env.npm_config_cache === undefined) {
+                            process.env.npm_config_cache = localNpmCache(root);
+                        }
+                    }
+                    return result;
+                },
+                provisionPnpm: async () => {
+                    const root = runtimeSeedRootOf(input.ctx);
+                    if (root === null)
+                        return { ok: false, detail: '找不到工作台根' };
+                    const result = await provisionLocalPnpm({
+                        root,
+                        run: async (command) => {
+                            const ran = await runShell(input.shell, command, { timeoutMs: INSTALL_TIMEOUT_MS });
+                            return {
+                                ok: ran.exitCode === 0 && !ran.timedOut,
+                                detail: tailLines(ran.stderr || ran.stdout, 3),
+                            };
+                        },
+                    });
+                    if (result.ok && result.binDir !== undefined)
+                        prependPath(result.binDir);
+                    return result;
+                },
+            }
+            : {}),
+        ...(desktopBrowser === undefined ? {} : { desktopBrowser }),
+    });
+    input.routes.preflight = preflightHandler(preflight);
+    if (desktopBrowser !== undefined) {
+        input.routes[WAKE_BROWSER_ROUTE] = async () => {
+            const result = await desktopBrowser.wake().catch(() => ({ status: 'unknown' }));
+            return { ok: true, ...result };
+        };
+    }
+}

package/dist/preflight.d.ts

@@ -0,0 +1,81 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { DiyPresetVerdict } from './diy-preset-health.js';
+import { type LocalNpmProvision, type LocalPnpmProvision } from './toolchain.js';
+import type { DesktopBrowser } from './browser-wake.js';
+export type PreflightStepId = 'toolchain' | 'opencli' | 'bridge' | 'diy' | 'warm';
+export type PreflightStepStatus = 'pending' | 'running' | 'ok' | 'warn' | 'failed';
+export interface PreflightStep {
+    readonly id: PreflightStepId;
+    readonly status: PreflightStepStatus;
+    readonly detail?: string;
+    readonly action?: string;
+    readonly command?: string;
+}
+export interface ToolchainReport {
+    readonly ok: boolean;
+    readonly detail: string;
+    readonly nodeMissing: boolean;
+    readonly npmMissing: boolean;
+    readonly pnpmProblem: boolean;
+}
+export type PreflightFailure = 'permission' | 'network' | 'missing' | 'unknown';
+export declare function classifyFailure(text: string): PreflightFailure;
+export type PreflightGuidance = 'install' | 'path' | 'shell';
+export declare function probeDesktopToolchain(shell: DshShell): Promise<ToolchainReport>;
+export type PreflightBridgeIssue = 'daemon' | 'extension' | 'profile' | 'stale' | 'unknown';
+export declare function readBridgeReport(stdout: string): {
+    readonly ok: boolean;
+    readonly issues: readonly PreflightBridgeIssue[];
+    readonly detail: string;
+};
+export interface PreflightDiyGap {
+    readonly rows: readonly string[];
+    readonly detail: string;
+    readonly command: string;
+}
+export interface PreflightSnapshot {
+    readonly phase: 'idle' | 'checking' | 'installing' | 'ready' | 'failed';
+    readonly steps: readonly PreflightStep[];
+    readonly at: number;
+    readonly error?: string;
+    readonly failure?: PreflightFailure;
+    readonly guidance?: PreflightGuidance;
+    readonly bridgeIssues?: readonly PreflightBridgeIssue[];
+    readonly diyGap?: PreflightDiyGap;
+    readonly canWakeBrowser?: boolean;
+}
+export interface Preflight {
+    run(options?: {
+        hard?: boolean;
+    }): Promise<PreflightSnapshot>;
+    snapshot(): PreflightSnapshot;
+}
+export declare const OPENCLI_INSTALL_COMMAND: string;
+export interface BridgeVerdict {
+    readonly ok: boolean;
+    readonly detail: string;
+    readonly issues: readonly PreflightBridgeIssue[];
+    readonly command?: string | undefined;
+}
+export declare function canWarm(bridge: {
+    ok: boolean;
+    issues: readonly PreflightBridgeIssue[];
+}): boolean;
+export declare function createPreflight(options: {
+    shell: DshShell;
+    command?: string;
+    installCommand?: string;
+    logger?: {
+        warn?(message: string): void;
+    } | undefined;
+    install?: (() => Promise<{
+        ok: boolean;
+        detail: string;
+    }>) | undefined;
+    warmReads?: (() => readonly (readonly string[])[]) | undefined;
+    probeDiy?: (() => Promise<DiyPresetVerdict | undefined>) | undefined;
+    probeToolchain?: (() => Promise<ToolchainReport>) | undefined;
+    provisionNpm?: (() => Promise<LocalNpmProvision>) | undefined;
+    provisionPnpm?: (() => Promise<LocalPnpmProvision>) | undefined;
+    desktopBrowser?: DesktopBrowser | undefined;
+}): Preflight;