dsh-manual-compact-plugin 0.1.3 → 0.2.0

package/README.md

@@ -10,6 +10,9 @@
 - **处理方式**：
   - 完成一批后停止
   - 分批处理直到完成
+- **取消压缩**：压缩过程中可随时取消
+- **压缩进度**：分批模式下实时显示进度条（已处理 / 总数）
+- **可读结果文件**：每次压缩自动追加到 `~/.dsh/manual-compact/<会话>.md`，含时间 / 保留数 / 压缩条数 / 摘要，可用任意文本编辑器打开
 - **压缩存档**：每次压缩显示时间、条数、约计 tokens，点击展开完整摘要
 - 调用 DSH 官方 compaction API（`compaction.compactRegion`）：不拆开工具调用对、会话忙时自动拒绝、失败不改动会话
 

package/lib/client.js

@@ -39,6 +39,10 @@ window.__ModuleLoader__.load({
       ".dsmc-actions button{border:0;border-radius:6px;padding:5px 10px;cursor:pointer;font-size:12px}",
       ".dsmc-actions button:disabled{cursor:default;opacity:.6}",
       ".dsmc-confirm{background:var(--dsw-alias-interactive-bg-primary);color:var(--dsw-alias-label-on-color)}",
+      ".dsmc-cancel{background:transparent;color:var(--dsw-alias-state-error-primary);border:1px solid var(--dsw-alias-state-error-primary)}",
+      ".dsmc-progress{height:6px;border-radius:999px;background:var(--dsw-alias-bg-layer-2);overflow:hidden;margin-top:8px;width:100%}",
+      ".dsmc-progress-fill{height:100%;border-radius:999px;background:var(--dsw-alias-interactive-bg-primary);transition:width .2s ease}",
+      ".dsmc-progress-txt{margin-top:4px;font-size:11px;color:var(--dsw-alias-label-tertiary)}",
       ".dsmc-msg{margin-top:6px;font-size:12px;line-height:16px;color:var(--dsw-alias-label-tertiary)}",
       ".dsmc-msg.dsmc-err{color:var(--dsw-alias-state-error-primary)}",
       ".dsmc-archive{max-height:160px;overflow:auto}",
@@ -101,10 +105,18 @@ window.__ModuleLoader__.load({
       var [mode, setMode] = useState("stop");
       var [localError, setLocalError] = useState("");
       var [expandedSeq, setExpandedSeq] = useState(null);
+      var [cancelling, setCancelling] = useState(false);
 
       var request = value.request;
       var busy = request !== null && request !== undefined;
       var lastRun = value.lastRun;
+      var progress = value.progress;
+      var progVisible = busy && progress && progress.nonce === (request && request.nonce) && progress.total > 0;
+
+      // Once the request clears, reset the "cancelling" local flag.
+      useEffect(function () {
+        if (!busy) setCancelling(false);
+      }, [busy]);
 
       var legacy = props.session && props.session.chat && props.session.chat.legacy;
       var nodes = legacy && Array.isArray(legacy.nodes) ? legacy.nodes : [];
@@ -114,6 +126,14 @@ window.__ModuleLoader__.load({
         if (n && n.kind === "compaction") entries.push(n);
       }
 
+      function newNonce() { return Date.now() * 1000 + Math.floor(Math.random() * 1000); }
+      function sendRequest(req) {
+        props.scope.set("request", req).catch(function (error) {
+          console.error("[dsh-manual-compact-plugin] request failed:", error);
+          setLocalError("请求发送失败，请稍后重试。");
+        });
+      }
+
       var effectiveKeep = keep;
       function submit() {
         var n = Number(effectiveKeep);
@@ -126,15 +146,12 @@ window.__ModuleLoader__.load({
           setLocalError("当前没有可压缩的会话。");
           return;
         }
-        props.scope.set("request", {
-          nonce: Date.now() * 1000 + Math.floor(Math.random() * 1000),
-          sessionId: props.sessionId,
-          keep: n,
-          mode: mode,
-        }).catch(function (error) {
-          console.error("[dsh-manual-compact-plugin] submit failed:", error);
-          setLocalError("请求发送失败，请稍后重试。");
-        });
+        sendRequest({ action: "compact", nonce: newNonce(), sessionId: props.sessionId, keep: n, mode: mode });
+      }
+      function cancelCurrent() {
+        if (props.sessionId === undefined || props.sessionId === null) return;
+        setCancelling(true);
+        sendRequest({ action: "cancel", nonce: newNonce(), sessionId: props.sessionId, keep: Number(effectiveKeep) || 4, mode: mode });
       }
 
       return react.createElement(
@@ -175,8 +192,29 @@ window.__ModuleLoader__.load({
             "button",
             { type: "button", className: "dsmc-confirm", disabled: busy, onClick: submit },
             busy ? "处理中…" : "开始压缩"
-          )
+          ),
+          busy
+            ? react.createElement(
+              "button",
+              { type: "button", className: "dsmc-cancel", disabled: cancelling, onClick: cancelCurrent },
+              cancelling ? "正在取消…" : "取消压缩"
+            )
+            : null
         ),
+        progVisible
+          ? react.createElement(
+            "div",
+            null,
+            react.createElement(
+              "div",
+              { className: "dsmc-progress" },
+              react.createElement("div", { className: "dsmc-progress-fill", style: { width: Math.round((progress.done / progress.total) * 100) + "%" } })
+            ),
+            react.createElement("div", { className: "dsmc-progress-txt" },
+              "压缩进度 " + progress.done + " / " + progress.total
+            )
+          )
+          : null,
         localError
           ? react.createElement("div", { className: "dsmc-msg dsmc-err" }, localError)
           : lastRun

package/lib/index.js

@@ -1,16 +1,20 @@
 /**
- * dsh-manual-compact — host face.
+ * dsh-manual-compact-plugin — host face.
  *
  * Registers the `manual-compact` settings namespace as the Client<->Host
  * transport (the same pattern dsh-plugin-proxy uses). The browser half writes
- * a `request` object; this half executes the compaction through the current
- * agent's official compaction seam (`compaction.compactRegion`) and writes the
- * outcome into `lastRun`, clearing the request. Safe boundaries (tool-call
- * pairing, busy session, cancellation) are enforced by the compaction seam.
+ * a `request` object with an `action`; this half executes the compaction
+ * through the current agent's official compaction seam
+ * (`compaction.compactRegion(..., signal)`), supports cancellation via an
+ * AbortController, publishes live progress, and appends a readable
+ * per-session markdown archive to `$DSH_HOME/manual-compact/<session>.md`.
+ * The outcome is published into `lastRun` and the request is cleared.
  */
 
 import z from '@deepseek-ai/schemastery'
 import { installSettingsSection } from '@deepseek-ai/dsh-settings'
+import { mkdir, appendFile } from 'node:fs/promises'
+import os from 'node:os'
 
 const name = 'dsh-manual-compact-plugin'
 const inject = ['settings', 'agents']
@@ -23,6 +27,12 @@ const Config = z.object({
     sessionId: z.string(),
     keep: z.number(),
     mode: z.union([z.const('stop'), z.const('batch')]),
+    action: z.union([z.const('compact'), z.const('cancel')]).default('compact'),
+  })]).default(null),
+  progress: z.union([z.const(null), z.object({
+    nonce: z.number(),
+    done: z.number(),
+    total: z.number(),
   })]).default(null),
   lastRun: z.union([z.const(null), z.object({
     at: z.number(),
@@ -31,49 +41,107 @@ const Config = z.object({
     ok: z.boolean(),
     shadowed: z.number(),
     message: z.string(),
+    cancelled: z.boolean().default(false),
+    file: z.string().default(''),
   })]).default(null),
 })
 
+/** Best-effort JSON-friendly timestamp. */
+function fmtTime(ms) {
+  const d = new Date(ms)
+  const pad = (v) => String(v).padStart(2, '0')
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`
+}
+
+/** Locate the newest landed compaction node, if any. */
+function newestCompactionNode(snapshot) {
+  const nodes = snapshot && snapshot.surface && snapshot.surface.nodes
+  if (!Array.isArray(nodes)) return null
+  let newest = null
+  for (const n of nodes) {
+    if (n && n.kind === 'compaction') newest = n
+  }
+  return newest
+}
+
+/** Append a readable markdown record for every completed region. */
+async function writeArchiveFile(sessionId, keep, mode, records, shadowed) {
+  if (!records.length) return ''
+  const dir = path(process.env.DSH_HOME || homeDotDsh(), 'manual-compact')
+  try { await mkdir(dir, { recursive: true }) } catch { /* best effort */ }
+  const file = path(dir, sessionId + '.md')
+  const chunks = records.map((r) => [
+    `## 压缩记录 · ${fmtTime(r.time)}`,
+    `- 保留最近：${keep} 条`,
+    `- 压缩：${shadowed} 条 · ~${fmtTokens(r.shadowedTokenCount)} tokens`,
+    `- 方式：${mode === 'batch' ? '分批处理直到完成' : '完成一批后停止'}`,
+    '',
+    r.summary || '',
+    '',
+    '---',
+    '',
+  ].join('\n'))
+  try { await appendFile(file, chunks.join('\n') + '\n', 'utf8') } catch { /* best effort */ }
+  return file
+}
+
+function homeDotDsh() {
+  return os.homedir() + (process.platform === 'win32' ? '\\.dsh' : '/.dsh')
+}
+function path(...parts) { return parts.join(process.platform === 'win32' ? '\\' : '/') }
+function fmtTokens(v) { return typeof v === 'number' && isFinite(v) ? (v >= 1000 ? Math.round(v / 1000) + 'k' : String(v)) : '?' }
+
+const ERROR_MESSAGES = {
+  busy: '当前正在压缩或模型仍在工作，请稍后再试。',
+  changed: '会话发生变化，本次压缩已停止。',
+  summary: '无法生成有效摘要，本次压缩已停止。',
+  commit: '压缩提交未完成。',
+  persistence: '摘要生成完成，但保存会话失败。',
+}
+
 /**
  * Run one manual compaction request against the requesting session.
- * @param ctx - registrant context (logger only).
- * @param agents - live agent registry; resolves the session's agent.
- * @param request - validated request payload.
- * @returns the outcome: ok, shadowed item count, and a human message.
+ * Supports cancellation through `signal` and reports progress through
+ * `onProgress`. Returns the outcome including a readable file path.
  */
-async function executeCompact(ctx, agents, request) {
+async function executeCompact(ctx, agents, request, signal, onProgress) {
   const agent = agents.get(request.sessionId)
   const compaction = agent && agent.ctx && agent.ctx.get('compaction')
   if (!agent || !compaction) {
-    return { ok: false, shadowed: 0, message: '当前会话暂时没有可用的压缩服务。' }
+    return { ok: false, shadowed: 0, message: '当前会话暂时没有可用的压缩服务。', cancelled: false, file: '' }
   }
+  const records = []
   try {
+    let done = 0
     let total = 0
     while (true) {
+      if (signal && signal.aborted) throw { name: 'AbortError' }
       const nodes = agent.session.surface.nodes
       if (!Array.isArray(nodes) || nodes.length <= request.keep) break
-      const endIndex = Math.min(nodes.length - request.keep - 1, request.mode === 'batch' ? 19 : nodes.length - request.keep - 1)
+      const toCompress = nodes.length - request.keep
+      if (total === 0) total = toCompress
+      const endIndex = Math.min(toCompress - 1, request.mode === 'batch' ? 19 : toCompress - 1)
       if (endIndex < 0) break
-      const result = await compaction.compactRegion(nodes[0], nodes[endIndex], agent)
-      total += result.shadowedSeqs.length
+      const result = await compaction.compactRegion(nodes[0], nodes[endIndex], agent, signal)
+      done += Array.isArray(result.shadowedSeqs) ? result.shadowedSeqs.length : 0
+      const rec = newestCompactionNode(agent.session.surface.nodes)
+      if (rec) {
+        records.push({ time: rec.time, shadowedItemCount: rec.shadowedItemCount, shadowedTokenCount: rec.shadowedTokenCount, summary: rec.summary })
+      }
+      if (onProgress) await onProgress({ nonce: request.nonce, done, total })
       if (request.mode !== 'batch') break
     }
-    return {
-      ok: true,
-      shadowed: total,
-      message: total
-        ? `已压缩 ${total} 条历史，保留最近 ${request.keep} 条。`
-        : `没有可压缩的历史，已保留最近 ${request.keep} 条。`,
-    }
+    const file = await writeArchiveFile(request.sessionId, request.keep, request.mode, records, done)
+    const message = done
+      ? `已压缩 ${done} 条历史，保留最近 ${request.keep} 条${done > 0 && file ? `；结果已保存到 ${file}` : ''}。`
+      : `没有可压缩的历史，已保留最近 ${request.keep} 条。`
+    return { ok: true, shadowed: done, message, cancelled: false, file }
   } catch (error) {
-    const messages = {
-      busy: '当前正在压缩或模型仍在工作，请稍后再试。',
-      changed: '会话发生变化，本次压缩已停止。',
-      summary: '无法生成有效摘要，本次压缩已停止。',
-      commit: '压缩提交未完成。',
-      persistence: '摘要生成完成，但保存会话失败。',
-    }
-    return { ok: false, shadowed: 0, message: messages[error && error.code] || `压缩失败：${error && error.message ? error.message : String(error)}` }
+    const cancelled = !!(signal && signal.aborted) || (error && error.name === 'AbortError')
+    const reason = cancelled
+      ? '已取消压缩。'
+      : ERROR_MESSAGES[error && error.code] || `压缩失败：${error && error.message ? error.message : String(error)}`
+    return { ok: false, shadowed: 0, message: reason, cancelled, file: '' }
   }
 }
 
@@ -86,17 +154,38 @@ function apply(ctx, config) {
   let getter = () => config
   let lastHandledNonce = null
   let handling = null
+  const controllers = new Map() // sessionId -> AbortController
+
   const handle = () => {
+    const current = getter()
+    const request = current && current.request
+    if (request === null || request === undefined) return
+
+    // Cancel: abort any active compaction for this session.
+    if (request.action === 'cancel') {
+      const controller = controllers.get(request.sessionId)
+      if (!controller) {
+        void ctx.settings.update(NS, { request: null }).catch(() => {})
+        return
+      }
+      controller.abort()
+      return // the running task publishes the cancelled lastRun and clears request
+    }
+
     if (handling !== null) return
+    if (request.nonce === lastHandledNonce) return
+    lastHandledNonce = request.nonce
     handling = (async () => {
+      const controller = new AbortController()
+      controllers.set(request.sessionId, controller)
       try {
-        const current = getter()
-        const request = current && current.request
-        if (request === null || request === undefined || request.nonce === lastHandledNonce) return
-        lastHandledNonce = request.nonce
-        const result = await executeCompact(ctx, ctx.agents, request)
+        const onProgress = async (p) => {
+          try { await ctx.settings.update(NS, { progress: p }) } catch {}
+        }
+        const result = await executeCompact(ctx, ctx.agents, request, controller.signal, onProgress)
         await ctx.settings.update(NS, {
           request: null,
+          progress: null,
           lastRun: {
             at: Date.now(),
             keep: request.keep,
@@ -104,15 +193,26 @@ function apply(ctx, config) {
             ok: result.ok,
             shadowed: result.shadowed,
             message: result.message,
+            cancelled: !!result.cancelled,
+            file: result.file || '',
           },
         })
       } catch (error) {
         ctx.logger.warn('manual-compact: handling a request failed: %s', String(error))
+        try {
+          await ctx.settings.update(NS, {
+            request: null,
+            progress: null,
+            lastRun: { at: Date.now(), keep: request.keep, mode: request.mode, ok: false, shadowed: 0, message: String(error), cancelled: (controller.signal && controller.signal.aborted), file: '' },
+          })
+        } catch {}
       } finally {
+        controllers.delete(request.sessionId)
         handling = null
       }
     })()
   }
+
   installSettingsSection(ctx, NS, Config, config, {
     setSource: (current) => {
       getter = current

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-manual-compact-plugin",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Manual context compaction for DeepSeek Harness: keep the latest N conversation items with stop or batch mode and a per-session compaction archive — embedded in the context meter popup when the meter panel slot exists, or a composer button otherwise.",
   "type": "module",
   "main": "lib/index.js",