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

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.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;
-}

package/dist/lib/diy-debug.d.ts

@@ -1,80 +0,0 @@
-/**
- * 调试约定的两个相位：`debugging` 正占着用户的屏，`paused` 已暂停但仍持着约定。
- */
-export type DebugPhase = 'debugging' | 'paused';
-/**
- * 调试约定收得下的三个人话动作：暂停 / 继续 / 结束。
- */
-export type DebugIntent = 'pause' | 'resume' | 'stop';
-/**
- * 把工具入参收成人话动作。
- * @param value - 任意入参值。
- * @returns `'pause'` / `'resume'` / `'stop'` 原样；别的值（含 `undefined`、多余空白、大小写不同）给 `null`，由调用方拒。
- */
-export declare function parseDebugIntent(value: unknown): DebugIntent | null;
-/**
- * 调试约定的有效期（4 小时，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export declare const DEBUG_STALE_MS: number;
-/**
- * 一份活着的调试约定：相位 + 谁的会话 + 哪个工作区 / 板 / 单元 + 起于何时（`at` 是最后一次动作）。
- */
-export interface DebugState {
-    readonly phase: DebugPhase;
-    readonly sessionId: string;
-    readonly workspacePath: string;
-    readonly title: string;
-    readonly board: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly startedAt: number;
-    readonly at: number;
-}
-/**
- * 建立约定要交的那几件：会话、工作区、板、单元、名字，以及此刻的时间戳。
- */
-export interface DebugPact {
-    readonly sessionId: string;
-    readonly workspacePath: string;
-    readonly title: string;
-    readonly board: string;
-    readonly unit: string;
-    readonly name: string;
-    readonly now: number;
-}
-/**
- * 约定被拒的原因码：自己已持有 / 别人持着 / 不是持有者 / 没有约定 / 已暂停 / 已在调试。
- */
-export type DebugRefusal = 'already-held' | 'held-by-other' | 'not-owner' | 'none' | 'already-paused' | 'already-debugging';
-/**
- * 一次约定动作的结果：成功带新状态，失败带拒绝码。
- */
-export type DebugMove = {
-    readonly ok: true;
-    readonly state: DebugState;
-} | {
-    readonly ok: false;
-    readonly code: DebugRefusal;
-};
-/**
- * 调试约定的存取口（外壳持有一份）：`live` 取当前有效的约定，`begin` / `pause` / `resume` / `stop` 推相位。
- */
-export interface DebugStore {
-    live(now: number): DebugState | null;
-    begin(pact: DebugPact): DebugMove;
-    pause(sessionId: string, now: number): DebugMove;
-    resume(sessionId: string, now: number): DebugMove;
-    stop(sessionId: string, now: number): DebugMove;
-    settle?(): Promise<void>;
-}
-/**
- * 造一份新的调试约定存储（进程内存，同一时刻只可能有一份有效约定）。
- * @returns 存取口；动作成不成都在返回的 `DebugMove` 里，不抛异常。
- */
-export declare function createDebugStore(): DebugStore;
-/**
- * 「谁还占着」的一句话，用于别人来抢时说清现况。
- * @param state - 当前有效的那份约定。
- * @returns 形如「会话 x（自 HH:mm:ssZ 起在调试 y）」的中文串。
- */
-export declare function debugOwnerText(state: DebugState): string;

package/dist/lib/diy-debug.js

@@ -1,88 +0,0 @@
-/**
- * 把工具入参收成人话动作。
- * @param value - 任意入参值。
- * @returns `'pause'` / `'resume'` / `'stop'` 原样；别的值（含 `undefined`、多余空白、大小写不同）给 `null`，由调用方拒。
- */
-export function parseDebugIntent(value) {
-    return value === 'pause' || value === 'resume' || value === 'stop' ? value : null;
-}
-/**
- * 调试约定的有效期（4 小时，毫秒）：超过它没动静的约定算过期、当场让人。
- */
-export const DEBUG_STALE_MS = 4 * 60 * 60 * 1000;
-function alive(state, now) {
-    if (state === null)
-        return null;
-    return now - state.at <= DEBUG_STALE_MS ? state : null;
-}
-function ownerOf(state, sessionId, now) {
-    const held = alive(state, now);
-    if (held === null)
-        return 'none';
-    return held.sessionId === sessionId ? held : 'not-owner';
-}
-/**
- * 造一份新的调试约定存储（进程内存，同一时刻只可能有一份有效约定）。
- * @returns 存取口；动作成不成都在返回的 `DebugMove` 里，不抛异常。
- */
-export function createDebugStore() {
-    let held = null;
-    const live = (now) => alive(held, now);
-    return {
-        live,
-        begin(pact) {
-            const current = alive(held, pact.now);
-            if (current !== null) {
-                return { ok: false, code: current.sessionId === pact.sessionId ? 'already-held' : 'held-by-other' };
-            }
-            const state = {
-                phase: 'debugging',
-                sessionId: pact.sessionId,
-                workspacePath: pact.workspacePath,
-                title: pact.title,
-                board: pact.board,
-                unit: pact.unit,
-                name: pact.name,
-                startedAt: pact.now,
-                at: pact.now,
-            };
-            held = state;
-            return { ok: true, state };
-        },
-        pause(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase === 'paused')
-                return { ok: false, code: 'already-paused' };
-            const state = { ...found, phase: 'paused', at: now };
-            held = state;
-            return { ok: true, state };
-        },
-        resume(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            if (found.phase === 'debugging')
-                return { ok: false, code: 'already-debugging' };
-            const state = { ...found, phase: 'debugging', at: now };
-            held = state;
-            return { ok: true, state };
-        },
-        stop(sessionId, now) {
-            const found = ownerOf(held, sessionId, now);
-            if (typeof found === 'string')
-                return { ok: false, code: found };
-            held = null;
-            return { ok: true, state: found };
-        },
-    };
-}
-/**
- * 「谁还占着」的一句话，用于别人来抢时说清现况。
- * @param state - 当前有效的那份约定。
- * @returns 形如「会话 x（自 HH:mm:ssZ 起在调试 y）」的中文串。
- */
-export function debugOwnerText(state) {
-    return `会话 ${state.sessionId}（自 ${new Date(state.startedAt).toISOString().slice(11, 19)}Z 起在调试 ${state.unit}）`;
-}