dsh-plugin-tool-management 0.17.0 → 0.18.5

package/lib/sessions/workspace.js

@@ -4,6 +4,8 @@ import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { hubPath } from "../hub.js";
 import { sessionDir } from "@deepseek-ai/dsh-spill-local";
 import { trackTombstone } from "./tombstone.js";
+import { archivedBatchTargetSchema, archivedSetSchema, workspaceIdSchema, } from "./archive-schemas.js";
+import { workspaceBaseName, workspacePathKey } from "./path-key.js";
 import { noteRuntime } from "../compat/runtime-notes.js";
 /**
  * A3-1：宿主补上了原生删除入口时上报一次（**不切换**，理由见 deleteSessionCore）。
@@ -113,127 +115,6 @@ function headerIdentity(header) {
         cwd: header.cwd ?? null,
     };
 }
-const sessionIdSchema = {
-    parse(value) {
-        if (typeof value !== "string" || value.length === 0)
-            throw new TypeError(`sessionId must be a non-empty string, got ${String(value)}`);
-        return value;
-    },
-};
-const workspaceIdSchema = {
-    parse(value) {
-        if (typeof value !== "string" || value.length === 0)
-            throw new TypeError(`workspaceId must be a non-empty string, got ${String(value)}`);
-        return value;
-    },
-};
-const archivedSetSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        const ids = value.archivedSessionIds;
-        if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        return value;
-    },
-};
-const deletedSchema = {
-    parse(value) {
-        if (typeof value !== "object" ||
-            value === null ||
-            Array.isArray(value) ||
-            value.deleted !== true)
-            throw new TypeError("deleted must be true");
-        return value;
-    },
-};
-const archivedBatchTargetSchema = {
-    // 校验通过后原样返回记录，调用方按 scope 判别式收窄（宿主返回值校验器，故返回 any）。
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("target must be an object");
-        if (value.scope === "all" || value.scope === "ungrouped")
-            return value;
-        if (value.scope === "workspace" &&
-            typeof value.workspaceId === "string" &&
-            value.workspaceId.length > 0)
-            return value;
-        if (value.scope === "sessions" &&
-            Array.isArray(value.sessionIds) &&
-            value.sessionIds.length > 0 &&
-            value.sessionIds.every((id) => typeof id === "string" && id.length > 0))
-            return value;
-        throw new TypeError("target.scope must be all, ungrouped, workspace with a non-empty workspaceId, or sessions with non-empty sessionIds");
-    },
-};
-const unarchivedBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        if (!Array.isArray(value.archivedSessionIds) ||
-            value.archivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        if (!Array.isArray(value.unarchivedSessionIds) ||
-            value.unarchivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("unarchivedSessionIds must be a string array");
-        return value;
-    },
-};
-const archivedWorkspaceBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        if (!Array.isArray(value.archivedSessionIds) ||
-            value.archivedSessionIds.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIds must be a string array");
-        if (!Array.isArray(value.archivedSessionIdsAdded) ||
-            value.archivedSessionIdsAdded.some((id) => typeof id !== "string"))
-            throw new TypeError("archivedSessionIdsAdded must be a string array");
-        return value;
-    },
-};
-const deletedBatchSchema = {
-    parse(value) {
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throw new TypeError("result must be an object");
-        for (const key of [
-            "requestedSessionIds",
-            "deletedSessionIds",
-            "skippedSessionIds",
-        ]) {
-            if (!Array.isArray(value[key]) ||
-                value[key].some((id) => typeof id !== "string"))
-                throw new TypeError(`${key} must be a string array`);
-        }
-        if (!Array.isArray(value.failures) ||
-            value.failures.some((failure) => typeof failure !== "object" ||
-                failure === null ||
-                typeof failure.sessionId !== "string" ||
-                typeof failure.message !== "string"))
-            throw new TypeError("failures must contain sessionId/message objects");
-        return value;
-    },
-};
-const archivedSessionMetadataSchema = {
-    parse(value) {
-        if (typeof value !== "object" ||
-            value === null ||
-            Array.isArray(value) ||
-            !Array.isArray(value.items))
-            throw new TypeError("result.items must be an array");
-        if (value.items.some((item) => typeof item !== "object" ||
-            item === null ||
-            typeof item.sessionId !== "string" ||
-            typeof item.createdAt !== "number" ||
-            !Number.isFinite(item.createdAt)))
-            throw new TypeError("items must contain sessionId/createdAt objects");
-        if (value.repairedSessionIds !== void 0 &&
-            (!Array.isArray(value.repairedSessionIds) ||
-                value.repairedSessionIds.some((id) => typeof id !== "string")))
-            throw new TypeError("repairedSessionIds must be a string array");
-        return value;
-    },
-};
 /**
  * 折叠进 dsh-plugin-tool-management 的归档工作区注册表。
  * 原始实现来自 @michengai/dsh-archive-manager（Apache-2.0），剥离了
@@ -247,47 +128,6 @@ function defaultArchivedAtFile() {
 function defaultWorkspaceSnapshotFile() {
     return hubPath("history-workspaces.json");
 }
-/**
- * 路径比较键：工作区的唯一性在宿主侧是 realpath 字符串相等（dsh-workspace
- * `realpathNormalize`），Windows 盘符大小写与分隔符拼写却可能不同，因此比较前
- * 先归一化。
- *
- * ⚠ 它不是"只用于分组"：它决定**哪些会话被挂回哪条登记** —— `registerWorkspace` 会调
- * `attachKnownSessions`，后者按这个键挑选会话并写宿主记账（`sessionIds`）；
- * `ensureWorkspaceAccounting` 也拿它当去重键后 `host.create` + 挂回。
- * 而且它比宿主更宽：宿主 `realpathNormalize` 只是 `fs.realpath`（**不做大小写归一**），
- * 本函数在 Windows 上 `toLowerCase()` ⇒ `C:\Proj` 与 `c:\proj` 在插件里同组、在宿主里
- * 可以是两条登记。挂回前应以宿主 `resolveByPath` 实际返回的 id 复核，而不是按归一字符串匹配。
- * @param {string} path - 原始路径。
- * @returns {string} 归一化后的比较键（空路径返回空串）。
- */
-function workspacePathKey(path) {
-    const raw = String(path ?? "").trim();
-    if (!raw)
-        return "";
-    const windows = /^[A-Za-z]:[\\/]/.test(raw) || raw.startsWith("\\\\");
-    let out = windows ? raw.replace(/\//g, "\\") : raw;
-    while (out.length > 1 && (out.endsWith("\\") || out.endsWith("/")))
-        out = out.slice(0, -1);
-    return windows ? out.toLowerCase() : out;
-}
-/**
- * 展示用目录名（与宿主 `defaultWorkspaceTitle` 同义：末段，无末段则用根拼写）。
- * @param {string} path - 原始路径。
- * @returns {string} 非空展示名。
- */
-function workspaceBaseName(path) {
-    const raw = String(path ?? "").trim();
-    if (!raw)
-        return "";
-    const trimmed = raw.replace(/[\\/]+$/, "");
-    const index = Math.max(trimmed.lastIndexOf("\\"), trimmed.lastIndexOf("/"));
-    const segment = index >= 0 ? trimmed.slice(index + 1) : trimmed;
-    if (segment)
-        return segment;
-    const root = trimmed.match(/^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/);
-    return root ? root[0] : trimmed || raw;
-}
 // Standalone facade over the existing registry. Never instantiate/register a
 // second WorkspaceRegistry, and never open another copy of its storage domain.
 var ArchiveWorkspaceRegistry = class {
@@ -402,6 +242,23 @@ var ArchiveWorkspaceRegistry = class {
         if (changed)
             await this.saveArchivedAt();
     }
+    /**
+     * 以宿主权威归档集合构造恢复回执。
+     *
+     * 官方 `unarchiveSession` 只回 `Promise<void>`，**宿主给什么一律不认**，委托与自持两条
+     * 分支共用这一个形状。读公开 getter 而不是 `requireState()`：后者经 `bridge.state()`
+     * 落到 `method("requireState")`，宿主缺这个私有成员时会直接抛（bridge.ts:331）——
+     * 恢复已经成功了，不该被一份回执拖成失败。
+     */
+    archivedSetResult() {
+        const raw = this.archivedSessionIds;
+        if (!Array.isArray(raw)) {
+            this.ctx.logger.warn("archive-manager: registry.archivedSessionIds is not an array; reporting an empty archive set");
+            return { archivedSessionIds: [] };
+        }
+        // 集合由我们自己拼，schema 在这里是后置断言：真触发说明 getter 的声明与运行时不符。
+        return archivedSetSchema.parse({ archivedSessionIds: [...new Set(raw.map((id) => String(id)))] });
+    }
     async ensureArchivedAtLoaded() {
         await this.ready;
         if (this.archivedAtLoaded)
@@ -849,9 +706,10 @@ var ArchiveWorkspaceRegistry = class {
     async unarchiveSession(sessionId) {
         this.bridge.checkWorkspace("unarchive");
         if (typeof this.registry.unarchiveSession === "function") {
-            const result = await this.registry.unarchiveSession(sessionId);
+            await this.registry.unarchiveSession(sessionId);
             await this.reconcileArchiveLedger();
-            return result;
+            // 官方只回 Promise<void>，返回值不认；回执按权威集合自造（见 archivedSetResult）。
+            return this.archivedSetResult();
         }
         return this.enqueueOperation(async () => {
             if (!(await this.sessionKnown(sessionId)))
@@ -917,6 +775,9 @@ var ArchiveWorkspaceRegistry = class {
      * 目标全部来自已归档集合，因此即使日志已被外部移除，也会清掉陈旧归档标记。
      */
     async unarchiveSessions(target) {
+        // ⚠️ 这一支今天**跑不到**：宿主没有 `unarchiveSessions`（dsh-workspace 全库零命中），
+        // 所以无从测试。它保留了「直接认宿主返回值」这个和 unarchiveSession 同型的过度信任 ——
+        // 官方哪天补上这个方法时，先照 unarchiveSession 的做法改成自造回执，别照抄这一行。
         if (typeof this.registry.unarchiveSessions === "function") {
             const result = await this.registry.unarchiveSessions(target);
             await this.reconcileArchiveLedger();
@@ -926,7 +787,7 @@ var ArchiveWorkspaceRegistry = class {
             const ids = this.archivedSessionIdsForTarget(target);
             for (const id of ids)
                 await this.unarchiveSession(id);
-            return { unarchivedSessionIds: ids, archivedSessionIds: [...this.registry.archivedSessionIds] };
+            return { unarchivedSessionIds: ids, ...this.archivedSetResult() };
         }
         return this.enqueueOperation(async () => {
             const unarchivedSessionIds = this.archivedSessionIdsForTarget(target);
@@ -1483,4 +1344,6 @@ var ArchiveWorkspaceRegistry = class {
     }
 };
 //#endregion
-export { ArchiveWorkspaceRegistry, ArchiveWorkspaceRegistry as default, workspaceBaseName, workspacePathKey };
+export { ArchiveWorkspaceRegistry, ArchiveWorkspaceRegistry as default };
+// 路径键拆进 path-key.ts 后照旧从这个入口对外可见（package.json 的 exports 只声明 ./workspace）。
+export { workspaceBaseName, workspacePathKey } from "./path-key.js";

package/lib/settings-sidecars.js

@@ -0,0 +1,143 @@
+// 三份界面设置侧车（inject / scene / slash）的读写与 TTL 缓存。
+//
+// 正文从 index.ts 的 apply 闭包里整段搬来，一字未改（只去一层缩进，并把五个 apply 作用域
+// 名字改成走 deps —— moved-verify 按这三类容差机检）。
+//
+// 为什么三份缓存仍留在闭包里：本工厂在 apply 的同一位置只调用一次，`let *Cache` 还是
+// 「每次 apply 一份」。搬到模块级就变成每进程一份，热更新重进 apply 时旧缓存会被复用 ——
+// 那是语义翻转，不是搬家。
+import { hubPath } from './hub.js';
+import { DEFAULT_INJECT_SETTINGS, normalizeInjectSettings } from './context-inject.js';
+import { normalizeSceneSettings } from './scene-settings.js';
+import { normalizeSlashSettings } from './slash-settings.js';
+export function createSettingsSidecars(deps) {
+    // 注入设置（侧车 `inject-settings.json`，界面在「兼容」页）：
+    //   - underSuppressingPresets：压制型预设（persona complete / 关运行时上下文，如极简）
+    //     下是否仍然注入。默认 false = 跟随预设。
+    //   - domains：各域开关（任何预设下都生效；界面五个勾选）。
+    // 注入器每个 step 都要同步读一次设置 → 走 TTL 缓存；未加载时先给默认值并异步预热。
+    const INJECT_SETTINGS_FILE = 'inject-settings.json';
+    const INJECT_SETTINGS_TTL_MS = 3000;
+    let injectSettingsCache = null;
+    async function readInjectSettings(force = false) {
+        if (injectSettingsCache && !force && Date.now() - injectSettingsCache.at < INJECT_SETTINGS_TTL_MS)
+            return injectSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(INJECT_SETTINGS_FILE));
+        injectSettingsCache = { at: Date.now(), value: normalizeInjectSettings(raw) };
+        return injectSettingsCache.value;
+    }
+    /** 同步快照（注入器取用）；还没加载时先返回默认值，并顺手预热一次。 */
+    function injectSettingsSync() {
+        if (injectSettingsCache)
+            return injectSettingsCache.value;
+        void readInjectSettings().catch(() => { });
+        return DEFAULT_INJECT_SETTINGS;
+    }
+    /** 边界提示要的注入设置快照（总开关 + 各域开关）。 */
+    const injectNoticeOptions = () => {
+        const s = injectSettingsSync();
+        return { underSuppressingPresets: s.underSuppressingPresets, domains: s.domains };
+    };
+    async function injectSettingsOp(args) {
+        const current = await readInjectSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeInjectSettings({
+            underSuppressingPresets: typeof args.underSuppressingPresets === 'boolean'
+                ? args.underSuppressingPresets
+                : current.underSuppressingPresets,
+            domains: { ...current.domains, ...(args.domains && typeof args.domains === 'object' ? args.domains : {}) },
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(INJECT_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            injectSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    // 场景页的界面设置（侧车 `scene-settings.json`）：目前只有一项 —— 进入场景前要不要先弹
+    // 那张「会改什么」的卡。它纯粹是界面提示，所以**不进场景冻结**（锁着场景的人在场景页
+    // 照样能关掉提醒，那与五个管理域的只读无关）。
+    const SCENE_SETTINGS_FILE = 'scene-settings.json';
+    const SCENE_SETTINGS_TTL_MS = 3000;
+    let sceneSettingsCache = null;
+    async function readSceneSettings(force = false) {
+        if (sceneSettingsCache && !force && Date.now() - sceneSettingsCache.at < SCENE_SETTINGS_TTL_MS)
+            return sceneSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(SCENE_SETTINGS_FILE));
+        const value = normalizeSceneSettings(raw);
+        sceneSettingsCache = { at: Date.now(), value };
+        return value;
+    }
+    async function sceneSettingsOp(args) {
+        const current = await readSceneSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeSceneSettings({
+            enterPreview: typeof args.enterPreview === 'boolean' ? args.enterPreview : current.enterPreview,
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(SCENE_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            sceneSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    // 斜杠命令入口的开关（侧车 `slash-settings.json`）：两段各一颗 —— 「工具」与「快捷提示词」。
+    // 判据与 `scene-settings` 同一条 —— 它是入口开关、不是管理动作，所以不冻结；读侧不带 `set`
+    // 时是纯读（客户端 boot 时必问一次，不能要令牌）。
+    const SLASH_SETTINGS_FILE = 'slash-settings.json';
+    const SLASH_SETTINGS_TTL_MS = 3000;
+    let slashSettingsCache = null;
+    async function readSlashSettings(force = false) {
+        if (slashSettingsCache && !force && Date.now() - slashSettingsCache.at < SLASH_SETTINGS_TTL_MS)
+            return slashSettingsCache.value;
+        await deps.ensurePaths();
+        const raw = await deps.readJsonFile(hubPath(SLASH_SETTINGS_FILE));
+        const value = normalizeSlashSettings(raw);
+        slashSettingsCache = { at: Date.now(), value };
+        return value;
+    }
+    async function slashSettingsOp(args) {
+        const current = await readSlashSettings();
+        if (!args || args.set !== true)
+            return { ok: true, settings: current };
+        const next = normalizeSlashSettings({
+            tools: typeof args.tools === 'boolean' ? args.tools : current.tools,
+            quickPrompts: typeof args.quickPrompts === 'boolean' ? args.quickPrompts : current.quickPrompts,
+        });
+        await deps.ensurePaths();
+        return deps.withWriteLock(async () => {
+            try {
+                await deps.writeJsonFile(hubPath(SLASH_SETTINGS_FILE), next);
+            }
+            catch (e) {
+                return { ok: false, error: '设置保存失败: ' + deps.message(e) };
+            }
+            slashSettingsCache = { at: Date.now(), value: next };
+            return { ok: true, settings: next };
+        });
+    }
+    return {
+        readInjectSettings,
+        injectSettingsSync,
+        injectNoticeOptions,
+        injectSettingsOp,
+        readSceneSettings,
+        sceneSettingsOp,
+        readSlashSettings,
+        slashSettingsOp,
+    };
+}

package/lib/skills/core-types.js

@@ -0,0 +1,8 @@
+// 技能核心的类型面（回执形状、状态文档、扫描与导入结构）。
+//
+// 从 core.ts 整段搬来，一行未改；类型在编译期擦除，所以这一刀不动运行时一个字。
+// 拆它的理由很直白：core.ts 那四千多行里，「每个函数返回什么形状」与「怎么读写磁盘」
+// 原本挤在同一个文件里来回翻。
+//
+// 这些类型原先是 core.ts 的私有声明（无一 export），现在导出层只服务 core.ts 自己。
+export {};

package/lib/skills/core-util.js

@@ -0,0 +1,81 @@
+// 技能核心的公共底座：业务错误码的构造与透传、条目路径谓词、可恢复 rename 的重试、
+// 同目录临时文件名。
+//
+// 声明从 core.ts 逐个搬来（`--export-top-level` 只多 `export ` 前缀，正文一字未改）。
+// 为什么要先有这一层：codedError / attachCode / lstatOrNull / renameWithRetry 这四件被
+// **导入链路与技能读写两侧同时用到**，留在 core.ts 里就意味着任何从 core 搬出去的下游段
+// 都要反过来引 core —— 那是运行时环。搬到这里，core.ts 与导入链路两侧都只向下引这一层。
+// 这一层自己不引同目录的任何兄弟模块（只引 ../paths.js 与 node:*）。
+import { basename, dirname, join, resolve } from "node:path";
+import { promises as fs } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { isSameOrDescendant, isValidSegment } from "../paths.js";
+export const MAX_ENTRY_NAME_LENGTH = 128;
+export const TRANSIENT_RENAME_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+// ── 业务错误码 ────────────────────────────────────────────────────────────────
+/** 构造带 code/params 的业务 Error，供导入链路 throw 后透传到失败明细。 */
+export function codedError(message, code, params) {
+    const error = new Error(message);
+    error.code = code;
+    error.params = params;
+    return error;
+}
+/** 把业务 Error 的 code/params 附加到失败明细；系统异常（ENOENT 等，非 error.* 前缀）保持原文。 */
+export function attachCode(item, error) {
+    // 透传并回写任意失败明细对象（形状由各调用点决定），故按 any 处理。
+    const coded = error;
+    if (coded && typeof coded.code === "string" && /^error\./.test(coded.code))
+        item.code = coded.code;
+    if (coded && coded.params)
+        item.params = coded.params;
+    return item;
+}
+export function pathIdentity(path) {
+    const canonical = resolve(path);
+    return process.platform === "win32" ? canonical.toLowerCase() : canonical;
+}
+export async function lstatOrNull(path) {
+    try {
+        return await fs.lstat(path);
+    }
+    catch {
+        return null;
+    }
+}
+/** 名称只允许一个普通路径段；不把既有技能名称限制为 kebab-case。 */
+export function entryPath(root, name) {
+    // 段名谓词收敛到 paths.js（此前与 rules / subagents / imports 各写一套，口径不一）。
+    // 原实现里 `basename(name) !== name` 那条已被谓词的「不含路径分隔符」覆盖。
+    if (!isValidSegment(name, MAX_ENTRY_NAME_LENGTH))
+        return null;
+    const rootPath = resolve(root);
+    const path = resolve(rootPath, name);
+    return isSameOrDescendant(rootPath, path) && rootPath !== path ? path : null;
+}
+/** 同目录临时文件加 rename，避免写入中断时截断原 SKILL.md。 */
+/** Windows 上杀毒软件或索引器可能短暂占用目录；只重试明确可恢复的 rename 错误。 */
+export async function renameWithRetry(source, destination, options = {}) {
+    const rename = typeof options.rename === "function" ? options.rename : fs.rename;
+    // Number.isInteger/isFinite 不收窄类型，故断言成 number 以保持既有比较表达式。
+    const maxAttempts = Number.isInteger(options.maxAttempts) && options.maxAttempts > 0
+        ? options.maxAttempts
+        : 6;
+    const delayMs = Number.isFinite(options.delayMs) && options.delayMs >= 0
+        ? options.delayMs
+        : 40;
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await rename(source, destination);
+        }
+        catch (error) {
+            // 系统 rename 异常按可选 code 读取，保持既有重试判定。
+            if (!TRANSIENT_RENAME_CODES.has(error && error.code) ||
+                attempt >= maxAttempts)
+                throw error;
+            await new Promise((resolvePromise) => setTimeout(resolvePromise, delayMs * attempt));
+        }
+    }
+}
+export function temporaryPath(target, kind) {
+    return join(dirname(target), `.${basename(target)}.dssm-${kind}-${randomUUID()}`);
+}