@michengai/dsh-archive-manager 1.1.7 → 1.1.8

package/lib/index.js

@@ -1,14 +1,125 @@
-import { registerPluginUpdater } from "./plugin-updater.js";
+import { getOnlineUpdate, getSidebarEntry, setOnlineUpdate, setSidebarEntry } from "./plugin-settings.js";
+import { isTrustedUpdateRequest, rawService, registerPluginUpdater, releaseUpdateRoute } from "./plugin-updater.js";
 import { apply as installHost, inject as hostInject } from "./host-install.js";
 const inject = ["webServer", ...hostInject];
-async function apply(ctx) {
+const SIDEBAR_ENTRY_ENDPOINT = "/api/michengai/dsh-archive-manager/sidebar-entry";
+const ONLINE_UPDATE_ENDPOINT = "/api/michengai/dsh-archive-manager/online-update";
+function sendJson(response, statusCode, value) {
+  response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+  response.end(JSON.stringify(value));
+}
+function readJsonBody(request) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let bytes = 0;
+    request.on("data", (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > 64 * 1024) return;
+      chunks.push(buffer);
+    });
+    request.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        const parsed = JSON.parse(raw);
+        resolve(parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null);
+      } catch {
+        resolve(null);
+      }
+    });
+    request.on("error", () => resolve(null));
+  });
+}
+function registerSettingsRoutes(ctx, hostUpdateDisabled) {
+  const server = rawService(ctx.webServer);
+  releaseUpdateRoute(server, SIDEBAR_ENTRY_ENDPOINT);
+  releaseUpdateRoute(server, ONLINE_UPDATE_ENDPOINT);
+  const disposeSidebar = ctx.webServer.register({
+    kind: "exact",
+    path: SIDEBAR_ENTRY_ENDPOINT,
+    handler: async (request, response) => {
+      if (request.method === "GET" || request.method === "HEAD") {
+        const enabled = await getSidebarEntry();
+        sendJson(response, 200, { ok: true, enabled });
+        return;
+      }
+      if (request.method === "POST") {
+        if (!isTrustedUpdateRequest(request)) {
+          sendJson(response, 403, { ok: false, error: "\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u540C\u6E90\u8BF7\u6C42\u3002" });
+          return;
+        }
+        const body = await readJsonBody(request);
+        if (!body || typeof body.enabled !== "boolean") {
+          sendJson(response, 400, { ok: false, error: "enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C" });
+          return;
+        }
+        const enabled = await setSidebarEntry(body.enabled);
+        sendJson(response, 200, { ok: true, enabled });
+        return;
+      }
+      response.writeHead(405, { allow: "GET, HEAD, POST" });
+      response.end();
+    }
+  });
+  const disposeUpdate = ctx.webServer.register({
+    kind: "exact",
+    path: ONLINE_UPDATE_ENDPOINT,
+    handler: async (request, response) => {
+      if (request.method === "GET" || request.method === "HEAD") {
+        const enabled = !hostUpdateDisabled && await getOnlineUpdate();
+        sendJson(response, 200, { ok: true, enabled, locked: hostUpdateDisabled });
+        return;
+      }
+      if (request.method === "POST") {
+        if (!isTrustedUpdateRequest(request)) {
+          sendJson(response, 403, { ok: false, error: "\u5DF2\u62D2\u7EDD\u975E\u672C\u673A\u540C\u6E90\u8BF7\u6C42\u3002" });
+          return;
+        }
+        if (hostUpdateDisabled) {
+          sendJson(response, 403, { ok: false, error: "\u5728\u7EBF\u66F4\u65B0\u5DF2\u88AB\u5BBF\u4E3B\u914D\u7F6E\u9501\u5B9A\u7981\u7528" });
+          return;
+        }
+        const body = await readJsonBody(request);
+        if (!body || typeof body.enabled !== "boolean") {
+          sendJson(response, 400, { ok: false, error: "enabled \u5FC5\u987B\u662F\u5E03\u5C14\u503C" });
+          return;
+        }
+        const enabled = await setOnlineUpdate(body.enabled);
+        sendJson(response, 200, { ok: true, enabled });
+        return;
+      }
+      response.writeHead(405, { allow: "GET, HEAD, POST" });
+      response.end();
+    }
+  });
+  return () => {
+    try {
+      disposeSidebar();
+    } catch {
+    }
+    try {
+      disposeUpdate();
+    } catch {
+    }
+  };
+}
+async function apply(ctx, config) {
+  const hostUpdateDisabled = config?.updater === false || config?.onlineUpdate === false;
   let disposeUpdater = () => {
   };
+  let disposeSettingsRoutes = () => {
+  };
+  try {
+    disposeSettingsRoutes = registerSettingsRoutes(ctx, hostUpdateDisabled);
+  } catch (error) {
+    ctx.logger?.warn?.(`archive-manager: settings routes skipped: ${String(error)}`);
+  }
   try {
     disposeUpdater = registerPluginUpdater(ctx, {
       endpoint: "/api/michengai/dsh-archive-manager/update",
       packageName: "@michengai/dsh-archive-manager",
-      manifestUrl: new URL("../package.json", import.meta.url)
+      manifestUrl: new URL("../package.json", import.meta.url),
+      isEnabled: async () => !hostUpdateDisabled && await getOnlineUpdate()
     });
   } catch (error) {
     ctx.logger?.warn?.(`archive-manager: update route skipped: ${String(error)}`);
@@ -18,11 +129,13 @@ async function apply(ctx) {
     disposeHost = await installHost(ctx);
   } catch (error) {
     disposeUpdater();
+    disposeSettingsRoutes();
     throw error;
   }
   return async () => {
     try {
       disposeUpdater();
+      disposeSettingsRoutes();
     } finally {
       await disposeHost();
     }

package/lib/plugin-settings.js

@@ -0,0 +1,123 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync } from "node:fs";
+import { readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function resolveDshHome() {
+  const custom = process.env.DSH_HOME;
+  if (typeof custom === "string" && custom.trim() !== "") {
+    return custom.trim();
+  }
+  return join(homedir(), ".dsh");
+}
+function managerSettingsPath() {
+  return join(resolveDshHome(), "archive-manager", "settings.json");
+}
+let writeQueue = Promise.resolve();
+function enqueueWrite(task) {
+  const next = writeQueue.then(task, task);
+  writeQueue = next.then(() => {
+  }, () => {
+  });
+  return next;
+}
+async function replaceTextFile(file, next) {
+  const dir = dirname(file);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const nonce = randomUUID();
+  const tmp = `${file}.${process.pid}.${nonce}.tmp`;
+  const backup = `${file}.${process.pid}.${nonce}.bak`;
+  await writeFile(tmp, next, "utf8");
+  try {
+    await rename(tmp, file);
+    return;
+  } catch (error) {
+    const code = error && typeof error === "object" && "code" in error ? String(error.code) : "";
+    if (code !== "EEXIST" && code !== "EPERM" && code !== "EACCES") {
+      await unlink(tmp).catch(() => {
+      });
+      throw error;
+    }
+  }
+  await unlink(backup).catch(() => {
+  });
+  await rename(file, backup);
+  try {
+    await rename(tmp, file);
+  } catch (error) {
+    await rename(backup, file).catch(() => {
+    });
+    await unlink(tmp).catch(() => {
+    });
+    throw error;
+  }
+  await unlink(backup).catch(() => {
+  });
+}
+async function readSettings() {
+  const path = managerSettingsPath();
+  if (!existsSync(path)) {
+    return { sidebarEntry: false, onlineUpdate: true };
+  }
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return { sidebarEntry: false, onlineUpdate: true };
+    }
+    const item = parsed;
+    return {
+      sidebarEntry: typeof item.sidebarEntry === "boolean" ? item.sidebarEntry : false,
+      onlineUpdate: typeof item.onlineUpdate === "boolean" ? item.onlineUpdate : true
+    };
+  } catch {
+    return { sidebarEntry: false, onlineUpdate: true };
+  }
+}
+async function writeSettings(next) {
+  const path = managerSettingsPath();
+  const serialized = `${JSON.stringify(next, null, 2)}
+`;
+  await replaceTextFile(path, serialized);
+}
+async function getSidebarEntry() {
+  const current = await readSettings();
+  return current.sidebarEntry === true;
+}
+async function setSidebarEntry(enabled) {
+  if (typeof enabled !== "boolean") {
+    throw new TypeError("sidebarEntry must be a boolean");
+  }
+  return enqueueWrite(async () => {
+    const current = await readSettings();
+    current.sidebarEntry = enabled;
+    await writeSettings(current);
+    return enabled;
+  });
+}
+async function getOnlineUpdate() {
+  const current = await readSettings();
+  return current.onlineUpdate !== false;
+}
+async function setOnlineUpdate(enabled) {
+  if (typeof enabled !== "boolean") {
+    throw new TypeError("onlineUpdate must be a boolean");
+  }
+  return enqueueWrite(async () => {
+    const current = await readSettings();
+    current.onlineUpdate = enabled;
+    await writeSettings(current);
+    return enabled;
+  });
+}
+export {
+  getOnlineUpdate,
+  getSidebarEntry,
+  managerSettingsPath,
+  readSettings,
+  setOnlineUpdate,
+  setSidebarEntry,
+  writeSettings
+};

package/lib/plugin-updater.js

@@ -367,6 +367,13 @@ function registerPluginUpdater(ctx, options) {
     path: options.endpoint,
     handler: async (request, response) => {
       try {
+        if (options.isEnabled) {
+          const allowed = await options.isEnabled();
+          if (!allowed) {
+            json(response, 403, { ok: false, error: "\u5728\u7EBF\u66F4\u65B0\u5DF2\u88AB\u7981\u7528\u3002" });
+            return;
+          }
+        }
         const target = runtime(host);
         if (request.method === "GET" || request.method === "HEAD") {
           const payload = await status(options, target);
@@ -430,8 +437,10 @@ export {
   isNewerVersion,
   isTrustedUpdateRequest,
   mergeMinimumReleaseAgeExclude,
+  rawService,
   recordReleaseAgeExclude,
   registerPluginUpdater,
+  releaseUpdateRoute,
   resolveUpdateRuntime,
   shouldNotifyParent
 };

package/lib/sidebar-entry.js

@@ -0,0 +1,393 @@
+import * as React from "react";
+import { IconArchiveOutlineMedium, Switch as PrimitiveSwitch } from "@deepseek-ai/dsh-client-ui-primitives";
+const h = React.createElement;
+const BUNDLE_KEY = "@michengai/dsh-archive-manager";
+const SIDEBAR_PANEL_ID = "archived-sessions";
+const SIDEBAR_PANEL_ORDER = 4;
+const SIDEBAR_ENTRY_STYLE_ID = "dsham-sidebar-entry-style";
+const sidebarEntryCss = `
+.dsham_mainPanel{box-sizing:border-box;height:100%;min-height:0;overflow-y:auto;display:flex;flex-direction:column;align-items:center;padding:28px clamp(24px,4vw,48px) 48px}
+.dsham_mainPanel>*{width:100%;max-width:960px}
+.dsham_bundle_row{display:flex;align-items:center;justify-content:space-between;gap:16px;padding:12px 0;border-bottom:0.5px solid var(--dsw-alias-border-l2)}
+.dsham_bundle_label_box{display:flex;flex-direction:column;gap:2px;min-width:0;flex:1;text-align:left}
+.dsham_bundle_title{font-size:13px;font-weight:500;line-height:20px;color:var(--dsw-alias-label-primary)}
+.dsham_bundle_desc{font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary)}
+`;
+function ensureSidebarEntryStyle() {
+  if (typeof document === "undefined" || typeof document.getElementById !== "function") return;
+  if (document.getElementById(SIDEBAR_ENTRY_STYLE_ID) !== null) return;
+  if (typeof document.createElement !== "function") return;
+  const style = document.createElement("style");
+  style.id = SIDEBAR_ENTRY_STYLE_ID;
+  style.textContent = sidebarEntryCss;
+  (document.head ?? document.documentElement)?.appendChild?.(style);
+}
+function ArchiveSidebarIcon(props) {
+  const size = props && typeof props.size === "number" ? props.size : 16;
+  return h(IconArchiveOutlineMedium, { size });
+}
+function ArchiveBundleConfigCard(props) {
+  ensureSidebarEntryStyle();
+  const {
+    t,
+    enabled,
+    onToggle,
+    disabled,
+    onlineUpdateEnabled = true,
+    onToggleOnlineUpdate,
+    onlineUpdateDisabled,
+    onlineUpdateLocked = false
+  } = props;
+  const rows = [
+    h(
+      "div",
+      { key: "sidebar-entry", className: "dsham_bundle_row" },
+      h(
+        "div",
+        { className: "dsham_bundle_label_box" },
+        h("span", { className: "dsham_bundle_title" }, t("sidebar.entry.title")),
+        h("span", { className: "dsham_bundle_desc" }, t("sidebar.entry.desc"))
+      ),
+      h(PrimitiveSwitch, {
+        checked: enabled,
+        onChange: onToggle,
+        label: t("sidebar.entry.toggle"),
+        disabled
+      })
+    )
+  ];
+  if (typeof onToggleOnlineUpdate === "function") {
+    const updateDesc = onlineUpdateLocked ? `${t("update.entry.desc")} (${t("update.entry.locked")})` : t("update.entry.desc");
+    rows.push(
+      h(
+        "div",
+        { key: "online-update", className: "dsham_bundle_row" },
+        h(
+          "div",
+          { className: "dsham_bundle_label_box" },
+          h("span", { className: "dsham_bundle_title" }, t("update.entry.title")),
+          h("span", { className: "dsham_bundle_desc" }, updateDesc)
+        ),
+        h(PrimitiveSwitch, {
+          checked: onlineUpdateEnabled,
+          onChange: onToggleOnlineUpdate,
+          label: t("update.entry.toggle"),
+          disabled: onlineUpdateDisabled || onlineUpdateLocked,
+          title: onlineUpdateLocked ? t("update.entry.locked") : void 0
+        })
+      )
+    );
+  }
+  return h(React.Fragment, null, rows);
+}
+function ArchiveBundleConfigCardWrapper(props) {
+  const [enabled, setEnabled] = React.useState(props.getEnabled);
+  const [onlineUpdateEnabled, setOnlineUpdateEnabled] = React.useState(props.getOnlineUpdateEnabled ? props.getOnlineUpdateEnabled : () => true);
+  const [onlineUpdateLocked, setOnlineUpdateLocked] = React.useState(props.getOnlineUpdateLocked ? props.getOnlineUpdateLocked : () => false);
+  const [savingSidebar, setSavingSidebar] = React.useState(false);
+  const [savingUpdate, setSavingUpdate] = React.useState(false);
+  React.useEffect(() => {
+    const syncState = () => {
+      setEnabled(props.getEnabled());
+      if (props.getOnlineUpdateEnabled) {
+        setOnlineUpdateEnabled(props.getOnlineUpdateEnabled());
+      }
+      if (props.getOnlineUpdateLocked) {
+        setOnlineUpdateLocked(props.getOnlineUpdateLocked());
+      }
+    };
+    syncState();
+    return props.subscribe(syncState);
+  }, [props]);
+  const onToggleSidebar = (next) => {
+    setSavingSidebar(true);
+    setEnabled(next);
+    props.setSidebar(next).catch(() => {
+      setEnabled(props.getEnabled());
+    }).finally(() => {
+      setSavingSidebar(false);
+    });
+  };
+  const onToggleOnlineUpdate = props.setOnlineUpdate ? (next) => {
+    if (props.getOnlineUpdateLocked?.()) return;
+    setSavingUpdate(true);
+    setOnlineUpdateEnabled(next);
+    props.setOnlineUpdate(next).catch(() => {
+      if (props.getOnlineUpdateEnabled) {
+        setOnlineUpdateEnabled(props.getOnlineUpdateEnabled());
+      }
+    }).finally(() => {
+      setSavingUpdate(false);
+    });
+  } : void 0;
+  return h(ArchiveBundleConfigCard, {
+    t: props.t,
+    enabled,
+    disabled: savingSidebar,
+    onToggle: onToggleSidebar,
+    onlineUpdateEnabled,
+    onlineUpdateDisabled: savingUpdate || onlineUpdateLocked,
+    onlineUpdateLocked,
+    onToggleOnlineUpdate
+  });
+}
+function setupSidebarEntry(ctx, options) {
+  ensureSidebarEntryStyle();
+  if (!ctx.locale) {
+    return {
+      isEnabled: () => false,
+      isSupported: () => false,
+      setEnabled: async () => false,
+      isOnlineUpdateEnabled: () => true,
+      isOnlineUpdateLocked: () => false,
+      setOnlineUpdate: async () => false,
+      destroy: () => {
+      }
+    };
+  }
+  const { callApi, renderPanel, ns } = options;
+  let sidebarEntryEnabled = false;
+  let sidebarSupported = false;
+  let mainSupported = false;
+  let offPanel = null;
+  let offRow = null;
+  let epoch = 0;
+  let destroyed = false;
+  let layoutService;
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    if (destroyed) return;
+    for (const listener of listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  };
+  const mountMain = () => {
+    if (destroyed || !mainSupported || !sidebarEntryEnabled || offPanel) return;
+    const res = ctx.slots.register({
+      name: "main",
+      key: SIDEBAR_PANEL_ID,
+      locale: ns,
+      inject: () => {
+        const extra = typeof options.injectProps === "function" ? options.injectProps() : {};
+        return Object.assign({ t: ctx.locale?.bind ? ctx.locale.bind(ns) : void 0 }, extra);
+      }
+    }, (ownerProps) => h("div", { className: "dsham_mainPanel" }, renderPanel(ownerProps)));
+    offPanel = typeof res === "function" ? res : () => {
+    };
+  };
+  const unmountMain = () => {
+    if (offPanel) {
+      try {
+        offPanel();
+      } catch {
+      }
+      offPanel = null;
+    }
+  };
+  const mountRow = () => {
+    if (destroyed || !sidebarSupported || !sidebarEntryEnabled || offRow) return;
+    const res = ctx.slots.register({
+      name: "sidebar.panellist",
+      id: SIDEBAR_PANEL_ID,
+      order: SIDEBAR_PANEL_ORDER,
+      label: () => ctx.locale.bind(ns)("archives.title"),
+      locale: ns
+    }, (ownerProps) => ArchiveSidebarIcon(ownerProps && typeof ownerProps === "object" && "size" in ownerProps ? ownerProps : void 0));
+    offRow = typeof res === "function" ? res : () => {
+    };
+  };
+  const unmountRow = () => {
+    if (offRow) {
+      try {
+        offRow();
+      } catch {
+      }
+      offRow = null;
+    }
+  };
+  const sync = () => {
+    if (destroyed) return;
+    if (sidebarEntryEnabled) {
+      mountMain();
+      mountRow();
+    } else {
+      if (layoutService?.panelInfo && typeof layoutService.selectPanel === "function") {
+        try {
+          if (layoutService.panelInfo.getSnapshot().activePanelId === SIDEBAR_PANEL_ID) {
+            layoutService.selectPanel(null);
+          }
+        } catch {
+        }
+      }
+      unmountRow();
+      unmountMain();
+    }
+  };
+  const setEnabled = async (next) => {
+    if (destroyed) return sidebarEntryEnabled;
+    const currentEpoch = ++epoch;
+    sidebarEntryEnabled = next;
+    sync();
+    notify();
+    try {
+      await callApi("/sidebar-entry", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ enabled: next })
+      });
+      return next;
+    } catch (err) {
+      if (currentEpoch === epoch) {
+        sidebarEntryEnabled = !next;
+        sync();
+        notify();
+      }
+      throw err;
+    }
+  };
+  let onlineUpdateEnabled = true;
+  let onlineUpdateLocked = false;
+  let updateEpoch = 0;
+  const setOnlineUpdate = async (next) => {
+    if (destroyed || onlineUpdateLocked) return onlineUpdateEnabled;
+    const currentEpoch = ++updateEpoch;
+    onlineUpdateEnabled = next;
+    notify();
+    if (typeof options.onOnlineUpdateChange === "function") {
+      try {
+        options.onOnlineUpdateChange(next);
+      } catch {
+      }
+    }
+    try {
+      await callApi("/online-update", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ enabled: next })
+      });
+      if (currentEpoch === updateEpoch && typeof options.onOnlineUpdateChange === "function") {
+        try {
+          options.onOnlineUpdateChange(next);
+        } catch {
+        }
+      }
+      return next;
+    } catch (err) {
+      if (currentEpoch === updateEpoch) {
+        onlineUpdateEnabled = !next;
+        notify();
+        if (typeof options.onOnlineUpdateChange === "function") {
+          try {
+            options.onOnlineUpdateChange(!next);
+          } catch {
+          }
+        }
+      }
+      throw err;
+    }
+  };
+  const loadEpoch = epoch;
+  callApi("/sidebar-entry").then((res) => {
+    if (!destroyed && epoch === loadEpoch && res && typeof res.enabled === "boolean") {
+      sidebarEntryEnabled = res.enabled;
+      sync();
+      notify();
+    }
+  }).catch(() => {
+  });
+  const loadUpdateEpoch = updateEpoch;
+  callApi("/online-update").then((res) => {
+    if (!destroyed && updateEpoch === loadUpdateEpoch && res && typeof res.enabled === "boolean") {
+      onlineUpdateEnabled = res.enabled;
+      if (res.locked === true) onlineUpdateLocked = true;
+      notify();
+      if (typeof options.onOnlineUpdateChange === "function") {
+        try {
+          options.onOnlineUpdateChange(onlineUpdateEnabled);
+        } catch {
+        }
+      }
+    }
+  }).catch(() => {
+  });
+  const hostCtx = ctx;
+  if (typeof hostCtx.inject === "function") {
+    hostCtx.inject(["layout"], (scoped) => {
+      if (!destroyed && scoped.layout) layoutService = scoped.layout;
+    });
+  }
+  ctx.slots.inject("main", () => {
+    if (destroyed) return;
+    mainSupported = true;
+    mountMain();
+    return () => {
+      mainSupported = false;
+      unmountMain();
+    };
+  });
+  ctx.slots.inject("sidebar.panellist", () => {
+    if (destroyed) return;
+    sidebarSupported = true;
+    mountRow();
+    return () => {
+      sidebarSupported = false;
+      unmountRow();
+    };
+  });
+  ctx.slots.inject("plugins.bundle.config", () => {
+    if (destroyed) return;
+    return ctx.slots.register({
+      name: "plugins.bundle.config",
+      key: BUNDLE_KEY,
+      locale: ns
+    }, (ownerProps) => {
+      if (ownerProps && ownerProps.view === "summary") return null;
+      return h(ArchiveBundleConfigCardWrapper, {
+        t: ctx.locale.bind(ns),
+        getEnabled: () => sidebarEntryEnabled,
+        setSidebar: setEnabled,
+        getOnlineUpdateEnabled: () => onlineUpdateEnabled,
+        setOnlineUpdate,
+        getOnlineUpdateLocked: () => onlineUpdateLocked,
+        subscribe: (fn) => {
+          listeners.add(fn);
+          return () => {
+            listeners.delete(fn);
+          };
+        }
+      });
+    });
+  });
+  return {
+    isEnabled: () => sidebarEntryEnabled,
+    isSupported: () => sidebarSupported,
+    setEnabled,
+    isOnlineUpdateEnabled: () => onlineUpdateEnabled,
+    isOnlineUpdateLocked: () => onlineUpdateLocked,
+    setOnlineUpdate,
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      epoch++;
+      updateEpoch++;
+      layoutService = void 0;
+      listeners.clear();
+      unmountRow();
+      unmountMain();
+    }
+  };
+}
+export {
+  ArchiveBundleConfigCard,
+  ArchiveSidebarIcon,
+  BUNDLE_KEY,
+  SIDEBAR_ENTRY_STYLE_ID,
+  SIDEBAR_PANEL_ID,
+  SIDEBAR_PANEL_ORDER,
+  ensureSidebarEntryStyle,
+  setupSidebarEntry,
+  sidebarEntryCss
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@michengai/dsh-archive-manager",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "归档、恢复、收藏和永久删除会话，并诊断损坏的会话日志。 · Archive, restore, favorite, and permanently delete sessions, and diagnose damaged session logs.",
   "type": "module",
   "packageManager": "pnpm@11.22.0",