@dsh-workbench/shared 0.1.11 → 0.1.13

package/dist/host/probe-units.js

@@ -0,0 +1,102 @@
+import { OPENCLI_TIMEOUT_MS, PROBE_TTL_MS } from '@dsh-workbench/shared';
+import { createTimedMemo } from "./probe-cache";
+import { parseJsonLoose } from '@dsh-workbench/shared';
+import { npmRegistryOf } from "./plugin-source";
+import { probeRelease } from "./release";
+import { probeLibs } from "./probe-libs";
+import { evaluateUnit } from "./probe-verdict";
+import { runShell } from "./shell";
+export function parsePluginList(stdout) {
+    const parsed = parseJsonLoose(stdout);
+    if (Array.isArray(parsed))
+        return parsed;
+    return /no plugins? installed/i.test(stdout) ? [] : undefined;
+}
+async function probeReleases(units, options) {
+    const needs = new Map();
+    for (const unit of units) {
+        for (const need of unit.plugins ?? []) {
+            const source = need.installSource;
+            if (source?.kind === "npm")
+                needs.set(need.name, source);
+        }
+    }
+    const found = new Map();
+    for (const [plugin, source] of needs) {
+        const registry = npmRegistryOf(source, process.env);
+        const signal = await probeRelease({
+            shell: options.shell,
+            package: source.package,
+            ...(registry.ok ? { registry: registry.value } : {}),
+            force: options.force,
+        });
+        if (signal !== undefined)
+            found.set(plugin, signal);
+    }
+    return found;
+}
+export async function probeUnitCommands(options) {
+    const all = await probeUnits({ ...options, units: [options.unit] });
+    return (all[0] ??
+        evaluateUnit(undefined, options.unit, "unchecked", options.command ?? "opencli"));
+}
+export async function probeUnits(options) {
+    const { shell, command = "opencli", units, force = false } = options;
+    const hits = units.map((unit) => unitCache.get(`${command}:${unit.unit}`));
+    if (!force && hits.every((hit) => hit !== undefined)) {
+        return hits;
+    }
+    const result = await runShell(shell, `${command} plugin list -f json`, {
+        timeoutMs: OPENCLI_TIMEOUT_MS,
+    }).then((value) => ({
+        kind: "ok",
+        stdout: value.exitCode === 0 ? value.stdout : "",
+        stderr: value.stderr,
+    }), (error) => ({
+        kind: "error",
+        stdout: "",
+        stderr: String(error),
+    }));
+    const list = result.kind === "ok" ? parsePluginList(result.stdout) : undefined;
+    const failure = result.kind === "error"
+        ? result.stderr
+        : list === undefined
+            ? "plugin list 的输出读不懂（不是 JSON 数组）"
+            : undefined;
+    if (failure !== undefined) {
+        return units.map((unit) => {
+            const capability = {
+                unit: unit.unit,
+                ...(unit.plugins?.[0] === undefined
+                    ? {}
+                    : { plugin: unit.plugins[0].name }),
+                status: "unchecked",
+                required: (unit.plugins ?? []).flatMap((need) => need.commands ?? []),
+                missing: [],
+                detail: failure,
+            };
+            unitCache.set(`${command}:${unit.unit}`, capability);
+            return capability;
+        });
+    }
+    const [releases, libs] = await Promise.all([
+        probeReleases(units, { shell, force }),
+        probeLibs({
+            needs: units.flatMap((unit) => unit.libs ?? []),
+            shell,
+            force,
+        }),
+    ]);
+    return units.map((unit) => {
+        const capability = evaluateUnit(list, unit, undefined, command, releases, libsOfUnit(unit, libs));
+        unitCache.set(`${command}:${unit.unit}`, capability);
+        return capability;
+    });
+}
+function libsOfUnit(unit, libs) {
+    return (unit.libs ?? [])
+        .map((need) => libs.get(need.name))
+        .filter((state) => state !== undefined);
+}
+const unitCache = createTimedMemo(PROBE_TTL_MS);
+export const resetProbeCache = () => void unitCache.clear();

package/dist/host/probe-verdict.d.ts

@@ -0,0 +1,7 @@
+import type { PluginRelease, UnitPluginNeed } from '@dsh-workbench/shared';
+import type { UnitCapability, UnitCommands, UnitLibState } from "./probe-libs";
+export declare function evaluateUnit(list: readonly unknown[] | undefined, unit: UnitCommands, failure: string | undefined, command?: string, releases?: ReadonlyMap<string, PluginRelease>, libs?: readonly UnitLibState[]): UnitCapability;
+export declare function gapsText(gaps: readonly string[]): string;
+export declare function pluginUpdateCommand(plugin: string | undefined): string | undefined;
+export declare function pluginInstallCommand(plugin: string | undefined): string;
+export declare function upgradeLine(need: UnitPluginNeed, command: string, latest: string): string | undefined;

package/dist/host/probe-verdict.js

@@ -0,0 +1,143 @@
+import { resolvePluginSource } from "./plugin-source";
+import { isNewerVersion } from "./release";
+export function evaluateUnit(list, unit, failure, command = "opencli", releases = new Map(), libs = []) {
+    const isPlugin = (item) => typeof item === "object" && item !== null;
+    const needs = unit.plugins ?? [];
+    const required = needs.flatMap((need) => need.commands ?? []);
+    const primary = needs[0]?.name;
+    if (failure !== undefined || list === undefined) {
+        return {
+            unit: unit.unit,
+            ...(primary === undefined ? {} : { plugin: primary }),
+            status: "unchecked",
+            required,
+            missing: [],
+            detail: failure ?? "探不动",
+            ...(libs.length === 0 ? {} : { libs }),
+        };
+    }
+    const plugins = list.filter(isPlugin);
+    const installed = new Map(plugins.map((item) => [String(item.name), item]));
+    const states = needs.map((need) => {
+        const hit = installed.get(need.name);
+        if (hit === undefined) {
+            const source = resolvePluginSource(need.installSource, process.env, {
+                command,
+                plugin: need.name,
+            });
+            return {
+                name: need.name,
+                status: "missing",
+                missing: [],
+                install: source.ok ? "ready" : source.problem,
+                command: source.ok ? source.line : pluginInstallCommand(need.name),
+            };
+        }
+        const available = new Set((Array.isArray(hit.commands) ? hit.commands : []).map(String));
+        const missing = (need.commands ?? []).filter((name) => !available.has(name));
+        const release = releases.get(need.name);
+        const behind = release?.latest !== undefined &&
+            isNewerVersion(release.latest, release.installed);
+        const commandsBehind = missing.length > 0;
+        const upgrade = behind && release?.latest !== undefined
+            ? upgradeLine(need, command, release.latest)
+            : undefined;
+        return {
+            name: need.name,
+            status: commandsBehind || behind ? "outdated" : "ok",
+            missing,
+            ...(release === undefined ? {} : { release }),
+            ...(commandsBehind || behind
+                ? {
+                    command: upgrade ??
+                        pluginUpdateCommand(need.name) ??
+                        pluginInstallCommand(need.name),
+                }
+                : {}),
+        };
+    });
+    const absent = states.filter((state) => state.status === "missing");
+    const outdated = states.filter((state) => state.status === "outdated");
+    const missing = states.flatMap((state) => state.missing);
+    const libMissing = libs.filter((state) => state.status === "missing");
+    const libMismatch = libs.filter((state) => state.status === "unsatisfied");
+    const libBehind = libs.filter((state) => state.status === "outdated");
+    const status = absent.length > 0 || libMissing.length > 0 || libMismatch.length > 0
+        ? "missing-plugin"
+        : missing.length > 0
+            ? "missing-commands"
+            : "ok";
+    const blocked = absent.find((state) => state.install !== "ready");
+    const install = absent.length === 0
+        ?
+            libMissing.length > 0 || libMismatch.length > 0
+                ? "ready"
+                : undefined
+        : blocked === undefined
+            ? "ready"
+            : blocked.install;
+    const fix = status === "missing-plugin"
+        ? install === "ready"
+            ? "install"
+            : undefined
+        : outdated.length > 0 || libBehind.length > 0
+            ? "update"
+            : undefined;
+    const first = absent[0] ?? outdated[0] ?? libMissing[0] ?? libMismatch[0] ?? libBehind[0];
+    const gaps = [...(missing.length === 0 ? [] : [`缺必需：${missing.join("、")}`])];
+    const newer = states.filter((state) => state.release?.latest !== undefined &&
+        isNewerVersion(state.release.latest, state.release.installed));
+    const versionText = newer.length === 0
+        ? ""
+        : `（源上有新版：${newer.map((state) => `${state.release?.installed ?? ""} → ${state.release?.latest ?? ""}`).join("、")}）`;
+    const absentNames = [
+        ...absent.map((state) => state.name),
+        ...libMissing.map((state) => state.name),
+    ];
+    const mismatchText = libMismatch.map((state) => {
+        const declared = unit.libs?.find((need) => need.name === state.name)?.version?.trim();
+        return `${state.name}（装的是 ${state.installed ?? "未知"}，声明要 ${declared === undefined || declared === "" ? "任意版本" : declared}）`;
+    });
+    return {
+        unit: unit.unit,
+        ...(primary === undefined ? {} : { plugin: primary }),
+        status,
+        required,
+        missing,
+        detail: absentNames.length > 0 || mismatchText.length > 0
+            ? [
+                ...(absentNames.length === 0
+                    ? []
+                    : [`${plugins.length} 个已装插件里没有 ${absentNames.join("、")}`]),
+                ...mismatchText,
+            ].join("；")
+            : `${needs.length} 份安装都在${gapsText(gaps)}${versionText}${libs.length === 0
+                ? ""
+                : `；交叉依赖：${libs.map((state) => `${state.name}${state.installed === undefined ? " 未装" : ` ${state.installed}`}`).join("、")}${libBehind.length === 0 ? "" : "（源上有新版）"}`}`,
+        ...(fix === undefined && first === undefined
+            ? {}
+            : { command: fix === "install" ? (absent[0] ?? first)?.command : first?.command }),
+        ...(fix === undefined ? {} : { fix }),
+        ...(install === undefined ? {} : { install }),
+        plugins: states,
+        ...(libs.length === 0 ? {} : { libs }),
+    };
+}
+export function gapsText(gaps) {
+    return gaps.length === 0 ? "" : `（${gaps.join("；")}）`;
+}
+export function pluginUpdateCommand(plugin) {
+    return plugin === undefined ? undefined : `opencli plugin update ${plugin}`;
+}
+export function pluginInstallCommand(plugin) {
+    return `opencli plugin install <${plugin ?? "插件"}源>`;
+}
+export function upgradeLine(need, command, latest) {
+    const source = resolvePluginSource(need.installSource, process.env, {
+        command,
+        plugin: need.name,
+        version: latest,
+        mode: "update",
+    });
+    return source.ok ? source.line : undefined;
+}

package/dist/host/tool-scope.d.ts

@@ -0,0 +1,32 @@
+import type { DshPromptAssembly } from '@dsh-workbench/shared';
+export interface ScopedToolRegistry {
+    restrict(filter: {
+        readonly allow?: readonly string[];
+        readonly deny?: readonly string[];
+    }): () => void;
+}
+export interface ToolScopeAgent {
+    readonly ctx?: {
+        readonly tools?: ScopedToolRegistry | undefined;
+        get?<T = unknown>(name: string): T | undefined;
+    } | undefined;
+    readonly session?: {
+        readonly header?: {
+            readonly cwd?: string;
+        } | undefined;
+    } | undefined;
+}
+export interface ToolScopeOptions {
+    deniedTools(workspace: string | null): readonly string[];
+    logger?: {
+        info?(message: string): void;
+        warn?(message: string): void;
+    } | undefined;
+}
+export interface ToolScope {
+    apply(agent: unknown): void;
+    narrow(assembly: DshPromptAssembly, agent: unknown): DshPromptAssembly;
+    reapply(): void;
+    disposeAll(): void;
+}
+export declare function createToolScope(options: ToolScopeOptions): ToolScope;

package/dist/host/tool-scope.js

@@ -0,0 +1,84 @@
+function agentOf(value) {
+    return typeof value === 'object' && value !== null ? value : undefined;
+}
+function workspaceOf(handle) {
+    const cwd = handle.session?.header?.cwd;
+    return typeof cwd === 'string' && cwd !== '' ? cwd : null;
+}
+export function createToolScope(options) {
+    const applied = new WeakMap();
+    const seen = new Set();
+    function toolsOf(handle) {
+        const byProperty = handle.ctx?.tools;
+        if (byProperty?.restrict !== undefined)
+            return byProperty;
+        const byGet = handle.ctx?.get?.('tools');
+        return byGet?.restrict === undefined ? undefined : byGet;
+    }
+    function sync(handle) {
+        const tools = toolsOf(handle);
+        if (tools === undefined) {
+            options.logger?.warn?.('[dsh-workbench] 拿不到 agent 作用域的工具面：这次不收窄（下次再试）');
+            return;
+        }
+        const workspace = workspaceOf(handle);
+        const deny = [...options.deniedTools(workspace)];
+        const signature = `${workspace ?? ''}\u0000${deny.join(',')}`;
+        const previous = applied.get(handle);
+        if (previous !== undefined && previous.signature === signature)
+            return;
+        if (previous === undefined)
+            seen.add(new WeakRef(handle));
+        previous?.dispose();
+        if (deny.length === 0) {
+            options.logger?.info?.('[dsh-workbench] 这个工作区启用了全部套件：不收窄工具面');
+            applied.delete(handle);
+            return;
+        }
+        try {
+            applied.set(handle, { signature, dispose: tools.restrict({ deny }) });
+            options.logger?.info?.(`[dsh-workbench] 按工作区收窄工具面：${workspace ?? '(未知工作区)'} 里收起 ${deny.length} 个工具（${deny.join(', ')}）`);
+        }
+        catch (error) {
+            options.logger?.warn?.(`[dsh-workbench] 收窄工具面失败：${String(error)}`);
+        }
+    }
+    return {
+        apply(agent) {
+            const handle = agentOf(agent);
+            if (handle === undefined)
+                return;
+            sync(handle);
+        },
+        narrow(assembly, agent) {
+            const handle = agentOf(agent);
+            const tools = assembly?.tools;
+            if (handle === undefined || tools === undefined)
+                return assembly;
+            const deny = new Set(options.deniedTools(workspaceOf(handle)));
+            if (deny.size === 0)
+                return assembly;
+            const kept = tools.filter((tool) => !deny.has(tool.name));
+            return kept.length === tools.length ? assembly : { ...assembly, tools: kept };
+        },
+        reapply() {
+            for (const ref of [...seen]) {
+                const handle = ref.deref();
+                if (handle === undefined)
+                    seen.delete(ref);
+                else
+                    sync(handle);
+            }
+        },
+        disposeAll() {
+            for (const ref of [...seen]) {
+                const handle = ref.deref();
+                if (handle === undefined)
+                    continue;
+                applied.get(handle)?.dispose();
+                applied.delete(handle);
+            }
+            seen.clear();
+        },
+    };
+}

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

@@ -0,0 +1,7 @@
+import type { UnitManifest } from '@dsh-workbench/shared';
+export interface UnitReadiness {
+    readonly canMount: boolean;
+    readonly missingHard: readonly string[];
+    readonly missingSoft: readonly string[];
+}
+export declare function unitReadiness(manifest: UnitManifest, lookup: (name: string) => unknown): UnitReadiness;

package/dist/host/unit-readiness.js

@@ -0,0 +1,5 @@
+export function unitReadiness(manifest, lookup) {
+    const missingHard = manifest.host.inject.filter((name) => lookup(name) === undefined);
+    const missingSoft = (manifest.host.optional ?? []).filter((name) => lookup(name) === undefined);
+    return { canMount: missingHard.length === 0, missingHard, missingSoft };
+}

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

@@ -0,0 +1,9 @@
+import type { UnitManifest } from '@dsh-workbench/shared';
+import type { UnitHostFace } from './unit-face';
+export interface UnitRegistry {
+    register(face: UnitHostFace): () => void;
+    all(): readonly UnitHostFace[];
+    manifests(): readonly UnitManifest[];
+    subscribe(listener: () => void): () => void;
+}
+export declare function createUnitRegistry(): UnitRegistry;

package/dist/host/unit-registry.js

@@ -0,0 +1,33 @@
+export function createUnitRegistry() {
+    const faces = [];
+    const ids = new Set();
+    const listeners = new Set();
+    function notify() {
+        for (const listener of listeners)
+            listener();
+    }
+    return {
+        register(face) {
+            const id = face.manifest.id;
+            if (ids.has(id))
+                throw new Error(`套件 id 重复：${id}（id 会进持久化配置，不能撞）`);
+            ids.add(id);
+            faces.push(face);
+            notify();
+            return () => {
+                const index = faces.indexOf(face);
+                if (index < 0)
+                    return;
+                faces.splice(index, 1);
+                ids.delete(id);
+                notify();
+            };
+        },
+        all: () => faces,
+        manifests: () => faces.map((face) => face.manifest),
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+}

package/dist/host/version-range.d.ts

@@ -0,0 +1,2 @@
+export type VersionVerdict = 'satisfied' | 'unsatisfied' | 'malformed';
+export declare function checkVersionRange(contract: string | undefined, version: string): VersionVerdict;

package/dist/host/version-range.js

@@ -0,0 +1,73 @@
+import { compareVersions } from './release';
+function readable(version) {
+    return compareVersions(version, '0.0.0') !== undefined;
+}
+function segmentsOf(version) {
+    if (!readable(version))
+        return undefined;
+    return version.split('.').map((part) => Number.parseInt(part, 10));
+}
+function caretUpper(base) {
+    const [major = 0, minor = 0, patch = 0] = base;
+    if (major > 0)
+        return `${major + 1}.0.0`;
+    return minor > 0 ? `0.${minor + 1}.0` : `0.0.${patch + 1}`;
+}
+function tildeUpper(base) {
+    const [major = 0, minor = 0] = base;
+    return `${major}.${minor + 1}.0`;
+}
+function comparator(token, version) {
+    const match = /^(>=|<=|>|<|=|\^|~)?\s*(.+)$/.exec(token.trim());
+    if (match === null)
+        return undefined;
+    const [, operator = '', raw = ''] = match;
+    const base = segmentsOf(raw.trim());
+    if (base === undefined)
+        return undefined;
+    const at = (other) => compareVersions(version, other);
+    switch (operator) {
+        case '^':
+            return (at(raw) ?? -1) >= 0 && (at(caretUpper(base)) ?? 1) < 0;
+        case '~':
+            return (at(raw) ?? -1) >= 0 && (at(tildeUpper(base)) ?? 1) < 0;
+        default:
+            break;
+    }
+    const compared = at(raw.trim());
+    if (compared === undefined)
+        return undefined;
+    switch (operator) {
+        case '>=':
+            return compared >= 0;
+        case '<=':
+            return compared <= 0;
+        case '>':
+            return compared > 0;
+        case '<':
+            return compared < 0;
+        case '=':
+        case '':
+            return compared === 0;
+        default:
+            return undefined;
+    }
+}
+export function checkVersionRange(contract, version) {
+    const spec = contract?.trim() ?? '';
+    if (spec === '')
+        return 'satisfied';
+    if (!readable(version))
+        return 'malformed';
+    const tokens = spec.split(/\s+/).filter((token) => token !== '');
+    if (tokens.length === 0)
+        return 'satisfied';
+    for (const token of tokens) {
+        const verdict = comparator(token, version);
+        if (verdict === undefined)
+            return 'malformed';
+        if (!verdict)
+            return 'unsatisfied';
+    }
+    return 'satisfied';
+}

package/dist/lib/ui.js

@@ -14,7 +14,14 @@ export function relativeTime(epochMs, t) {
         return t('time.hours', { n: Math.floor(diff / (60 * MINUTE)) });
     if (diff < 7 * 24 * 60 * MINUTE)
         return t('time.days', { n: Math.floor(diff / (24 * 60 * MINUTE)) });
-    return new Date(epochMs).toLocaleDateString();
+    return new Date(epochMs).toLocaleString(undefined, {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
 }
 export function shortenPath(path) {
     if (typeof path !== 'string')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dsh-workbench/shared",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "工作台与模块共享的纯代码与契约类型：类型、纯逻辑、哑组件、平台解析。宿主侧的东西从 /host 进（不影响浏览器产物）。",
   "license": "MIT",
   "type": "module",

package/src/components/ChoiceGroup.css

@@ -10,6 +10,7 @@
 }
 
 .wb-choiceOption {
+  position: relative;
   display: flex;
   align-items: center;
   gap: var(--wb-len-6);
@@ -22,6 +23,54 @@
   color: var(--dsw-alias-label-primary);
 }
 
+.wb-choiceOptionOn {
+  background: var(--dsw-alias-interactive-bg-hover);
+}
+
+.wb-checkbox {
+  position: absolute;
+  width: var(--wb-len-16);
+  height: var(--wb-len-16);
+  margin: 0;
+  opacity: 0;
+  pointer-events: none;
+}
+
+.wb-checkboxBox {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  box-sizing: border-box;
+  flex: none;
+  width: var(--wb-len-16);
+  height: var(--wb-len-16);
+  border: 1px solid var(--dsw-alias-border-l3);
+  border-radius: var(--dsw-radius-xs);
+  corner-shape: round;
+  color: var(--dsw-alias-label-primary-foreground);
+  transition:
+    background-color var(--wb-dur-0-12) ease, border-color var(--wb-dur-0-12) ease;
+}
+
+.wb-choiceOption:hover .wb-checkboxBox {
+  border-color: var(--dsw-alias-label-tertiary);
+}
+
+.wb-checkbox:checked + .wb-checkboxBox {
+  border-color: var(--dsw-alias-brand-primary);
+  background: var(--dsw-alias-brand-primary);
+}
+
+.wb-checkbox:disabled + .wb-checkboxBox {
+  opacity: 0.5;
+}
+
+.wb-checkbox:focus-visible + .wb-checkboxBox {
+  outline: var(--dsw-focus-ring-width, var(--wb-len-2)) solid
+    var(--dsw-focus-ring-color, var(--dsw-alias-state-business-primary));
+  outline-offset: 2px;
+}
+
 .wb-choiceOption:hover {
   background: var(--dsw-alias-interactive-bg-hover);
 }