@dsh-workbench/shared 0.3.6 → 0.3.8

package/dist/host/panel-state.d.ts

@@ -0,0 +1,120 @@
+/**
+ * 一张面板卡片取数走到哪一步：`idle` 还没取、`loading` 取着、`ready` 拿到了、`error` 失败了。
+ */
+export type PanelCardPhase = 'idle' | 'loading' | 'ready' | 'error';
+/**
+ * 一次取数失败：机器码 + 给人看的一句话。
+ */
+export interface PanelCardError {
+    readonly code: string;
+    readonly message: string;
+}
+/**
+ * 一张卡片最近一次取数的读数：哪个单元、哪条路由、什么相位、什么时候、失败原因。
+ */
+export interface PanelCardRead {
+    readonly unit: string;
+    readonly route: string;
+    readonly phase: PanelCardPhase;
+    readonly at: number;
+    readonly error?: PanelCardError;
+}
+/**
+ * 一张卡片崩了的读数：单元、原因、时间，以及同一原因连着崩了几次（窗口见 `PANEL_STATE_CRASH_WINDOW_MS`）。
+ */
+export interface PanelCardCrash {
+    readonly unit: string;
+    readonly reason: string;
+    readonly at: number;
+    readonly count: number;
+}
+/**
+ * 一个单元此刻的读数：它的卡片、最近一次读成的时间（`okAt`，没成过给 `null`），以及崩了的那一条。
+ */
+export interface PanelUnitReport {
+    readonly unit: string;
+    readonly at: number;
+    readonly okAt: number | null;
+    readonly cards: readonly PanelCardRead[];
+    readonly crash?: PanelCardCrash;
+}
+/**
+ * 一个工作区此刻的全量读数（面板按工作区存）：所有单元的读数 + 整块最近动过的时间。
+ */
+export interface PanelWorkspaceReport {
+    readonly workspace: string | null;
+    readonly at: number;
+    readonly units: readonly PanelUnitReport[];
+}
+/**
+ * 客户端往上报的一批卡片读数（`POST` 请求体的形状）。
+ */
+export interface PanelCardsReport {
+    readonly workspace: string;
+    readonly cards: readonly PanelCardRead[];
+}
+/**
+ * 客户端往上报的一次卡片崩溃（`POST` 请求体的形状）。
+ */
+export interface PanelCrashReport {
+    readonly workspace: string;
+    readonly unit: string;
+    readonly reason: string;
+    readonly at: number;
+}
+/**
+ * 面板运行态的留存口（宿主持有一份）：收卡片读数与崩溃，按工作区取快照。
+ */
+export interface PanelStateStore {
+    cards(report: PanelCardsReport): void;
+    crash(report: PanelCrashReport): void;
+    snapshot(workspace: string | null): PanelWorkspaceReport;
+}
+/**
+ * 留存的工作区上限（LRU，满 64 个丢最旧的）。
+ */
+export declare const PANEL_STATE_MAX_UNITS = 64;
+/**
+ * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
+ */
+export declare const PANEL_STATE_MAX_CARDS = 12;
+/**
+ * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
+ */
+export declare const PANEL_STATE_MAX_REPORTS = 32;
+/**
+ * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
+ */
+export declare const PANEL_STATE_CRASH_WINDOW_MS = 600000;
+/**
+ * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
+ */
+export declare const PANEL_STATE_MAX_TEXT = 2000;
+/**
+ * 上报解析的结果：`ok: true` 带收好的值，`ok: false` 带一句中文原因（直接回给上报方）。
+ */
+export type PanelParse<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly message: string;
+};
+/**
+ * 收一批卡片读数上报。
+ * @param payload - `POST` 的请求体。
+ * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
+ *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
+ */
+export declare function parseCardsReport(payload: unknown): PanelParse<PanelCardsReport>;
+/**
+ * 收一次卡片崩溃上报。
+ * @param payload - `POST` 的请求体。
+ * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
+ */
+export declare function parseCrashReport(payload: unknown): PanelParse<PanelCrashReport>;
+/**
+ * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
+ * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
+ */
+export declare function createPanelStateStore(): PanelStateStore;

package/dist/host/panel-state.js

@@ -0,0 +1,176 @@
+/**
+ * 留存的工作区上限（LRU，满 64 个丢最旧的）。
+ */
+export const PANEL_STATE_MAX_UNITS = 64;
+/**
+ * 每个单元留存的卡片上限（按路由 LRU，满 12 张丢最旧的）。
+ */
+export const PANEL_STATE_MAX_CARDS = 12;
+/**
+ * 一次上报最多读入的卡片条数（32 条之后的丢掉）。
+ */
+export const PANEL_STATE_MAX_REPORTS = 32;
+/**
+ * 同一原因的连续崩溃算进同一次计数的窗口（10 分钟，毫秒）。
+ */
+export const PANEL_STATE_CRASH_WINDOW_MS = 600000;
+/**
+ * 上报文本字段的截断长度（2000 字符；workspace / reason / message 共用）。
+ */
+export const PANEL_STATE_MAX_TEXT = 2000;
+const PHASES = ['idle', 'loading', 'ready', 'error'];
+function asRecord(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function textOf(value, max) {
+    if (typeof value !== 'string')
+        return '';
+    const trimmed = value.trim();
+    return trimmed.length > max ? trimmed.slice(0, max) : trimmed;
+}
+function atOf(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    if (value < 0)
+        return null;
+    return Math.trunc(value);
+}
+function errorOf(raw) {
+    const record = asRecord(raw);
+    if (record === undefined)
+        return undefined;
+    const code = textOf(record['code'], 120);
+    const message = textOf(record['message'], PANEL_STATE_MAX_TEXT);
+    if (code === '' && message === '')
+        return undefined;
+    return { code: code === '' ? 'unknown' : code, message };
+}
+/**
+ * 收一批卡片读数上报。
+ * @param payload - `POST` 的请求体。
+ * @returns 至少收到一条能认的卡片才 `ok: true`；请求体不是对象、`workspace` 为空、`cards` 不是数组，
+ *   或一条都认不出（`unit` / `route` / `phase` / `at` 缺一）时 `ok: false` + 中文原因；认不出的单条静默跳过。
+ */
+export function parseCardsReport(payload) {
+    const record = asRecord(payload);
+    if (record === undefined)
+        return { ok: false, message: '请求体要是一个对象' };
+    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
+    if (workspace === '')
+        return { ok: false, message: 'workspace 不能是空的 —— 面板按工作区存' };
+    const raw = record['cards'];
+    if (!Array.isArray(raw))
+        return { ok: false, message: 'cards 要是一个数组' };
+    const cards = [];
+    for (const item of raw.slice(0, PANEL_STATE_MAX_REPORTS)) {
+        const card = asRecord(item);
+        if (card === undefined)
+            continue;
+        const unit = textOf(card['unit'], 200);
+        const route = textOf(card['route'], 400);
+        const phase = textOf(card['phase'], 20);
+        const at = atOf(card['at']);
+        if (unit === '' || route === '' || at === null || !PHASES.includes(phase))
+            continue;
+        const error = errorOf(card['error']);
+        cards.push({ unit, route, phase, at, ...(error === undefined ? {} : { error }) });
+    }
+    if (cards.length === 0)
+        return { ok: false, message: 'cards 里没有一条能认的（unit / route / phase / at 都要有）' };
+    return { ok: true, value: { workspace, cards } };
+}
+/**
+ * 收一次卡片崩溃上报。
+ * @param payload - `POST` 的请求体。
+ * @returns `workspace` / `unit` / `reason` 都不能空，缺一给 `ok: false` + 中文原因；`at` 缺省或不合法时取当前时间。
+ */
+export function parseCrashReport(payload) {
+    const record = asRecord(payload);
+    if (record === undefined)
+        return { ok: false, message: '请求体要是一个对象' };
+    const workspace = textOf(record['workspace'], PANEL_STATE_MAX_TEXT);
+    const unit = textOf(record['unit'], 200);
+    const reason = textOf(record['reason'], PANEL_STATE_MAX_TEXT);
+    if (workspace === '')
+        return { ok: false, message: 'workspace 不能是空的' };
+    if (unit === '')
+        return { ok: false, message: 'unit 不能是空的' };
+    if (reason === '')
+        return { ok: false, message: 'reason 不能是空的（没有原因的崩溃没法查）' };
+    return { ok: true, value: { workspace, unit, reason, at: atOf(record['at']) ?? Date.now() } };
+}
+/**
+ * 造一份面板运行态的留存（进程内存、按工作区分桶，带上面那几条上限的 LRU）。
+ * @returns 留存口：`cards` / `crash` 收上报，`snapshot(workspace)` 取全量；没存过的工作区（含 `null`）给一份空的。
+ */
+export function createPanelStateStore() {
+    const workspaces = new Map();
+    function trim(entry, max) {
+        while (entry.size > max) {
+            const oldest = entry.keys().next();
+            if (oldest.done === true)
+                return;
+            entry.delete(oldest.value);
+        }
+    }
+    function workspaceEntryOf(workspace) {
+        const existing = workspaces.get(workspace);
+        if (existing !== undefined)
+            return existing;
+        const created = { at: 0, units: new Map() };
+        workspaces.set(workspace, created);
+        trim(workspaces, PANEL_STATE_MAX_UNITS);
+        return created;
+    }
+    function unitEntryOf(entry, unit) {
+        const existing = entry.units.get(unit);
+        if (existing !== undefined)
+            return existing;
+        const created = { at: 0, cards: new Map() };
+        entry.units.set(unit, created);
+        return created;
+    }
+    return {
+        cards(report) {
+            const entry = workspaceEntryOf(report.workspace);
+            for (const card of report.cards) {
+                const unit = unitEntryOf(entry, card.unit);
+                unit.cards.delete(card.route);
+                unit.cards.set(card.route, card);
+                trim(unit.cards, PANEL_STATE_MAX_CARDS);
+                if (card.at > unit.at)
+                    unit.at = card.at;
+                if (card.at > entry.at)
+                    entry.at = card.at;
+            }
+        },
+        crash(report) {
+            const entry = workspaceEntryOf(report.workspace);
+            const unit = unitEntryOf(entry, report.unit);
+            const previous = unit.crash;
+            const counted = previous !== undefined &&
+                previous.reason === report.reason &&
+                report.at >= previous.at &&
+                report.at - previous.at <= PANEL_STATE_CRASH_WINDOW_MS;
+            unit.crash = { unit: report.unit, reason: report.reason, at: report.at, count: counted ? previous.count + 1 : 1 };
+            if (report.at > unit.at)
+                unit.at = report.at;
+            if (report.at > entry.at)
+                entry.at = report.at;
+        },
+        snapshot(workspace) {
+            if (workspace === null)
+                return { workspace: null, at: 0, units: [] };
+            const entry = workspaces.get(workspace);
+            if (entry === undefined)
+                return { workspace, at: 0, units: [] };
+            const units = [...entry.units.entries()].map(([unit, one]) => {
+                const cards = [...one.cards.values()].sort((a, b) => a.route.localeCompare(b.route));
+                const okAt = cards.reduce((best, card) => (card.phase === 'ready' && (best === null || card.at > best) ? card.at : best), null);
+                return { unit, at: one.at, okAt, cards, ...(one.crash === undefined ? {} : { crash: one.crash }) };
+            });
+            units.sort((a, b) => b.at - a.at || a.unit.localeCompare(b.unit));
+            return { workspace, at: entry.at, units };
+        },
+    };
+}

package/dist/host/plugin-source.js

@@ -1,4 +1,4 @@
-import { quoteShellArg } from '../lib/text.js';
+import { quoteShellArg } from './shell-text.js';
 import { npmCacheDir, toolchainOpencliDir, vendorPeerLink, vendorPrefix } from '../host/opencli-runtime.js';
 function mergeLines(commands) {
     return commands

package/dist/host/preflight.d.ts

@@ -0,0 +1,58 @@
+import type { DshShell } from '@dsh-workbench/shared';
+export type PreflightStepId = 'opencli' | 'bridge' | '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 type PreflightFailure = 'permission' | 'network' | 'missing' | 'unknown';
+export declare function classifyFailure(text: string): PreflightFailure;
+export type PreflightGuidance = 'install' | 'path' | 'shell';
+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 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[];
+}
+export interface Preflight {
+    run(options?: {
+        force?: 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;
+}): Preflight;

package/dist/host/preflight.js

@@ -0,0 +1,233 @@
+import { INSTALL_TIMEOUT_MS, OPENCLI_TIMEOUT_MS, WARM_TIMEOUT_MS } from '@dsh-workbench/shared';
+import { tailLines } from '@dsh-workbench/shared';
+import { opencliCommandLine } from './opencli';
+import { isolatedInstallCommand } from './opencli-runtime';
+import { runShell } from './shell';
+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';
+}
+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') || issues.includes('extension'))
+        return `${command} daemon restart`;
+    return undefined;
+}
+export const OPENCLI_INSTALL_COMMAND = isolatedInstallCommand();
+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 = () => [
+        step('opencli'),
+        step('bridge'),
+        ...(warmReads().length === 0 ? [] : [step('warm')]),
+    ];
+    let current = { phase: 'idle', steps: steps(), at: Date.now() };
+    let running = null;
+    let latest = null;
+    let rerun = false;
+    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 doRun() {
+        set({ phase: 'checking', error: undefined, failure: undefined, steps: steps() });
+        patchStep('opencli', { status: 'running', action: `${command} --version` });
+        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) {
+            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();
+        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);
+        logger?.warn?.(`[dsh-workbench] 环境体检：${current.steps.map((item) => `${item.id}=${item.status}`).join(' ')}`);
+        return set({ phase: 'ready', ...(settled.ok ? {} : { bridgeIssues: settled.issues }) });
+    }
+    async function start(runOptions = {}) {
+        if (running !== null) {
+            if (runOptions.force === true)
+                rerun = true;
+            return running;
+        }
+        if (runOptions.force !== true && latest !== null)
+            return latest;
+        const inflight = doRun();
+        latest = inflight;
+        running = inflight;
+        await inflight.catch(() => undefined);
+        running = null;
+        if (rerun) {
+            rerun = false;
+            return start({ force: true });
+        }
+        return inflight;
+    }
+    return {
+        run: start,
+        snapshot() {
+            return current;
+        },
+    };
+}

package/dist/host/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/host/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/host/probe-libs.d.ts

@@ -0,0 +1,45 @@
+import type { DshShell } from '@dsh-workbench/shared';
+import type { PluginRelease, UnitLibNeed, UnitPluginNeed } from '@dsh-workbench/shared';
+import type { PluginSourceProblem } from './plugin-source';
+export interface UnitLibState {
+    readonly name: string;
+    readonly purpose: string;
+    readonly status: 'ok' | 'outdated' | 'missing' | 'unsatisfied';
+    readonly installed?: string;
+    readonly latest?: string;
+    readonly command?: string;
+}
+export declare function installedLibVersion(name: string): string | undefined;
+export declare function probeLibs(options: {
+    readonly needs: readonly UnitLibNeed[];
+    readonly shell: DshShell;
+    readonly force: boolean;
+}): Promise<ReadonlyMap<string, UnitLibState>>;
+export interface UnitCommands {
+    readonly unit: string;
+    readonly plugins?: readonly UnitPluginNeed[];
+    readonly libs?: readonly UnitLibNeed[];
+}
+export interface UnitPluginState {
+    readonly name: string;
+    readonly status: "ok" | "outdated" | "missing";
+    readonly missing: readonly string[];
+    readonly install?: "ready" | PluginSourceProblem;
+    readonly command?: string;
+    readonly release?: PluginRelease;
+}
+export interface UnitCapability {
+    readonly unit: string;
+    readonly status: "ok" | "missing-commands" | "missing-plugin" | "unchecked";
+    readonly plugin?: string;
+    readonly required: readonly string[];
+    readonly missing: readonly string[];
+    readonly detail: string;
+    readonly command?: string;
+    readonly fix?: "install" | "update";
+    readonly install?: "ready" | PluginSourceProblem;
+    readonly plugins?: readonly UnitPluginState[];
+    readonly libs?: readonly UnitLibState[];
+    readonly released?: boolean;
+}
+export declare function resetLibCache(): void;