@dsh-workbench/shared 0.3.10 → 1.0.0-beta.0

package/dist/host/opencli-runtime.d.ts

@@ -1,25 +0,0 @@
-import type { UnitLibNeed } from '../api/unit.js';
-import { dshHome } from './data-root.js';
-export { dshHome };
-export declare function isolatedRoot(): string;
-export declare function isolatedHome(): string;
-export declare const OPENCLI_NPM_PACKAGE = "@jackwener/opencli";
-export declare function toolchainDir(): string;
-export declare function toolchainOpencliDir(): string;
-export declare function vendorPrefix(): string;
-export declare function vendorPluginsDir(): string;
-export declare const OPENCLI_CATALOG_ENV = "DSH_WB_OPENCLI_CATALOG";
-export declare function cliCatalogPath(): string;
-export declare function vendorPeerLink(): {
-    readonly dir: string;
-    readonly parent: string;
-};
-export declare function npmCacheDir(): string;
-export declare function isolatedCommand(): string;
-export declare function libsPrefix(): string;
-export declare function libDir(name: string): string;
-export declare function libInstallCommand(options: {
-    readonly need: UnitLibNeed;
-    readonly version?: string | undefined;
-}): string;
-export declare function isolatedInstallCommand(): string;

package/dist/host/opencli-runtime.js

@@ -1,56 +0,0 @@
-import { OPENCLI_PIN } from '../config/constants.js';
-import { quoteShellArg } from './shell-text.js';
-import { dshHome } from './data-root.js';
-export { dshHome };
-export function isolatedRoot() {
-    return `${dshHome()}/workbench/opencli`;
-}
-export function isolatedHome() {
-    return `${isolatedRoot()}/home`;
-}
-export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
-export function toolchainDir() {
-    return `${isolatedRoot()}/toolchain`;
-}
-export function toolchainOpencliDir() {
-    return `${toolchainDir()}/node_modules/${OPENCLI_NPM_PACKAGE}`;
-}
-export function vendorPrefix() {
-    return `${isolatedRoot()}/plugins-npm`;
-}
-export function vendorPluginsDir() {
-    return `${vendorPrefix()}/node_modules`;
-}
-export const OPENCLI_CATALOG_ENV = 'DSH_WB_OPENCLI_CATALOG';
-export function cliCatalogPath() {
-    const override = process.env[OPENCLI_CATALOG_ENV]?.trim();
-    return override === undefined || override === ''
-        ? `${toolchainOpencliDir()}/cli-manifest.json`
-        : override;
-}
-export function vendorPeerLink() {
-    const base = `${vendorPrefix()}/node_modules`;
-    const [scope] = OPENCLI_NPM_PACKAGE.split('/');
-    return { dir: `${base}/${OPENCLI_NPM_PACKAGE}`, parent: `${base}/${scope}` };
-}
-export function npmCacheDir() {
-    return `${isolatedRoot()}/npm-cache`;
-}
-export function isolatedCommand() {
-    return `${isolatedRoot()}/bin/opencli`;
-}
-export function libsPrefix() {
-    return `${isolatedRoot()}/libs`;
-}
-export function libDir(name) {
-    return `${libsPrefix()}/node_modules/${name}`;
-}
-export function libInstallCommand(options) {
-    const { need, version } = options;
-    const registry = process.env[need.registryEnv]?.trim() || need.registryDefault;
-    const spec = version ?? need.version ?? 'latest';
-    return `npm i --prefix '${libsPrefix()}' ${quoteShellArg(`${need.name}@${spec}`)} --registry '${registry}' --cache '${npmCacheDir()}'`;
-}
-export function isolatedInstallCommand() {
-    return `npm i --prefix '${toolchainDir()}' ${OPENCLI_NPM_PACKAGE}@${OPENCLI_PIN} --cache '${npmCacheDir()}'`;
-}

package/dist/host/opencli-window.d.ts

@@ -1,2 +0,0 @@
-export declare function backgroundPrefix(): readonly string[];
-export declare function backgroundLine(command: string, argv: readonly string[]): string;

package/dist/host/opencli-window.js

@@ -1,8 +0,0 @@
-import { quoteShellArg } from './shell-text.js';
-const OPENCLI_WINDOW_ENV = 'OPENCLI_WINDOW=background';
-export function backgroundPrefix() {
-    return [quoteShellArg('env'), quoteShellArg(OPENCLI_WINDOW_ENV)];
-}
-export function backgroundLine(command, argv) {
-    return [...backgroundPrefix(), quoteShellArg(command), ...argv.map(quoteShellArg)].join(' ');
-}

package/dist/host/opencli.d.ts

@@ -1,37 +0,0 @@
-import type { DshShell } from '../api/dsh.js';
-export declare class WorkbenchDataError extends Error {
-    readonly code: string;
-    readonly detail?: string;
-    readonly hint?: string;
-    readonly project?: unknown;
-    readonly helpUrl?: string;
-    constructor(code: string, message: string, extra?: {
-        detail?: string;
-        hint?: string;
-        project?: unknown;
-        helpUrl?: string;
-    });
-}
-export interface OpencliResult {
-    readonly value: unknown;
-    readonly at: number;
-}
-export type OpencliSession = 'persistent' | 'ephemeral' | 'none';
-export declare function opencliCommandLine(command: string, argv: readonly string[], session?: OpencliSession): string;
-export interface Opencli {
-    json(args: readonly string[], options?: {
-        key?: string;
-        workdir?: string;
-        session?: OpencliSession;
-    }): Promise<OpencliResult>;
-}
-export declare function createOpencli(options: {
-    shell: DshShell;
-    plugin: string;
-    logger?: {
-        warn?(message: string): void;
-    } | undefined;
-    command?: string;
-    timeoutMs?: number;
-    maxConcurrent?: number;
-}): Opencli;

package/dist/host/opencli.js

@@ -1,155 +0,0 @@
-import { OPENCLI_MAX_CONCURRENT, OPENCLI_TIMEOUT_MS } from '../config/constants.js';
-import { parseJsonLoose } from '../lib/text.js';
-import { quoteShellArg, tailLines } from './shell-text.js';
-import { helpUrlOf, parseCliErrorEnvelope } from './cli-error.js';
-import { backgroundPrefix } from './opencli-window.js';
-import { runShell } from './shell.js';
-const FORBIDDEN_CODES = new Set(['FORBIDDEN', 'PERMISSION_DENIED']);
-const SITE_SESSION_ARGS = ['--site-session', 'persistent'];
-export class WorkbenchDataError extends Error {
-    code;
-    detail;
-    hint;
-    project;
-    helpUrl;
-    constructor(code, message, extra = {}) {
-        super(message);
-        this.name = 'WorkbenchDataError';
-        this.code = code;
-        if (extra.detail !== undefined)
-            this.detail = extra.detail;
-        if (extra.hint !== undefined)
-            this.hint = extra.hint;
-        if (extra.project !== undefined)
-            this.project = extra.project;
-        if (extra.helpUrl !== undefined)
-            this.helpUrl = extra.helpUrl;
-    }
-}
-export function opencliCommandLine(command, argv, session = 'persistent') {
-    return [
-        ...backgroundPrefix(),
-        quoteShellArg(command),
-        ...argv.map(quoteShellArg),
-        ...(session === 'persistent' ? SITE_SESSION_ARGS : []),
-        '-f',
-        'json',
-    ].join(' ');
-}
-export function createOpencli(options) {
-    const { shell, plugin, logger, command = 'opencli', timeoutMs = OPENCLI_TIMEOUT_MS, maxConcurrent = OPENCLI_MAX_CONCURRENT, } = options;
-    const inflight = new Map();
-    const MAX_CONCURRENT = maxConcurrent;
-    let running = 0;
-    const waiting = [];
-    async function acquire() {
-        if (running < MAX_CONCURRENT) {
-            running += 1;
-            return;
-        }
-        await new Promise((resolve) => waiting.push(resolve));
-    }
-    function release() {
-        const next = waiting.shift();
-        if (next === undefined)
-            running -= 1;
-        else
-            next();
-    }
-    async function runLimited(task) {
-        await acquire();
-        try {
-            return await task();
-        }
-        finally {
-            release();
-        }
-    }
-    async function call(commandLine, workdir) {
-        let result;
-        try {
-            result = await runShell(shell, commandLine, {
-                ...(workdir === undefined ? {} : { workdir }),
-                timeoutMs,
-            });
-        }
-        catch (error) {
-            throw new WorkbenchDataError('cli-exec-failed', `执行 opencli 失败：${String(error)}`, {
-                hint: '确认 opencli 已安装且在 PATH 里（which opencli）。',
-            });
-        }
-        if (result.timedOut) {
-            throw new WorkbenchDataError('cli-timeout', `opencli 超过 ${Math.round(timeoutMs / 1000)} 秒没有返回`, { hint: '无头浏览器可能没起来，重试一次通常就好。' });
-        }
-        if (result.exitCode !== 0) {
-            const detail = tailLines(result.stderr || result.stdout, 6);
-            const envelope = parseCliErrorEnvelope(result.stderr) ?? parseCliErrorEnvelope(result.stdout);
-            const url = envelope === undefined ? undefined : helpUrlOf(envelope);
-            if (envelope?.code === 'AUTH_REQUIRED') {
-                throw new WorkbenchDataError('auth-required', envelope.message, {
-                    detail,
-                    ...(url === undefined ? {} : { helpUrl: url }),
-                });
-            }
-            if (envelope !== undefined && FORBIDDEN_CODES.has(envelope.code)) {
-                throw new WorkbenchDataError('permission-denied', envelope.message, {
-                    detail,
-                    ...(url === undefined ? {} : { helpUrl: url }),
-                });
-            }
-            if (envelope !== undefined) {
-                throw new WorkbenchDataError('cli-command-failed', `${envelope.code}：${envelope.message}`, {
-                    detail,
-                    ...(envelope.help === undefined ? {} : { hint: envelope.help }),
-                });
-            }
-            throw new WorkbenchDataError('cli-unclassified', `opencli 这条命令没跑通（退出码 ${result.exitCode}），而且没有结构化错误码`, {
-                detail,
-                hint: '多半是插件里没有这条命令（版本旧就会缺），也可能是命令自己失败了：先确认命令存在，再更新插件重试。',
-            });
-        }
-        const parsed = parseJsonLoose(result.stdout);
-        if (parsed === undefined) {
-            throw new WorkbenchDataError('cli-bad-output', 'opencli 输出不是 JSON', {
-                detail: tailLines(result.stdout, 4),
-            });
-        }
-        return parsed;
-    }
-    async function json(args, callOptions = {}) {
-        const { key, workdir } = callOptions;
-        const session = callOptions.session ?? 'persistent';
-        const callKey = key ?? args.map((arg) => String(arg)).join(' ');
-        const pending = inflight.get(callKey);
-        if (pending !== undefined)
-            return pending;
-        const commandLine = opencliCommandLine(command, [plugin, ...args], session);
-        const once = async () => {
-            const value = await call(commandLine, workdir);
-            return { value, at: Date.now() };
-        };
-        const task = runLimited(async () => {
-            try {
-                return await once();
-            }
-            catch (error) {
-                if (!(error instanceof WorkbenchDataError) || error.code !== 'auth-required')
-                    throw error;
-                return await once();
-            }
-        });
-        inflight.set(callKey, task);
-        try {
-            return await task;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            logger?.warn?.(`[dsh-workbench] opencli 调用失败：${message}`);
-            throw error;
-        }
-        finally {
-            inflight.delete(callKey);
-        }
-    }
-    return { json };
-}

package/dist/host/unit-declaration.d.ts

@@ -1,65 +0,0 @@
-import type { UnitEnvNeeds, UnitHostNeeds, UnitManifest } from '../api/unit.js';
-/**
- * 声明协议当前版本；模块清单的 dsh.workbench.apiVersion 要写这个整数。
- */
-export declare const WORKBENCH_API_VERSION = 1;
-/**
- * 外壳愿意认的协议版本；不在表里的模块当场被拒，不猜语义。
- */
-export declare const SUPPORTED_API_VERSIONS: readonly number[];
-/**
- * 清单里那半张卡片声明：文案键加排序位；卡片默认显不显示不在这里（那是运行期面板配置的事）。
- */
-export interface UnitCardDeclaration {
-    readonly titleKey: string;
-    readonly order: number;
-}
-/**
- * 清单里的一条工具声明：进 dsh 工具表的全名、会不会写，以及生成物里的键名。
- */
-export interface UnitToolDeclaration {
-    readonly name: string;
-    readonly writes: boolean;
-    readonly key?: string;
-}
-/**
- * 模块清单里 dsh.workbench 那一段的完整形状（协议版本、单元 id、卡片、工具、宿主与环境需要）。
- */
-export interface UnitDeclaration {
-    readonly apiVersion: number;
-    readonly unit: string;
-    readonly card: UnitCardDeclaration | null;
-    readonly tools: readonly UnitToolDeclaration[];
-    readonly host: UnitHostNeeds;
-    readonly env?: UnitEnvNeeds;
-}
-/**
- * 协议认得的全部键；写了别的键不会被采纳（外壳静默忽略），所以字段名拼错不会有提示。
- */
-export declare const DECLARATION_KEYS: readonly string[];
-/**
- * 协议要求必写的键；env 不在其中（没有环境需要就不写）。
- */
-export declare const DECLARATION_REQUIRED_KEYS: readonly string[];
-/**
- * 查清单里 dsh.workbench 那一段的形状，回一串给人看的问题（中文，带字段路径）。
- * @param subject 报错时用的主语，一般是包名。
- * @param raw 清单里那段原始值，可能什么都不是。
- * @returns 空数组表示形状过得去；版本不对就当场返回（后面的字段无从判起）。
- */
-export declare function declarationProblemsOf(subject: string, raw: unknown): readonly string[];
-/**
- * 读一份清单的结果：要么带着规整过的声明与 manifest，要么只带一串问题。
- */
-export interface DeclarationRead {
-    readonly declaration?: UnitDeclaration;
-    readonly manifest?: UnitManifest;
-    readonly problems: readonly string[];
-}
-/**
- * 读一份清单：先查形状，过了再把声明规整成 manifest。
- * @param subject 报错时用的主语。
- * @param raw 清单里 dsh.workbench 那段原始值。
- * @returns 有问题时只有 problems；没问题时 declaration 与 manifest 都给，manifest 里的字符串已 trim。
- */
-export declare function readDeclaration(subject: string, raw: unknown): DeclarationRead;

package/dist/host/unit-declaration.js

@@ -1,213 +0,0 @@
-/**
- * 声明协议当前版本；模块清单的 dsh.workbench.apiVersion 要写这个整数。
- */
-export const WORKBENCH_API_VERSION = 1;
-/**
- * 外壳愿意认的协议版本；不在表里的模块当场被拒，不猜语义。
- */
-export const SUPPORTED_API_VERSIONS = [WORKBENCH_API_VERSION];
-/**
- * 协议认得的全部键；写了别的键不会被采纳（外壳静默忽略），所以字段名拼错不会有提示。
- */
-export const DECLARATION_KEYS = [
-    'apiVersion',
-    'unit',
-    'card',
-    'tools',
-    'host',
-    'env',
-];
-/**
- * 协议要求必写的键；env 不在其中（没有环境需要就不写）。
- */
-export const DECLARATION_REQUIRED_KEYS = [
-    'apiVersion',
-    'unit',
-    'card',
-    'tools',
-    'host',
-];
-const CARD_KEYS = ['titleKey', 'order'];
-const TOOL_KEYS = ['name', 'writes', 'key'];
-const TOOL_KEY_SHAPE = /^[a-z][a-zA-Z0-9]*$/;
-const HOST_KEYS = ['inject', 'optional'];
-function text(value) {
-    return typeof value === 'string' ? value.trim() : '';
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function outsideKeys(value, allowed) {
-    return Object.keys(value).filter((key) => !allowed.includes(key));
-}
-function listOf(keys) {
-    return keys.map((key) => JSON.stringify(key)).join(' / ');
-}
-function stringArrayProblems(at, value) {
-    if (!Array.isArray(value))
-        return [`${at} 要是一串字符串，现在是 ${JSON.stringify(value)}`];
-    return value.flatMap((item, index) => text(item) === '' ? [`${at}[${index}] 不是非空字符串：${JSON.stringify(item)}`] : []);
-}
-/**
- * 查清单里 dsh.workbench 那一段的形状，回一串给人看的问题（中文，带字段路径）。
- * @param subject 报错时用的主语，一般是包名。
- * @param raw 清单里那段原始值，可能什么都不是。
- * @returns 空数组表示形状过得去；版本不对就当场返回（后面的字段无从判起）。
- */
-export function declarationProblemsOf(subject, raw) {
-    if (!isRecord(raw))
-        return [`${subject}: dsh.workbench 不是一个对象 —— ${JSON.stringify(raw)}`];
-    const version = raw.apiVersion;
-    if (version === undefined) {
-        return [
-            `${subject}: dsh.workbench 没有 apiVersion —— 协议从 v${WORKBENCH_API_VERSION} 起，` +
-                `写 \`"apiVersion": ${WORKBENCH_API_VERSION}\`。缺它 = 外壳不认这个模块（ADR-0038 §2.3）`,
-        ];
-    }
-    if (!Number.isInteger(version) || !SUPPORTED_API_VERSIONS.includes(version)) {
-        return [
-            `${subject}: dsh.workbench.apiVersion 是 ${JSON.stringify(version)}，这里只认 ` +
-                `${SUPPORTED_API_VERSIONS.join(' / ')}（要整数）`,
-        ];
-    }
-    const problems = [];
-    const unknown = outsideKeys(raw, DECLARATION_KEYS);
-    if (unknown.length > 0) {
-        problems.push(`${subject}: dsh.workbench 里有协议 v${WORKBENCH_API_VERSION} 不认识的键 ${listOf(unknown)} —— ` +
-            `只有 ${listOf(DECLARATION_KEYS)}。（拼错的键会被外壳**静默忽略**：那句声明等于没写）`);
-    }
-    for (const key of DECLARATION_REQUIRED_KEYS) {
-        if (raw[key] === undefined) {
-            problems.push(`${subject}: dsh.workbench 缺 ${key}` +
-                (key === 'card' ? '（这个模块没有卡片就写 `"card": null`）' : ''));
-        }
-    }
-    const card = raw.card;
-    if (card !== undefined && card !== null) {
-        if (!isRecord(card)) {
-            problems.push(`${subject}: dsh.workbench.card 要么是对象、要么是 null，现在是 ${JSON.stringify(card)}`);
-        }
-        else {
-            const extra = outsideKeys(card, CARD_KEYS);
-            if (extra.length > 0) {
-                problems.push(`${subject}: dsh.workbench.card 里有不认的键 ${listOf(extra)} —— card 只有 ${listOf(CARD_KEYS)}` +
-                    `（卡片默认显不显示由运行期的面板配置决定，清单里没有这一位）`);
-            }
-            if (text(card.titleKey) === '') {
-                problems.push(`${subject}: dsh.workbench.card.titleKey 要是非空字符串（面板那一格的文案键）`);
-            }
-            if (typeof card.order !== 'number' || !Number.isFinite(card.order)) {
-                problems.push(`${subject}: dsh.workbench.card.order 要是数字，现在是 ${JSON.stringify(card.order)}`);
-            }
-        }
-    }
-    const tools = raw.tools;
-    if (tools !== undefined) {
-        if (!Array.isArray(tools)) {
-            problems.push(`${subject}: dsh.workbench.tools 要是一串声明，现在是 ${JSON.stringify(tools)}`);
-        }
-        else {
-            const seen = new Set();
-            const seenKeys = new Set();
-            tools.forEach((tool, index) => {
-                const at = `dsh.workbench.tools[${index}]`;
-                if (!isRecord(tool)) {
-                    problems.push(`${subject}: ${at} 要是对象，现在是 ${JSON.stringify(tool)}`);
-                    return;
-                }
-                const extra = outsideKeys(tool, TOOL_KEYS);
-                if (extra.length > 0) {
-                    problems.push(`${subject}: ${at} 里有不认的键 ${listOf(extra)} —— tools 只有 ${listOf(TOOL_KEYS)}`);
-                }
-                const name = text(tool.name);
-                if (name === '') {
-                    problems.push(`${subject}: ${at}.name 要是非空字符串`);
-                }
-                else if (seen.has(name)) {
-                    problems.push(`${subject}: ${at}.name「${name}」与前面那条撞了 —— 工具名会进 dsh 的工具表，不许重`);
-                }
-                else {
-                    seen.add(name);
-                }
-                if (typeof tool.writes !== 'boolean') {
-                    problems.push(`${subject}: ${at}.writes 要是 true / false（它是"这会写"的唯一声明，缺了审批无从认领）`);
-                }
-                if (tool.key !== undefined) {
-                    const key = text(tool.key);
-                    if (!TOOL_KEY_SHAPE.test(key)) {
-                        problems.push(`${subject}: ${at}.key 要是 lowerCamelCase 的标识符（如 \`sync\` / \`podLogs\`），` +
-                            `现在是 ${JSON.stringify(tool.key)} —— 它会变成生成物里的键名，所以不引号、不许带点或横线`);
-                    }
-                    else if (seenKeys.has(key)) {
-                        problems.push(`${subject}: ${at}.key「${key}」与前面那条撞了 —— 生成物里的键只能有一个`);
-                    }
-                    else {
-                        seenKeys.add(key);
-                    }
-                }
-            });
-        }
-    }
-    const host = raw.host;
-    if (host !== undefined) {
-        if (!isRecord(host)) {
-            problems.push(`${subject}: dsh.workbench.host 要是对象，现在是 ${JSON.stringify(host)}`);
-        }
-        else {
-            const extra = outsideKeys(host, HOST_KEYS);
-            if (extra.length > 0) {
-                problems.push(`${subject}: dsh.workbench.host 里有不认的键 ${listOf(extra)} —— host 只有 ${listOf(HOST_KEYS)}`);
-            }
-            if (host.inject === undefined) {
-                problems.push(`${subject}: dsh.workbench.host.inject 没写 —— 它声明这个模块要外壳的哪几个服务，` +
-                    `外壳靠它判"能不能挂"。一个都不要也要写 \`"inject": []\``);
-            }
-            else {
-                problems.push(...stringArrayProblems(`${subject}: dsh.workbench.host.inject`, host.inject));
-            }
-            if (host.optional !== undefined) {
-                problems.push(...stringArrayProblems(`${subject}: dsh.workbench.host.optional`, host.optional));
-            }
-        }
-    }
-    if (raw.env !== undefined && !isRecord(raw.env)) {
-        problems.push(`${subject}: dsh.workbench.env 要是对象（command / plugins / libs）—— ` +
-            `语义由门禁的 env 判据查，这里只查形状`);
-    }
-    return problems;
-}
-/**
- * 读一份清单：先查形状，过了再把声明规整成 manifest。
- * @param subject 报错时用的主语。
- * @param raw 清单里 dsh.workbench 那段原始值。
- * @returns 有问题时只有 problems；没问题时 declaration 与 manifest 都给，manifest 里的字符串已 trim。
- */
-export function readDeclaration(subject, raw) {
-    const problems = declarationProblemsOf(subject, raw);
-    if (problems.length > 0)
-        return { problems };
-    const declaration = raw;
-    const card = declaration.card;
-    return {
-        declaration,
-        problems: [],
-        manifest: {
-            id: text(declaration.unit),
-            card: card === null
-                ? null
-                : {
-                    titleKey: text(card.titleKey),
-                    order: card.order,
-                },
-            tools: declaration.tools.map((tool) => ({
-                name: text(tool.name),
-                writes: tool.writes,
-            })),
-            host: {
-                inject: [...(declaration.host.inject ?? [])],
-                ...(declaration.host.optional === undefined ? {} : { optional: [...declaration.host.optional] }),
-            },
-            ...(declaration.env === undefined ? {} : { env: declaration.env }),
-        },
-    };
-}

package/dist/host/unit-libs.d.ts

@@ -1,37 +0,0 @@
-import type { PluginSourceProblem } from './plugin-source.js';
-import type { PluginRelease, UnitLibNeed, UnitPluginNeed } from '../api/unit.js';
-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 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" | "failed" | "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;
-}