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

package/dist/preflight.js

@@ -0,0 +1,372 @@
+import { INSTALL_TIMEOUT_MS, OPENCLI_TIMEOUT_MS, PREFLIGHT_FRESH_MS, WARM_TIMEOUT_MS } from '@dsh-workbench/shared/host';
+import { tailLines } from '@dsh-workbench/shared/host';
+import { opencliCommandLine } from '@dsh-workbench/adapter-runtime';
+import { runShell } from '@dsh-workbench/shared/host';
+import { DIY_UPGRADE_COMMAND } from './diy-preset-health.js';
+import { opencliInstallCommand } from './install.js';
+import { desktopPnpmPath, LOCAL_NPM_VERSION, LOCAL_PNPM_VERSION, } from './toolchain.js';
+export function classifyFailure(text) {
+    const lower = text.toLowerCase();
+    if (/eacces|eperm|permission denied|operation not permitted/.test(lower))
+        return 'permission';
+    if (/enotfound|etimedout|econnrefused|econnreset|network|proxy|fetch failed/.test(lower))
+        return 'network';
+    if (/command not found|not found|no such file/.test(lower))
+        return 'missing';
+    return 'unknown';
+}
+async function toolVersion(shell, line) {
+    try {
+        const result = await runShell(shell, line, { timeoutMs: 10_000 });
+        const text = (result.stdout || result.stderr).trim().split('\n')[0] ?? '';
+        return { ok: result.exitCode === 0 && !result.timedOut, text };
+    }
+    catch {
+        return { ok: false, text: '' };
+    }
+}
+export async function probeDesktopToolchain(shell) {
+    const [node, npm, pnpm] = await Promise.all([
+        toolVersion(shell, 'node --version'),
+        toolVersion(shell, 'npm --version'),
+        toolVersion(shell, 'pnpm --version'),
+    ]);
+    const nodeMissing = !node.ok;
+    const npmMissing = !npm.ok;
+    const hasBundledPnpm = desktopPnpmPath() !== undefined;
+    const pnpmMajor = /^v?(\d+)/.exec(pnpm.text)?.[1];
+    const pnpmProblem = !pnpm.ok || pnpmMajor !== '10';
+    const parts = [
+        nodeMissing ? 'node 不在 PATH（Desktop 自带 Node 的 shim 没生效）' : `node ${node.text}（Desktop 自带）`,
+        npmMissing
+            ? hasBundledPnpm
+                ? 'npm 缺（opencli 安装走 pnpm；插件安装/模块库仍需 npm）'
+                : 'npm 缺（装不了 opencli：bundled pnpm 也没找到）'
+            : `npm ${npm.text}`,
+        pnpmProblem
+            ? pnpm.ok
+                ? `pnpm ${pnpm.text}（工坊按 10 方言）`
+                : 'pnpm 缺（只影响工坊 build/install）'
+            : `pnpm ${pnpm.text}`,
+    ];
+    return { ok: !nodeMissing, detail: parts.join(' · '), nodeMissing, npmMissing, pnpmProblem };
+}
+export function readBridgeReport(stdout) {
+    const text = String(stdout ?? '');
+    const ok = /^\[OK\] Daemon:/m.test(text) && /^\[OK\] Extension:/m.test(text) && /^\[OK\] Connectivity:/m.test(text);
+    if (ok) {
+        const good = text.split('\n').find((line) => line.trim() === 'Everything looks good!');
+        return { ok: true, issues: [], detail: good?.trim() ?? tailLines(text, 1) };
+    }
+    const found = new Set();
+    if (!/^\[OK\] Daemon:/m.test(text))
+        found.add('daemon');
+    if (!/^\[OK\] Extension:/m.test(text))
+        found.add('extension');
+    if (/Multiple Chrome profiles are connected/i.test(text))
+        found.add('profile');
+    if (/Default browser profile is stale|Selected browser profile is not connected/i.test(text)) {
+        found.add('stale');
+    }
+    if (found.has('profile') || found.has('stale'))
+        found.delete('extension');
+    if (found.size === 0)
+        found.add('unknown');
+    const order = ['profile', 'stale', 'daemon', 'extension', 'unknown'];
+    return { ok: false, issues: order.filter((issue) => found.has(issue)), detail: issuesSection(text) };
+}
+function issuesSection(text) {
+    const lines = text.split('\n');
+    const start = lines.findIndex((line) => /^Issues:/.test(line.trim()));
+    if (start < 0)
+        return tailLines(text, 6);
+    return lines.slice(start).join('\n').trim();
+}
+function bridgeFixCommand(command, issues) {
+    if (issues.includes('profile') || issues.includes('stale'))
+        return `${command} profile list`;
+    if (issues.includes('daemon'))
+        return `${command} daemon restart`;
+    return undefined;
+}
+export const OPENCLI_INSTALL_COMMAND = opencliInstallCommand();
+const WARMABLE_BRIDGE_ISSUES = ['daemon', 'stale'];
+export function canWarm(bridge) {
+    return bridge.ok || bridge.issues.every((issue) => WARMABLE_BRIDGE_ISSUES.includes(issue));
+}
+function step(id) {
+    return { id, status: 'pending' };
+}
+export function createPreflight(options) {
+    const { shell, command = 'opencli', logger } = options;
+    const installCommand = options.installCommand ?? OPENCLI_INSTALL_COMMAND;
+    const warmReads = () => options.warmReads?.() ?? [];
+    const steps = () => [
+        ...(options.probeToolchain === undefined ? [] : [step('toolchain')]),
+        step('opencli'),
+        step('bridge'),
+        ...(options.probeDiy === undefined ? [] : [step('diy')]),
+        ...(warmReads().length === 0 ? [] : [step('warm')]),
+    ];
+    let current = {
+        phase: 'idle',
+        steps: steps(),
+        at: Date.now(),
+        ...(options.desktopBrowser === undefined ? {} : { canWakeBrowser: true }),
+    };
+    let running = null;
+    function set(next) {
+        current = { ...current, ...next, at: Date.now() };
+        return current;
+    }
+    function patchStep(id, patch) {
+        return set({ steps: current.steps.map((item) => (item.id === id ? { ...item, ...patch } : item)) });
+    }
+    async function exec(commandLine, timeoutMs) {
+        try {
+            const result = await runShell(shell, commandLine, { timeoutMs });
+            if (result.timedOut) {
+                return { kind: 'error', detail: `超时（${String(timeoutMs)} ms）：${commandLine}` };
+            }
+            if (result.exitCode !== 0) {
+                return { kind: 'nonzero', detail: tailLines(result.stderr || result.stdout, 4) };
+            }
+            return { kind: 'ok', stdout: result.stdout };
+        }
+        catch (error) {
+            return { kind: 'error', detail: String(error) };
+        }
+    }
+    async function probeVersion() {
+        const result = await exec(`${command} --version`, OPENCLI_TIMEOUT_MS);
+        if (result.kind === 'ok')
+            return { ok: true, missing: false, detail: result.stdout.trim().split('\n')[0] ?? '' };
+        return { ok: false, missing: result.kind === 'nonzero', detail: result.detail };
+    }
+    async function probeBridge() {
+        const result = await exec(`${command} doctor`, OPENCLI_TIMEOUT_MS);
+        if (result.kind !== 'ok')
+            return { ok: false, detail: result.detail, issues: ['unknown'] };
+        const report = readBridgeReport(result.stdout);
+        if (report.ok)
+            return report;
+        return { ...report, command: bridgeFixCommand(command, report.issues) };
+    }
+    async function installOpencli() {
+        if (options.install !== undefined)
+            return options.install();
+        const result = await exec(installCommand, INSTALL_TIMEOUT_MS);
+        if (result.kind !== 'ok')
+            return { ok: false, detail: result.detail };
+        return { ok: true, detail: tailLines(result.stdout, 1) };
+    }
+    async function warmSites(bridge) {
+        const reads = warmReads();
+        if (reads.length === 0)
+            return bridge;
+        if (!canWarm(bridge)) {
+            patchStep('warm', { status: 'warn', detail: '' });
+            return bridge;
+        }
+        patchStep('warm', {
+            status: 'running',
+            action: `${command} <套件自己声明的那条读命令> --site-session persistent -f json`,
+        });
+        const results = await Promise.all(reads.map((read) => exec(opencliCommandLine(command, read), WARM_TIMEOUT_MS)));
+        const failed = reads.filter((_, index) => results[index]?.kind !== 'ok');
+        patchStep('warm', {
+            status: failed.length === 0 ? 'ok' : 'warn',
+            detail: failed.length === 0 ? String(reads.length) : failed.map((read) => read.join(' ')).join(' '),
+            action: undefined,
+        });
+        if (bridge.ok)
+            return bridge;
+        const again = await probeBridge();
+        patchStep('bridge', {
+            status: again.ok ? 'ok' : 'warn',
+            detail: again.detail,
+            action: undefined,
+            command: again.command,
+        });
+        return again;
+    }
+    async function settleDiy(started) {
+        if (started === undefined)
+            return undefined;
+        const verdict = await started.catch(() => undefined);
+        if (verdict === undefined) {
+            set({ steps: current.steps.filter((item) => item.id !== 'diy') });
+            return undefined;
+        }
+        if (verdict.ok) {
+            patchStep('diy', { status: 'ok', detail: verdict.detail });
+            return undefined;
+        }
+        patchStep('diy', { status: 'warn', detail: verdict.detail, command: DIY_UPGRADE_COMMAND });
+        return { rows: verdict.rows, detail: verdict.detail, command: DIY_UPGRADE_COMMAND };
+    }
+    async function doRun() {
+        set({
+            phase: 'checking',
+            error: undefined,
+            failure: undefined,
+            guidance: undefined,
+            bridgeIssues: undefined,
+            diyGap: undefined,
+            steps: steps(),
+        });
+        const toolchainStarted = options.probeToolchain?.();
+        if (toolchainStarted !== undefined) {
+            patchStep('toolchain', { status: 'running', action: 'node --version · npm --version · pnpm --version' });
+        }
+        let toolchain = toolchainStarted === undefined
+            ? undefined
+            : await toolchainStarted.catch(() => ({
+                ok: false,
+                detail: '工具链探测没跑起来',
+                nodeMissing: true,
+                npmMissing: true,
+                pnpmProblem: true,
+            }));
+        if (toolchain !== undefined && toolchain.ok && toolchain.npmMissing && options.provisionNpm !== undefined) {
+            patchStep('toolchain', { status: 'running', action: `装本地 npm@${LOCAL_NPM_VERSION}` });
+            const provisioned = await options.provisionNpm().catch((error) => ({
+                ok: false,
+                detail: String(error),
+            }));
+            if (provisioned.ok) {
+                const reprobed = await options.probeToolchain?.();
+                if (reprobed !== undefined)
+                    toolchain = reprobed;
+            }
+            else {
+                toolchain = { ...toolchain, detail: `${toolchain.detail}；本地 npm 没装成：${provisioned.detail}` };
+            }
+        }
+        if (toolchain !== undefined && toolchain.ok && toolchain.pnpmProblem && options.provisionPnpm !== undefined) {
+            patchStep('toolchain', { status: 'running', action: `装本地 pnpm@${LOCAL_PNPM_VERSION}` });
+            const provisioned = await options.provisionPnpm().catch((error) => ({
+                ok: false,
+                detail: String(error),
+            }));
+            if (provisioned.ok) {
+                const reprobed = await options.probeToolchain?.();
+                if (reprobed !== undefined)
+                    toolchain = reprobed;
+            }
+            else {
+                toolchain = { ...toolchain, detail: `${toolchain.detail}；本地 pnpm 10 没装成：${provisioned.detail}` };
+            }
+        }
+        if (toolchain !== undefined) {
+            patchStep('toolchain', {
+                status: toolchain.ok ? (toolchain.npmMissing || toolchain.pnpmProblem ? 'warn' : 'ok') : 'failed',
+                detail: toolchain.detail,
+                action: undefined,
+            });
+            if (!toolchain.ok) {
+                return set({
+                    phase: 'failed',
+                    error: toolchain.detail,
+                    failure: 'missing',
+                    guidance: 'install',
+                });
+            }
+        }
+        patchStep('opencli', { status: 'running', action: `${command} --version` });
+        const diyStarted = options.probeDiy?.();
+        if (diyStarted !== undefined)
+            patchStep('diy', { status: 'running' });
+        let version = await probeVersion();
+        if (!version.ok && !version.missing) {
+            patchStep('opencli', { status: 'failed', detail: version.detail, action: undefined });
+            return set({
+                phase: 'failed',
+                error: version.detail,
+                failure: classifyFailure(version.detail),
+                guidance: 'shell',
+            });
+        }
+        if (!version.ok) {
+            if (toolchain?.npmMissing === true && installCommand.trim().startsWith('npm ')) {
+                patchStep('opencli', { status: 'failed', detail: '没有 npm：装不了 opencli（只影响 opencli 安装）' });
+                return set({
+                    phase: 'failed',
+                    error: '没有 npm：装不了 opencli（只影响 opencli 安装）',
+                    failure: 'missing',
+                    guidance: 'install',
+                });
+            }
+            set({ phase: 'installing' });
+            patchStep('opencli', { status: 'running', action: installCommand, command: installCommand });
+            const installed = await installOpencli();
+            if (!installed.ok) {
+                patchStep('opencli', {
+                    status: 'failed',
+                    detail: installed.detail,
+                    command: installCommand,
+                });
+                return set({
+                    phase: 'failed',
+                    error: installed.detail,
+                    failure: classifyFailure(installed.detail),
+                    guidance: 'install',
+                });
+            }
+            patchStep('opencli', { status: 'running', action: `${command} --version` });
+            version = await probeVersion();
+            if (!version.ok) {
+                patchStep('opencli', { status: 'failed', detail: version.detail, command: installCommand });
+                return set({
+                    phase: 'failed',
+                    error: version.detail,
+                    failure: classifyFailure(version.detail),
+                    guidance: 'path',
+                });
+            }
+        }
+        patchStep('opencli', { status: 'ok', detail: version.detail, action: undefined });
+        patchStep('bridge', { status: 'running', action: `${command} doctor` });
+        const bridge = await probeBridge();
+        if (options.desktopBrowser !== undefined && bridge.ok) {
+            await options.desktopBrowser.observe().catch(() => undefined);
+        }
+        const healable = !bridge.ok && warmReads().length > 0 && canWarm(bridge);
+        if (!healable) {
+            patchStep('bridge', {
+                status: bridge.ok ? 'ok' : 'warn',
+                detail: bridge.detail,
+                action: undefined,
+                ...(bridge.command === undefined ? {} : { command: bridge.command }),
+            });
+        }
+        const settled = await warmSites(bridge);
+        const diyGap = await settleDiy(diyStarted);
+        logger?.warn?.(`[dsh-workbench] 环境体检：${current.steps.map((item) => `${item.id}=${item.status}`).join(' ')}`);
+        return set({
+            phase: 'ready',
+            ...(settled.ok ? {} : { bridgeIssues: settled.issues }),
+            ...(diyGap === undefined ? {} : { diyGap }),
+        });
+    }
+    function freshReady() {
+        return current.phase === 'ready' && Date.now() - current.at < PREFLIGHT_FRESH_MS;
+    }
+    async function start(runOptions = {}) {
+        if (running !== null)
+            return running;
+        if (runOptions.hard !== true && freshReady())
+            return current;
+        const inflight = doRun();
+        running = inflight;
+        await inflight.catch(() => undefined);
+        running = null;
+        return inflight;
+    }
+    return {
+        run: start,
+        snapshot() {
+            return current;
+        },
+    };
+}

package/dist/probe-cache.d.ts

@@ -0,0 +1,6 @@
+export interface TimedMemo<T> {
+    get(key: string, now?: number): T | undefined;
+    set(key: string, value: T, now?: number): void;
+    clear(): void;
+}
+export declare function createTimedMemo<T>(ttlMs: number): TimedMemo<T>;

package/dist/probe-cache.js

@@ -0,0 +1,19 @@
+export function createTimedMemo(ttlMs) {
+    const entries = new Map();
+    return {
+        get(key, now = Date.now()) {
+            const hit = entries.get(key);
+            if (hit === undefined)
+                return undefined;
+            if (now - hit.at >= ttlMs)
+                return undefined;
+            return hit.value;
+        },
+        set(key, value, now = Date.now()) {
+            entries.set(key, { at: now, value });
+        },
+        clear() {
+            entries.clear();
+        },
+    };
+}

package/dist/probe-libs.d.ts

@@ -0,0 +1,10 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { LibNeed, NeedState, SupplyIndex } from '@dsh-workbench/shared/host';
+export declare function installedLibVersion(name: string): string | undefined;
+export declare function probeLibs(options: {
+    readonly needs: readonly LibNeed[];
+    readonly shell: DshShell;
+    readonly force: boolean;
+    readonly index?: SupplyIndex | undefined;
+}): Promise<ReadonlyMap<string, NeedState>>;
+export declare function resetLibCache(): void;

package/dist/probe-libs.js

@@ -0,0 +1,67 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { libInstallCommand, needIdOf, npmSourceOf } from '@dsh-workbench/shared/host';
+import { libDir } from '@dsh-workbench/adapter-runtime';
+import { npmRegistryOf } from '@dsh-workbench/adapter-supply';
+import { isNewerVersion, latestVersion, resetReleaseCache } from '@dsh-workbench/adapter-profile';
+import { checkVersionRange } from './version-range.js';
+export function installedLibVersion(name) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(libDir(name), 'package.json'), 'utf8'));
+        const version = parsed.version;
+        return typeof version === 'string' && version.trim() !== '' ? version.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function stateOf(need, status, detail, extra = {}) {
+    return {
+        id: needIdOf(need),
+        kind: 'lib',
+        name: need.name,
+        status,
+        detail,
+        ...extra,
+    };
+}
+export async function probeLibs(options) {
+    const { needs, shell, force, index } = options;
+    const found = new Map();
+    for (const need of needs) {
+        if (found.has(need.name))
+            continue;
+        const source = npmSourceOf(index?.sourcesOf('lib', need.name) ?? need.sources);
+        const install = source === undefined
+            ? {}
+            : { command: libInstallCommand({ need, source, ...(need.version === undefined ? {} : { version: need.version }) }) };
+        const installed = installedLibVersion(need.name);
+        if (installed === undefined) {
+            found.set(need.name, stateOf(need, 'missing', `共用依赖 ${need.name} 没装`, install));
+            continue;
+        }
+        if (checkVersionRange(need.version, installed) !== 'satisfied') {
+            found.set(need.name, stateOf(need, 'unsatisfied', `装的是 ${installed}，声明要 ${need.version ?? '任意版本'}`, {
+                installed,
+                ...install,
+            }));
+            continue;
+        }
+        const registry = source === undefined ? undefined : npmRegistryOf(source, process.env);
+        const latest = registry === undefined || !registry.ok
+            ? undefined
+            : await latestVersion({ shell, name: need.name, registry: registry.value, force });
+        const behind = latest !== undefined && isNewerVersion(latest, installed);
+        found.set(need.name, stateOf(need, behind ? 'outdated' : 'ok', behind ? `装的 ${installed}，源上最新 ${latest ?? ''}` : `${installed} 版本对`, {
+            installed,
+            ...(latest === undefined ? {} : { latest }),
+            ...(behind && source !== undefined
+                ? { command: libInstallCommand({ need, source, version: latest }) }
+                : {}),
+        }));
+    }
+    return found;
+}
+export function resetLibCache() {
+    resetReleaseCache();
+}

package/dist/probe-units.d.ts

@@ -0,0 +1,18 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import { type NeedProbeInput, type UnitCapability } from '@dsh-workbench/shared/host';
+export type { NeedProbeInput, NeedState, UnitCapability, } from '@dsh-workbench/shared/host';
+export declare function parsePluginList(stdout: string): unknown[] | undefined;
+export declare function probeUnits(options: {
+    shell: DshShell;
+    runtimeCommands: Readonly<Record<string, string>>;
+    units: readonly NeedProbeInput[];
+    force?: boolean;
+}): Promise<UnitCapability[]>;
+export declare function probeUnitCommands(options: {
+    shell: DshShell;
+    runtimeCommands?: Readonly<Record<string, string>> | undefined;
+    unit: NeedProbeInput;
+    force?: boolean;
+    catalog?: readonly NeedProbeInput[];
+}): Promise<UnitCapability>;
+export declare const resetProbeCache: () => void;