@michengai/dsh-archive-manager 1.0.11 → 1.0.13

package/lib/host-install.js

@@ -0,0 +1,41 @@
+import { bindArchiveManagerRemote, installArchiveWorkspace, tolerateStaleFileUploadResolver } from "./workspace.js";
+import { installArchiveProjectionCache, installArchiveProjectionCacheGuards } from "./projcache.js";
+const inject = ["workspaceRegistry", "sessionProjectionCache", "typert"];
+async function apply(ctx) {
+  tolerateStaleFileUploadResolver(ctx);
+  const registry = ctx.workspaceRegistry;
+  const cache = ctx.sessionProjectionCache;
+  const uninstallWorkspace = installArchiveWorkspace(registry);
+  let uninstallCache = async () => {
+  };
+  let unbindRemote = () => {
+  };
+  const dispose = async () => {
+    try {
+      unbindRemote();
+    } finally {
+      try {
+        await uninstallCache();
+      } finally {
+        uninstallWorkspace();
+      }
+    }
+  };
+  try {
+    try {
+      uninstallCache = await installArchiveProjectionCache(cache);
+    } catch (error) {
+      ctx.logger?.warn?.(`archive-manager: projection cache overlay skipped: ${String(error)}`);
+      uninstallCache = installArchiveProjectionCacheGuards(cache);
+    }
+    unbindRemote = bindArchiveManagerRemote(ctx);
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+  return dispose;
+}
+export {
+  apply,
+  inject
+};

package/lib/index.js

@@ -1,11 +1,32 @@
 import { registerPluginUpdater } from "./plugin-updater.js";
-const inject = ["webServer"];
-function apply(ctx) {
-  return registerPluginUpdater(ctx, {
-    endpoint: "/api/michengai/dsh-archive-manager/update",
-    packageName: "@michengai/dsh-archive-manager",
-    manifestUrl: new URL("../package.json", import.meta.url)
-  });
+import { apply as installHost, inject as hostInject } from "./host-install.js";
+const inject = ["webServer", ...hostInject];
+async function apply(ctx) {
+  let disposeUpdater = () => {
+  };
+  try {
+    disposeUpdater = registerPluginUpdater(ctx, {
+      endpoint: "/api/michengai/dsh-archive-manager/update",
+      packageName: "@michengai/dsh-archive-manager",
+      manifestUrl: new URL("../package.json", import.meta.url)
+    });
+  } catch (error) {
+    ctx.logger?.warn?.(`archive-manager: update route skipped: ${String(error)}`);
+  }
+  let disposeHost;
+  try {
+    disposeHost = await installHost(ctx);
+  } catch (error) {
+    disposeUpdater();
+    throw error;
+  }
+  return async () => {
+    try {
+      disposeUpdater();
+    } finally {
+      await disposeHost();
+    }
+  };
 }
 export {
   apply,

package/lib/plugin-updater.js

@@ -1,3 +1,4 @@
+import { symbols } from "@deepseek-ai/cordis";
 import { record } from "./contracts.js";
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
@@ -194,10 +195,34 @@ function publicError(error) {
   const message = error instanceof Error ? error.message : "\u66F4\u65B0\u6682\u4E0D\u53EF\u7528\u3002";
   return /[A-Za-z]:[\\/]|\/(?:home|root|Users|var|tmp)\//.test(message) ? "\u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u67E5\u770B\u670D\u52A1\u7AEF\u65E5\u5FD7\u3002" : message;
 }
+const updateRoutes = Symbol.for("dsh-archive-manager.update-routes");
+function updateRouteBag(server) {
+  const owner = server;
+  return owner[updateRoutes] ?? (owner[updateRoutes] = /* @__PURE__ */ new Map());
+}
+function rawService(service) {
+  const original = Reflect.get(service, symbols.original);
+  return original !== null && typeof original === "object" ? original : service;
+}
+function releaseUpdateRoute(server, path) {
+  const raw = rawService(server);
+  const bag = updateRouteBag(raw);
+  const owned = bag.get(path);
+  if (owned !== void 0) {
+    bag.delete(path);
+    owned();
+  }
+  for (const key of ["exact", "prefixes"]) {
+    const table = Reflect.get(raw, key);
+    if (table instanceof Map && table.has(path)) table.delete(path);
+  }
+}
 function registerPluginUpdater(ctx, options) {
   const host = ctx;
   let installing = false;
-  return host.webServer.register({
+  const server = rawService(host.webServer);
+  releaseUpdateRoute(server, options.endpoint);
+  const dispose = host.webServer.register({
     kind: "exact",
     path: options.endpoint,
     handler: async (request, response) => {
@@ -249,6 +274,14 @@ function registerPluginUpdater(ctx, options) {
       }
     }
   });
+  const wrapped = () => {
+    const bag = updateRouteBag(server);
+    if (bag.get(options.endpoint) !== wrapped) return;
+    bag.delete(options.endpoint);
+    dispose();
+  };
+  updateRouteBag(server).set(options.endpoint, wrapped);
+  return wrapped;
 }
 export {
   PLUGIN_UPDATE_HEADER,

package/lib/projcache.js

@@ -1,6 +1,6 @@
 const CacheBase = SessionProjectionCache;
 import { createHash } from "node:crypto";
-import { Service } from "@deepseek-ai/cordis";
+import { Service, symbols } from "@deepseek-ai/cordis";
 import {
   SessionProjectionCache,
   checkpointIdentity,
@@ -169,16 +169,16 @@ async function importMissingRecords(ctx, target, records, label) {
   }
   return imported;
 }
-async function importPreviousProjectionCache(ctx, target) {
+async function importPreviousProjectionCache(ctx, target, currentTable) {
+  const sameSpec = projectionCacheDomainSpec.version === legacyProjectionCacheDomainSpec.version && projectionCacheDomainSpec.layout === legacyProjectionCacheDomainSpec.layout;
   const legacySafeV2 = await readLegacySafeRecords(ctx, legacySafeV2ProjectionCacheDomainSpec, "archive-manager v2");
   const legacySafe = await readLegacySafeRecords(ctx, legacySafeProjectionCacheDomainSpec, "archive-manager v1");
-  const legacy = await readSourceRecords(ctx, legacyProjectionCacheDomainSpec, "legacy v3");
-  const sameSpec = projectionCacheDomainSpec.version === legacyProjectionCacheDomainSpec.version && projectionCacheDomainSpec.layout === legacyProjectionCacheDomainSpec.layout;
+  const legacy = sameSpec && currentTable !== void 0 ? { opened: true, records: [...currentTable.entries()] } : await readSourceRecords(ctx, legacyProjectionCacheDomainSpec, "legacy v3");
   let imported = 0;
   if (legacySafeV2.opened) imported += await importMissingRecords(ctx, target, legacySafeV2.records, "archive-manager v2");
   if (legacySafe.opened) imported += await importMissingRecords(ctx, target, legacySafe.records, "archive-manager v1");
   if (!sameSpec) {
-    const current = await readSourceRecords(ctx, projectionCacheDomainSpec, "current");
+    const current = currentTable !== void 0 ? { opened: true, records: [...currentTable.entries()] } : await readSourceRecords(ctx, projectionCacheDomainSpec, "current");
     if (current.opened) imported += await importMissingRecords(ctx, target, current.records, "current");
   }
   if (legacy.opened) imported += await importMissingRecords(ctx, target, legacy.records, "legacy v3");
@@ -269,11 +269,107 @@ var ArchiveProjectionCache = class extends CacheBase {
     if (idx !== -1) this.deletedSessionOrder.splice(idx, 1);
   }
 };
+const projectionGuards = /* @__PURE__ */ new WeakMap();
+function installArchiveProjectionCacheGuards(cache, table) {
+  const target = Reflect.get(cache, symbols.original) ?? cache;
+  const existing = projectionGuards.get(target);
+  if (existing) return existing;
+  const fields = {
+    table: table ?? target.table,
+    deletedSessionIds: /* @__PURE__ */ new Set(),
+    deletedSessionOrder: [],
+    deletedSessionTombstoneLimit: 4096,
+    writeTail: Promise.resolve()
+  };
+  const receiver = Object.create(target, Object.fromEntries(Object.entries(fields).map(([name, value]) => [name, { value, writable: true, configurable: true }])));
+  const restoredMethods = [];
+  let active = true;
+  const restore = () => {
+    active = false;
+    for (const item of [...restoredMethods].reverse()) {
+      if (item.descriptor) Object.defineProperty(target, item.name, item.descriptor);
+      else delete target[item.name];
+    }
+  };
+  try {
+    for (const name of Object.getOwnPropertyNames(ArchiveProjectionCache.prototype)) {
+      if (name === "constructor") continue;
+      const method = Reflect.get(ArchiveProjectionCache.prototype, name);
+      if (typeof method !== "function") continue;
+      Object.defineProperty(receiver, name, { value: method, writable: true, configurable: true });
+      const previous = target[name];
+      restoredMethods.push({ name, descriptor: Object.getOwnPropertyDescriptor(target, name) });
+      target[name] = (...args) => {
+        if (!active) {
+          if (typeof previous === "function") return Reflect.apply(previous, target, args);
+          throw new Error("archive-manager: projection cache guards are stopped");
+        }
+        const result = Reflect.apply(method, receiver, args);
+        if (name === "delete") receiver.writeTail = Promise.allSettled([receiver.writeTail, result]).then(() => void 0);
+        return result;
+      };
+    }
+  } catch (error) {
+    restore();
+    throw error;
+  }
+  let disposal;
+  const uninstall = () => {
+    if (disposal) return disposal;
+    const drain = receiver.writeTail;
+    restore();
+    projectionGuards.delete(target);
+    return disposal = drain;
+  };
+  projectionGuards.set(target, uninstall);
+  return uninstall;
+}
+const projectionOverlay = Symbol.for("dsh-archive-manager.projcache-overlay");
+async function installArchiveProjectionCache(cache) {
+  const target = cache;
+  if (target[projectionOverlay] === true) return async () => {
+  };
+  const domain = await target.ctx.storageDomain.open(safeProjectionCacheDomainSpec);
+  let installed = false;
+  const previousTable = target.table;
+  let uninstallGuards;
+  try {
+    const table = new SafeSessionTable(domain.table("sessions"));
+    await importPreviousProjectionCache(target.ctx, table, previousTable);
+    uninstallGuards = installArchiveProjectionCacheGuards(cache, table);
+    target.table = table;
+    target[projectionOverlay] = true;
+    installed = true;
+    let disposal;
+    return () => disposal ??= (async () => {
+      if (target[projectionOverlay] !== true) return;
+      const drain = uninstallGuards();
+      target.table = previousTable;
+      delete target[projectionOverlay];
+      await drain;
+      await domain.close();
+    })();
+  } catch (error) {
+    if (!installed) {
+      const drain = uninstallGuards?.();
+      target.table = previousTable;
+      delete target[projectionOverlay];
+      try {
+        await drain;
+      } finally {
+        await domain.close();
+      }
+    }
+    throw error;
+  }
+}
 export {
   ArchiveProjectionCache,
   SafeSessionTable,
   ArchiveProjectionCache as default,
   importPreviousProjectionCache,
+  installArchiveProjectionCache,
+  installArchiveProjectionCacheGuards,
   legacyProjectionCacheDomainSpec,
   legacySafeProjectionCacheDomainSpec,
   legacySafeV2ProjectionCacheDomainSpec,

package/lib/workspace.js

@@ -1,3 +1,4 @@
+import { symbols } from "@deepseek-ai/cordis";
 import { record, errorMessage, errorCode } from "./contracts.js";
 import * as SessionRuntime from "@deepseek-ai/dsh-session";
 import { childCatalogFact, prepareAutomationRepair } from "./session-repair.js";
@@ -51,6 +52,20 @@ function strictCodec(typeSymbol, schema) {
     schema
   };
 }
+const ARCHIVE_REMOTE_METHODS = [
+  "unarchiveSession",
+  "deleteSession",
+  "deleteArchivedSessions",
+  "archivedSessionMetadata",
+  "favoriteSessions",
+  "setSessionFavorite",
+  "searchArchivedContent",
+  "searchSessionContent",
+  "previewArchivedSession",
+  "sessionDetails",
+  "diagnoseSession",
+  "repairSession"
+];
 function markRemoteMethod(instance, method) {
   const context = {
     private: false,
@@ -244,6 +259,24 @@ function registerHostRemote(ctx) {
     typertCtx.typert.register(ARCHIVE_MANAGER_TYPERT);
   });
 }
+function bindArchiveManagerRemote(ctx) {
+  const typert = ctx.get("typert");
+  if (typert === void 0 || typeof typert.register !== "function") {
+    throw new Error("archive-manager: typert is unavailable");
+  }
+  try {
+    const dispose = typert.register(ARCHIVE_MANAGER_TYPERT);
+    return typeof dispose === "function" ? () => {
+      dispose();
+    } : () => {
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("already registered")) throw error;
+    return () => {
+    };
+  }
+}
 async function hostRepairFormat(format, children = []) {
   if (!format || !Number.isInteger(format.currentVersion) || format.currentVersion < 3) throw new Error("\u5F53\u524D\u5BBF\u4E3B\u4E0D\u652F\u6301\u6B64\u4FEE\u590D\uFF0C\u8BF7\u5347\u7EA7 DSH \u540E\u91CD\u8BD5");
   if (typeof format.createRestore === "function") return format;
@@ -311,30 +344,9 @@ var ArchiveWorkspaceRegistry = class extends WorkspaceRegistry {
   constructor(ctx) {
     super(ctx);
     tolerateStaleFileUploadResolver(ctx);
-    const indexedPath = this.host.sessionPath;
-    this.host.sessionPath = (id) => {
-      const path = indexedPath(id);
-      if (path !== void 0) return path;
-      if (this.invalidSessionPaths.has(id)) return void 0;
-      try {
-        return this.archivedWorkspacePath(id);
-      } catch {
-        return void 0;
-      }
-    };
+    protectArchivedSessionPath(this);
     this.typertRemote = bindTypertRemote(this, this.name);
-    markRemoteMethod(this, "unarchiveSession");
-    markRemoteMethod(this, "deleteSession");
-    markRemoteMethod(this, "deleteArchivedSessions");
-    markRemoteMethod(this, "archivedSessionMetadata");
-    markRemoteMethod(this, "favoriteSessions");
-    markRemoteMethod(this, "setSessionFavorite");
-    markRemoteMethod(this, "searchArchivedContent");
-    markRemoteMethod(this, "searchSessionContent");
-    markRemoteMethod(this, "previewArchivedSession");
-    markRemoteMethod(this, "sessionDetails");
-    markRemoteMethod(this, "diagnoseSession");
-    markRemoteMethod(this, "repairSession");
+    for (const method of ARCHIVE_REMOTE_METHODS) markRemoteMethod(this, method);
     registerHostRemote(this.ctx);
   }
   /** 只读取归档日志；已有实时实例读取快照，不调用 prepare、enter 或恢复接口。 */
@@ -1204,7 +1216,107 @@ var ArchiveWorkspaceRegistry = class extends WorkspaceRegistry {
     }
   }
 };
+const workspaceOverlay = Symbol.for("dsh-archive-manager.workspace-overlay");
+function protectArchivedSessionPath(registry) {
+  const indexedPath = registry.host.sessionPath;
+  registry.host.sessionPath = (id) => {
+    const path = indexedPath(id);
+    if (path !== void 0) return path;
+    if (registry.invalidSessionPaths.has(id)) return void 0;
+    try {
+      return registry.archivedWorkspacePath(id);
+    } catch {
+      return void 0;
+    }
+  };
+  return () => {
+    registry.host.sessionPath = indexedPath;
+  };
+}
+const remoteMethodDescriptor = "@deepseek-ai/dsh-typert-protocol/remote-methods";
+function markOverlayMethods(registry, methods) {
+  const raw = Reflect.get(registry, symbols.original) ?? registry;
+  const prototype = Object.getPrototypeOf(raw);
+  if (prototype === null) return () => {
+  };
+  const before = Object.getOwnPropertyDescriptor(prototype, remoteMethodDescriptor);
+  const marked = /* @__PURE__ */ new Set();
+  for (const marker of Reflect.get(before?.value ?? {}, "methods") ?? []) {
+    if (typeof marker.method === "string") marked.add(marker.method);
+  }
+  for (const method of methods) {
+    if (marked.has(method)) continue;
+    markRemoteMethod(raw, method);
+  }
+  return () => {
+    if (before === void 0) delete prototype[remoteMethodDescriptor];
+    else Object.defineProperty(prototype, remoteMethodDescriptor, before);
+  };
+}
+function bindOverlayRemote(registry) {
+  const raw = Reflect.get(registry, symbols.original) ?? registry;
+  if (Reflect.get(raw, "typertRemote") !== void 0) return () => {
+  };
+  const name = Reflect.get(raw, "name");
+  const serviceKey = typeof name === "string" ? name : "workspaceRegistry";
+  Reflect.set(raw, "typertRemote", bindTypertRemote(raw, serviceKey));
+  return () => {
+    Reflect.deleteProperty(raw, "typertRemote");
+  };
+}
+function installArchiveWorkspace(registry) {
+  const overlay = registry;
+  if (overlay[workspaceOverlay] === true) return () => {
+  };
+  if (registry instanceof ArchiveWorkspaceRegistry) return () => {
+  };
+  const target = overlay;
+  const fields = {
+    deletedSessionIds: /* @__PURE__ */ new Set(),
+    deletedSessionOrder: [],
+    deletedSessionTombstoneLimit: 4096,
+    deletedIdentities: /* @__PURE__ */ new Map(),
+    archivedSessionPathIndex: /* @__PURE__ */ new Map(),
+    archivedSessionPathIndexKey: void 0
+  };
+  const addedFields = [];
+  for (const [key, value] of Object.entries(fields)) {
+    if (!Object.hasOwn(target, key)) {
+      target[key] = value;
+      addedFields.push(key);
+    }
+  }
+  const restorePath = protectArchivedSessionPath(overlay);
+  const restoreRemote = bindOverlayRemote(registry);
+  const restoredMethods = [];
+  const copiedMethods = [];
+  for (const name of Object.getOwnPropertyNames(ArchiveWorkspaceRegistry.prototype)) {
+    if (name === "constructor") continue;
+    const method = Reflect.get(ArchiveWorkspaceRegistry.prototype, name);
+    if (typeof method !== "function") continue;
+    restoredMethods.push({ name, hadOwn: Object.hasOwn(target, name), previous: target[name] });
+    target[name] = method;
+    copiedMethods.push(name);
+  }
+  const restoreMarkers = markOverlayMethods(registry, ARCHIVE_REMOTE_METHODS.filter((method) => copiedMethods.includes(method)));
+  target[workspaceOverlay] = true;
+  return () => {
+    if (target[workspaceOverlay] !== true) return;
+    restorePath();
+    restoreMarkers();
+    restoreRemote();
+    for (const item of restoredMethods.reverse()) {
+      if (item.hadOwn) target[item.name] = item.previous;
+      else delete target[item.name];
+    }
+    for (const key of addedFields) delete target[key];
+    delete target[workspaceOverlay];
+  };
+}
 export {
   ArchiveWorkspaceRegistry,
-  ArchiveWorkspaceRegistry as default
+  bindArchiveManagerRemote,
+  ArchiveWorkspaceRegistry as default,
+  installArchiveWorkspace,
+  tolerateStaleFileUploadResolver
 };

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Archive Manager",
+    "description": "Archive, restore, favorite, and permanently delete sessions, and diagnose damaged session logs."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Archive Manager",
+    "description": "归档、恢复、收藏和永久删除会话，并诊断损坏的会话日志。"
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@michengai/dsh-archive-manager",
-  "version": "1.0.11",
-  "description": "NPM-installable DSH Web plugin for managing archived sessions.",
+  "version": "1.0.13",
+  "description": "归档、恢复、收藏和永久删除会话，并诊断损坏的会话日志。 · Archive, restore, favorite, and permanently delete sessions, and diagnose damaged session logs.",
   "type": "module",
   "packageManager": "pnpm@11.22.0",
   "engines": {
@@ -12,12 +12,15 @@
     ".": "./lib/index.js",
     "./workspace": "./lib/workspace.js",
     "./projcache": "./lib/projcache.js",
+    "./host": "./lib/host-install.js",
     "./client": "./lib/client.js",
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
   },
   "files": [
     "lib",
     "assets",
+    "locale",
     "cordis.patch.yml",
     "README.md",
     "README.zh-CN.md",