@harness-mix/cli 0.1.6 → 0.1.8

package/src/main/host/runtime.js

@@ -3,7 +3,7 @@ const { promises: fs } = require("node:fs");
 const path = require("node:path");
 const { CapabilityManager } = require('../protocol-core/capability-manager');
 const { normalizeCapabilities } = require('../harness-adapter/manifest');
-const { Store } = require("./store");
+const { ThreadStore } = require('./thread-store');
 const { buildAdapters } = require("../adapters");
 const { ReviewController } = require('../workspace/review-controller');
 const { ReviewStore } = require('../workspace/review');
@@ -13,7 +13,9 @@ const { SessionHistory } = require('./session-history');
 const { Integrations } = require('./integrations');
 const { buildHandoffContext, composeHandoffEnvelope } = require('./handoff');
 const { HandoffCheckpoints } = require('./handoff-checkpoints');
-const { HandoffAccess } = require('./handoff-access');
+const { HandoffAccess } = require('./handoff-access');
+const { VerificationGates } = require('./verification-gates');
+const { storageProjection } = require('./thread-storage');
 const { createWorkspace, reviewWorkspace, applyWorkspace, removeWorkspace, discardWorkspace, pushWorkspace } = require('./collaboration-worktree');
 
 /**
@@ -24,7 +26,7 @@ const { createWorkspace, reviewWorkspace, applyWorkspace, removeWorkspace, disca
  */
 class HostRuntime {
   constructor({ dataDirectory, observer = null }) {
-    this.store = new Store(dataDirectory);
+    this.store = new ThreadStore(dataDirectory);
     this.threads = [];
     this.sessions = new Map(); // threadId -> { adapter, ...session }
     this.listeners = new Set();
@@ -44,7 +46,8 @@ class HostRuntime {
     this.history = new SessionHistory(this);
     this.integrations = new Integrations(this);
     this.handoffs = new HandoffCheckpoints(this);
-    this.handoffAccess = new HandoffAccess(this);
+    this.handoffAccess = new HandoffAccess(this);
+    this.verificationGates = new VerificationGates(this);
     this.reviewController = new ReviewController(this, { save: () => this.#save(), broadcast: () => this.#broadcast() });
     this.execution = new CoreSession();
     this.core = this.execution.core;
@@ -52,7 +55,7 @@ class HostRuntime {
   }
 
   async initialize() {
-    this.threads = await this.store.load();
+    this.threads = await this.store.loadIndex();
     await this.collaboration.initialize();
     await this.handoffs.initialize();
     const emit = (event) => this.#applyEvent(event);
@@ -64,7 +67,15 @@ class HostRuntime {
       // Resolve renamed adapters without touching native identities or transcripts.
       thread.harnessId = this.resolveHarnessId(thread.harnessId) || thread.harnessId;
       for (const entry of thread.harnessChain || []) entry.harnessId = this.resolveHarnessId(entry.harnessId) || entry.harnessId;
-      if (thread.pendingHandoff) thread.pendingHandoff.fromHarnessId = this.resolveHarnessId(thread.pendingHandoff.fromHarnessId) || thread.pendingHandoff.fromHarnessId;
+      if (thread.pendingHandoff) thread.pendingHandoff.fromHarnessId = this.resolveHarnessId(thread.pendingHandoff.fromHarnessId) || thread.pendingHandoff.fromHarnessId;
+      if (thread._storageStub) {
+        if (isDefaultTitle(thread.title) && thread.preview) {
+          const derived = deriveThreadTitle(thread.preview, [], { isWorktree: thread.workspace?.mode === 'worktree' });
+          if (derived && !isDefaultTitle(derived)) thread.title = derived;
+        }
+        if (thread.status === 'interrupted') thread.error = '宿主异常退出，任务已中断；打开任务后即可继续。';
+        continue;
+      }
       thread.connectionStatus = 'ready';
       if (thread.nativeSessionId && thread.messages?.length) thread.restore = true;
       if (thread.status === "working") {
@@ -127,9 +138,9 @@ class HostRuntime {
     return null;
   }
 
-  snapshot() {
+  snapshot() {
     return {
-      threads: this.threads.map(({ coreState, ...thread }) => ({ ...thread, capabilities: this.getCapabilities(thread.harnessId), coreEnabled: true })),
+      threads: this.threads.map(({ coreState, _storageStub, ...thread }) => ({ ...thread, capabilities: this.getCapabilities(thread.harnessId), coreEnabled: true })),
       adapters: [...this.adapters.values()].map((a) => ({ id: a.manifest.id, name: a.manifest.name, icon: a.manifest.icon, capabilities: a.manifest.capabilities, coreCapabilities: this.getCapabilities(a.manifest.id), ...this.status[a.manifest.id] })),
     };
   }
@@ -190,8 +201,13 @@ class HostRuntime {
     const switchTargets = thread && !thread.parentThreadId
       ? [...this.adapters.values()].filter(a => a.manifest.id !== thread.harnessId && this.status[a.manifest.id]?.available).map(a => a.manifest.name)
       : [];
-    const hostCommands = [
-      { id: 'delegate', label: '/delegate', description: '委派子任务给其他 Harness：/delegate <Harness 名> <任务>', action: 'insert', text: '/delegate ' },
+    const hostCommands = [
+      { id: 'delegate', label: '/delegate', description: '委派子任务给其他 Harness：/delegate <Harness 名> <任务>', action: 'insert', text: '/delegate ' },
+      { id: 'verify', label: '/verify', description: '立即运行当前任务的验证门禁', action: 'execute' },
+      { id: 'gate', label: '/gate', description: '配置门禁：/gate required|advisory|off [--auto] [--clean] [-- 验证命令]', action: 'insert', text: '/gate required ' },
+      { id: 'gate-required', label: '/gate-required', description: '启用强制验证门禁；未通过时禁止合并或推送', action: 'execute' },
+      { id: 'gate-advisory', label: '/gate-advisory', description: '启用建议型验证门禁；失败只报告、不阻止交付', action: 'execute' },
+      { id: 'gate-off', label: '/gate-off', description: '关闭当前任务的验证门禁', action: 'execute' },
       ...(switchTargets.length ? [
         { id: 'switch', label: '/switch', description: `原地切换 Harness 继续当前会话（历史与文件现场保留）：/switch <Harness 名> [备注]（可用：${switchTargets.join('、')}）`, action: 'insert', text: '/switch ' },
       ] : []),
@@ -202,8 +218,19 @@ class HostRuntime {
     return [...native.filter(c => !hostCommands.some(h => h.id === c.id)), ...hostCommands];
   }
 
-  async executeCommand(threadId, commandId) {
-    const thread = this.#requireThread(threadId);
+  async executeCommand(threadId, commandId) {
+    const thread = this.#requireThread(threadId);
+    if (commandId === 'verify') {
+      await this.runVerification(threadId);
+      return;
+    }
+    if (commandId === 'gate-required' || commandId === 'gate-advisory' || commandId === 'gate-off') {
+      const mode = commandId === 'gate-required' ? 'required' : commandId === 'gate-advisory' ? 'advisory' : 'off';
+      const previous = this.verificationGates.policy(thread);
+      await this.configureVerification(threadId, { ...previous, mode });
+      this.#notify('status', mode === 'off' ? '验证门禁已关闭' : `验证门禁已设为 ${mode}`, thread.id);
+      return;
+    }
     if (commandId === 'apply-worktree') {
       await this.applyThreadWorkspace(threadId);
       return;
@@ -224,10 +251,11 @@ class HostRuntime {
     return reviewWorkspace(thread.workspace);
   }
 
-  async applyThreadWorkspace(threadId, digest) {
+  async applyThreadWorkspace(threadId, digest) {
     const thread = this.#requireThread(threadId);
     if (thread.workspace?.mode !== 'worktree') throw new Error('该任务未使用 Worktree 隔离工作区');
-    if (this.execution.isRunning(thread.id) || thread.reviewPending) throw new Error('请等待任务完成后再合并隔离分支');
+    if (this.execution.isRunning(thread.id) || thread.reviewPending) throw new Error('请等待任务完成后再合并隔离分支');
+    this.verificationGates.assertSatisfied(thread, '合并隔离分支');
     const review = await reviewWorkspace(thread.workspace);
     const result = await applyWorkspace(thread.workspace, digest || review.digest);
     this.#notify('status', '已成功将隔离分支改动应用到主项目', thread.id);
@@ -248,10 +276,11 @@ class HostRuntime {
     return result;
   }
 
-  async pushThreadWorkspace(threadId, { remote = 'origin', branch } = {}) {
+  async pushThreadWorkspace(threadId, { remote = 'origin', branch } = {}) {
     const thread = this.#requireThread(threadId);
     if (thread.workspace?.mode !== 'worktree') throw new Error('该任务未使用 Worktree 隔离工作区');
-    if (this.execution.isRunning(thread.id) || thread.reviewPending) throw new Error('请等待任务完成后再推送分支');
+    if (this.execution.isRunning(thread.id) || thread.reviewPending) throw new Error('请等待任务完成后再推送分支');
+    this.verificationGates.assertSatisfied(thread, '推送分支');
     const result = await pushWorkspace(thread.workspace, remote, branch);
     this.#notify('status', `已成功将分支 ${result.branch} 推送到远程 ${result.remote}`, thread.id);
     return result;
@@ -278,10 +307,17 @@ class HostRuntime {
       return this.delegateTask({ fromThreadId: thread.id, harnessId: target, task, displayText: typed });
     }
     // Host 级切换指令：/switch <harness> [备注]（原地换 Harness；会话历史保留，下条消息携带一次性上下文信封）
-    if (!commandId && !delegateOf && !collaborationOf && /^\/(switch|切换)(\s|$)/.test(typed)) {
+    if (!commandId && !delegateOf && !collaborationOf && /^\/(switch|切换)(\s|$)/.test(typed)) {
       const { target, note } = parseSwitchCommand(typed);
-      return this.switchHarness(thread.id, target, { note });
-    }
+      return this.switchHarness(thread.id, target, { note });
+    }
+    if (!commandId && !delegateOf && !collaborationOf && /^\/gate(\s|$)/.test(typed)) {
+      const policy = parseVerificationCommand(typed, this.verificationGates.policy(thread));
+      return this.configureVerification(thread.id, policy);
+    }
+    if (!commandId && !delegateOf && !collaborationOf && /^\/verify\s*$/.test(typed)) {
+      return this.runVerification(thread.id);
+    }
     // 首个真实输入让预热（ephemeral）线程转正为持久会话
     if (thread.ephemeral) delete thread.ephemeral;
     // 自动为默认标题任务派生语义标题
@@ -346,7 +382,8 @@ class HostRuntime {
         }
       }
     }
-    thread.messages.push({ id: randomUUID(), role: "user", text: text ?? '', at: Date.now(), ...(prepared.meta.length ? { attachments: prepared.meta } : {}), ...(hasConcurrentTurn ? { concurrent: true } : {}) });
+    this.verificationGates.invalidate(thread);
+    thread.messages.push({ id: randomUUID(), role: "user", text: text ?? '', at: Date.now(), ...(prepared.meta.length ? { attachments: prepared.meta } : {}), ...(hasConcurrentTurn ? { concurrent: true } : {}) });
     thread.updatedAt = Date.now();
     delete thread.error;
     this.execution.turnStarted(thread, displayPrompt);
@@ -792,12 +829,49 @@ class HostRuntime {
     return thread;
   }
 
-  async setThreadArchived(threadId, archived) {
+  async setThreadArchived(threadId, archived) {
     const thread = this.#requireThread(threadId);
     if (this.execution.isRunning(thread.id)) throw new Error('任务执行中，不能归档');
     thread.archived = Boolean(archived);
     await this.#save(); this.#broadcast();
-  }
+  }
+
+  getThread(threadId) { return this.#requireThread(threadId); }
+
+  verificationState(threadId) {
+    return this.verificationGates.inspect(this.#requireThread(threadId));
+  }
+
+  async configureVerification(threadId, policy) {
+    const thread = this.#requireThread(threadId);
+    if (this.execution.isRunning(thread.id)) throw new Error('任务执行中不能修改验证门禁');
+    this.verificationGates.configure(thread, policy);
+    await this.#save();
+    this.#broadcast();
+    return this.verificationGates.inspect(thread);
+  }
+
+  async runVerification(threadId) {
+    const thread = this.#requireThread(threadId);
+    if (this.execution.isRunning(thread.id) || thread.reviewPending) throw new Error('请等待任务与文件审查结算后再运行验证');
+    const report = await this.verificationGates.run(thread);
+    await this.#save();
+    this.#broadcast();
+    this.#notify(report.status === 'passed' ? 'status' : 'error', report.status === 'passed' ? '验证门禁已通过' : '验证门禁未通过', thread.id);
+    return report;
+  }
+
+  async inspectStorage() {
+    const result = storageProjection(this.threads);
+    return { ...result, ...await this.store.inspectFiles(), backupFile: `${this.store.legacyFile}.bak` };
+  }
+
+  async optimizeStorage() {
+    const before = await this.inspectStorage();
+    await this.#save();
+    const after = await this.inspectStorage();
+    return { before, after };
+  }
 
   async setThreadSection(threadId, section, beforeThreadId) {
     const thread = this.#requireThread(threadId);
@@ -819,9 +893,10 @@ class HostRuntime {
     if (thread.workspace?.mode === 'worktree') {
       await removeWorkspace(thread.workspace).catch(() => {});
     }
-    this.threads = this.threads.filter((t) => t.id !== threadId);
-    await this.#save();
-    this.#broadcast();
+    this.threads = this.threads.filter((t) => t.id !== threadId);
+    await this.#save();
+    await this.store.remove(threadId);
+    this.#broadcast();
   }
 
   /** 移动任务到另一个项目：关闭当前原生进程，下次发送在新目录惰性恢复（项目级会话的原生历史可能不跟随） */
@@ -860,10 +935,19 @@ class HostRuntime {
     return adapter;
   }
 
-  #requireThread(threadId) {
-    const thread = this.threads.find((t) => t.id === threadId);
-    if (!thread) throw new Error("任务不存在");
-    return thread;
+  #requireThread(threadId) {
+    const thread = this.threads.find((t) => t.id === threadId);
+    if (!thread) throw new Error("任务不存在");
+    if (thread._storageStub) {
+      this.store.hydrateInto(thread);
+      thread.harnessId = this.resolveHarnessId(thread.harnessId) || thread.harnessId;
+      thread.connectionStatus = 'ready';
+      if (thread.nativeSessionId && thread.messages?.length) thread.restore = true;
+      thread.reviewPending = false;
+      thread.pendingApprovals = [];
+      this.execution.threadCreated(thread);
+    }
+    return thread;
   }
 
   async #assertCwd(cwd) {
@@ -951,7 +1035,14 @@ class HostRuntime {
       const message = thread.messages.find(m => m.coreTurnId === turn.id);
       const activeChildren = [...this.collaboration.jobs.values()].some(job => job.owner === thread.id && job.status === 'running');
       if (activeChildren) thread.reviewPending = true;
-      const task = activeChildren ? this.collaboration.cancelOwner(thread.id).catch(() => {}).then(() => this.#settleReview(thread, message)) : this.#settleReview(thread, message);
+      const settle = activeChildren ? this.collaboration.cancelOwner(thread.id).catch(() => {}).then(() => this.#settleReview(thread, message)) : this.#settleReview(thread, message);
+      const task = Promise.resolve(settle).then(async () => {
+        if (this.verificationGates.policy(thread).autoRun) {
+          await this.verificationGates.run(thread, { turnId: turn.id });
+          await this.#save();
+          this.#broadcast();
+        }
+      });
       this.reviewTasks.add(task);
       void task.finally(() => this.reviewTasks.delete(task));
     }
@@ -1037,10 +1128,16 @@ class HostRuntime {
 
   #syncCore(thread) { this.execution.sync(thread); }
 
-  #save() {
-    for (const thread of this.threads) this.#syncCore(thread);
-    return this.store.save(this.threads);
-  }
+  #save() {
+    for (const thread of this.threads) {
+      if (thread._storageStub) continue;
+      this.#syncCore(thread);
+      thread.coreState = this.execution.checkpoint(thread);
+    }
+    const saving = this.store.save(this.threads);
+    for (const thread of this.threads) delete thread.coreState;
+    return saving;
+  }
 
   #saveSoon() {
     if (this.saveTimer) return;
@@ -1059,11 +1156,28 @@ function attachSession(adapter, session, threadId) {
 }
 
 /** /delegate <harness> <任务> 指令解析（宿主级协作入口，支持中文别名；目标名解析见 resolveHarnessId） */
-function parseDelegationCommand(text) {
+function parseDelegationCommand(text) {
   const match = /^\/(?:delegate|委派)\s+(\S+)\s+([\s\S]+)/.exec(text);
   if (!match) throw new Error('用法：/delegate <harness> <任务>，例如 /delegate <目标 Harness> 审查 src/ 的改动');
   return { target: match[1], task: match[2].trim() };
-}
+}
+
+function parseVerificationCommand(text, previous) {
+  const match = /^\/gate\s+(off|advisory|required)([\s\S]*)$/i.exec(text);
+  if (!match) throw new Error('用法：/gate required|advisory|off [--auto] [--clean] [-- 验证命令]');
+  const tail = match[2].trim();
+  const separator = tail.indexOf('-- ');
+  const flags = (separator >= 0 ? tail.slice(0, separator) : tail).trim().split(/\s+/).filter(Boolean);
+  if (flags.some(flag => !['--auto', '--clean'].includes(flag))) throw new Error(`未知门禁选项：${flags.find(flag => !['--auto', '--clean'].includes(flag))}`);
+  const command = separator >= 0 ? tail.slice(separator + 3).trim() : '';
+  return {
+    ...previous,
+    mode: match[1].toLowerCase(),
+    autoRun: flags.includes('--auto'),
+    checks: { ...previous.checks, cleanWorkingTree: flags.includes('--clean') },
+    commands: command ? [{ id: 'custom', command }] : previous.commands,
+  };
+}
 
 /** /switch <harness> [备注] 指令解析（宿主级切换入口，支持中文别名；目标名解析见 resolveHarnessId） */
 function parseSwitchCommand(text) {

package/src/main/host/store.js

@@ -3,9 +3,14 @@ const path = require("node:path");
 
 /** 线程记录的 JSON 持久化：折叠排队保存 + tmp 文件原子替换，避免中间状态内存堆积 */
 class Store {
-  constructor(directory, filename = "threads.json") {
+  constructor(directory, filename = "threads.json", options = {}) {
     this.directory = directory;
     this.file = path.join(directory, filename);
+    this.schemaVersion = options.schemaVersion ?? null;
+    this.serialize = options.serialize ?? ((value) => value);
+    this.deserialize = options.deserialize ?? ((value) => value);
+    this.backup = options.backup === true;
+    this.backupPending = false;
     this.writing = false;
     this.pendingData = null;
     this.pendingResolvers = [];
@@ -21,17 +26,24 @@ class Store {
     }
     await fs.mkdir(this.directory, { recursive: true });
     try {
-      const threads = JSON.parse(await fs.readFile(this.file, "utf8"));
-      if (!Array.isArray(threads)) throw new Error('Invalid thread store; original file preserved');
-      return threads;
+      const parsed = JSON.parse(await fs.readFile(this.file, "utf8"));
+      if (!Array.isArray(parsed) && this.schemaVersion != null && parsed?.schemaVersion !== this.schemaVersion) {
+        throw new Error(`Unsupported thread store schema: ${parsed?.schemaVersion ?? 'missing'}; original file preserved`);
+      }
+      const threads = Array.isArray(parsed) ? parsed : parsed?.threads;
+      if (!Array.isArray(threads)) throw new Error('Invalid thread store; original file preserved');
+      if (this.backup && Array.isArray(parsed)) this.backupPending = true;
+      return threads.map((thread) => this.deserialize(thread));
     } catch (error) {
       if (error.code === 'ENOENT') return [];
       throw error;
     }
   }
 
-  save(threads) {
-    this.pendingData = threads;
+  save(threads) {
+    // Capture the serializable projection now. Callers may release heavyweight
+    // in-memory checkpoint fields immediately after save() returns.
+    this.pendingData = threads.map((value) => this.serialize(value));
     const promise = new Promise((resolve, reject) => {
       this.pendingResolvers.push(resolve);
       this.pendingRejecters.push(reject);
@@ -52,16 +64,25 @@ class Store {
       this.pendingRejecters = [];
       const tmpFile = `${this.file}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
       try {
-        const contents = JSON.stringify(data, null, 2);
-        await fs.mkdir(this.directory, { recursive: true });
-        await fs.writeFile(tmpFile, contents);
+        const payload = this.schemaVersion == null
+          ? data
+          : { schemaVersion: this.schemaVersion, savedAt: Date.now(), threads: data };
+        const contents = JSON.stringify(payload, null, 2);
+        await fs.mkdir(this.directory, { recursive: true });
+        await fs.writeFile(tmpFile, contents);
+        if (this.backupPending) {
+          await fs.copyFile(this.file, `${this.file}.bak`).catch((error) => {
+            if (error.code !== 'ENOENT') throw error;
+          });
+        }
         for (let attempt = 0; ; attempt++) {
-          try { await fs.rename(tmpFile, this.file); break; }
+          try { await fs.rename(tmpFile, this.file); break; }
           catch (error) {
             if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code) || attempt === 9) throw error;
             await new Promise(resolve => setTimeout(resolve, 50));
           }
-        }
+        }
+        this.backupPending = false;
         for (const r of resolvers) r();
       } catch (error) {
         await fs.unlink(tmpFile).catch(() => {});

package/src/main/host/thread-storage.js

@@ -0,0 +1,73 @@
+const { Buffer } = require('node:buffer');
+
+const DERIVED_THREAD_FIELDS = [
+  'tools', 'pendingApprovals', 'interactions', 'currentTurn', 'coreThread',
+  'coreUsage', 'usage', 'capabilities', 'coreEnabled',
+];
+const DERIVED_MESSAGE_FIELDS = [
+  'coreTurn', 'coreItems', 'text', 'thinking', 'artifacts', 'at', 'endedAt',
+  'streaming', 'stopReason', 'items',
+];
+
+function compactThread(thread) {
+  // Use structural sharing while serializing. A deep clone here would recreate the
+  // same large transient allocation this format is intended to avoid.
+  const value = { ...thread };
+  if (value.coreState?.version !== 1) return value;
+  for (const key of DERIVED_THREAD_FIELDS) delete value[key];
+  value.messages = (value.messages ?? []).map((message) => {
+    if (message.role !== 'assistant' || !message.coreTurnId) return message;
+    const compact = { ...message };
+    for (const key of DERIVED_MESSAGE_FIELDS) delete compact[key];
+    return compact;
+  });
+  value.storage = { schemaVersion: 2 };
+  return value;
+}
+
+function hydrateThread(thread) {
+  const value = { ...thread };
+  delete value.storage;
+  value.messages ??= [];
+  value.tools ??= [];
+  value.pendingApprovals ??= [];
+  return value;
+}
+
+function byteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value));
+}
+
+function storageProjection(threads) {
+  const rows = threads.map((thread) => {
+    if (thread._storageStub) return {
+      threadId: thread.id, title: thread.title, updatedAt: thread.updatedAt ?? thread.createdAt ?? 0,
+      archived: thread.archived === true, messageCount: thread.messageCount ?? null,
+      logicalBytes: null, persistedBytes: thread.recordBytes ?? null, savedBytes: null, loaded: false,
+    };
+    const logicalBytes = byteLength(thread);
+    const persistedBytes = byteLength(compactThread(thread));
+    return {
+      threadId: thread.id,
+      title: thread.title,
+      updatedAt: thread.updatedAt ?? thread.createdAt ?? 0,
+      archived: thread.archived === true,
+      messageCount: thread.messages?.length ?? 0,
+      logicalBytes,
+      persistedBytes,
+      savedBytes: Math.max(0, logicalBytes - persistedBytes),
+      loaded: true,
+    };
+  }).sort((a, b) => b.persistedBytes - a.persistedBytes);
+  return {
+    schemaVersion: 2,
+    threadCount: rows.length,
+    loadedThreadCount: rows.filter(row => row.loaded).length,
+    logicalBytes: rows.reduce((sum, row) => sum + (row.logicalBytes ?? 0), 0),
+    persistedBytes: rows.reduce((sum, row) => sum + (row.persistedBytes ?? 0), 0),
+    savedBytes: rows.reduce((sum, row) => sum + (row.savedBytes ?? 0), 0),
+    largestThreads: rows.filter(row => row.persistedBytes != null).sort((a, b) => b.persistedBytes - a.persistedBytes).slice(0, 20),
+  };
+}
+
+module.exports = { compactThread, hydrateThread, storageProjection };

package/src/main/host/thread-store.js

@@ -0,0 +1,123 @@
+const fsSync = require('node:fs');
+const { promises: fs } = fsSync;
+const path = require('node:path');
+const { compactThread, hydrateThread } = require('./thread-storage');
+
+const SCHEMA_VERSION = 3;
+
+async function writeAtomic(file, value) {
+  const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const contents = JSON.stringify(value, null, 2);
+  await fs.writeFile(tmp, contents);
+  for (let attempt = 0; ; attempt++) {
+    try { await fs.rename(tmp, file); return Buffer.byteLength(contents); }
+    catch (error) {
+      if (!['EPERM', 'EACCES', 'EBUSY'].includes(error.code) || attempt === 9) { await fs.unlink(tmp).catch(() => {}); throw error; }
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+  }
+}
+
+function recordName(id) { return `${encodeURIComponent(id)}.json`; }
+
+function summarize(thread) {
+  const firstUser = (thread.messages ?? []).find(message => message.role === 'user');
+  const fields = ['id', 'harnessId', 'title', 'cwd', 'originalCwd', 'nativeSessionId', 'status', 'connectionStatus', 'createdAt', 'updatedAt', 'archived', 'section', 'sectionEnteredAt', 'projectId', 'parentThreadId', 'ephemeral', 'gitInfo', 'workspace', 'isolation', 'harnessChain', 'pendingHandoff', 'options', 'model'];
+  const summary = Object.fromEntries(fields.filter(key => thread[key] !== undefined).map(key => [key, thread[key]]));
+  summary.preview = firstUser?.text || thread.preview || thread.title || '';
+  summary.messageCount = thread.messages?.length ?? thread.messageCount ?? 0;
+  if (thread.recordBytes != null) summary.recordBytes = thread.recordBytes;
+  return summary;
+}
+
+class ThreadStore {
+  constructor(directory) {
+    this.directory = directory;
+    this.legacyFile = path.join(directory, 'threads.json');
+    this.shardDirectory = path.join(directory, 'threads');
+    this.recordsDirectory = path.join(this.shardDirectory, 'records');
+    this.indexFile = path.join(this.shardDirectory, 'index.json');
+    this.file = this.indexFile;
+    this.writing = false;
+    this.pending = null;
+    this.waiters = [];
+  }
+  async #readIndex() {
+    try {
+      const value = JSON.parse(await fs.readFile(this.indexFile, 'utf8'));
+      if (value?.schemaVersion !== SCHEMA_VERSION || !Array.isArray(value.threads)) throw new Error('Unsupported sharded thread store; original files preserved');
+      return value;
+    } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  }
+  async #readLegacy() {
+    try {
+      const value = JSON.parse(await fs.readFile(this.legacyFile, 'utf8'));
+      const threads = Array.isArray(value) ? value : value?.threads;
+      if (!Array.isArray(threads)) throw new Error('Invalid legacy thread store; original file preserved');
+      return threads.map(hydrateThread);
+    } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  }
+  async loadIndex() {
+    const index = await this.#readIndex();
+    if (!index) return this.#readLegacy();
+    return index.threads.map(summary => ({
+      ...summary,
+      status: summary.status === 'working' ? 'interrupted' : summary.status === 'opening' ? 'ready' : summary.status,
+      connectionStatus: 'ready',
+      messages: [], tools: [], pendingApprovals: [], _storageStub: true,
+    }));
+  }
+  async load() {
+    const index = await this.#readIndex();
+    if (!index) return this.#readLegacy();
+    return Promise.all(index.threads.map(async summary => hydrateThread(JSON.parse(await fs.readFile(path.join(this.recordsDirectory, recordName(summary.id)), 'utf8')))));
+  }
+  hydrateInto(thread) {
+    if (!thread?._storageStub) return thread;
+    const record = hydrateThread(JSON.parse(fsSync.readFileSync(path.join(this.recordsDirectory, recordName(thread.id)), 'utf8')));
+    for (const key of Object.keys(thread)) delete thread[key];
+    Object.assign(thread, record);
+    return thread;
+  }
+  save(threads) {
+    this.pending = {
+      index: { schemaVersion: SCHEMA_VERSION, savedAt: Date.now(), threads: threads.map(summarize) },
+      records: threads.filter(thread => !thread._storageStub).map(thread => ({ id: thread.id, value: compactThread(thread) })),
+    };
+    const promise = new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+    void this.#drain();
+    return promise;
+  }
+  async #drain() {
+    if (this.writing) return;
+    this.writing = true;
+    while (this.pending) {
+      const snapshot = this.pending; this.pending = null;
+      const waiters = this.waiters; this.waiters = [];
+      try {
+        await fs.mkdir(this.recordsDirectory, { recursive: true });
+        if (snapshot.records.length && !fsSync.existsSync(`${this.legacyFile}.bak`)) await fs.copyFile(this.legacyFile, `${this.legacyFile}.bak`).catch(error => { if (error.code !== 'ENOENT') throw error; });
+        for (const record of snapshot.records) {
+          const bytes = await writeAtomic(path.join(this.recordsDirectory, recordName(record.id)), record.value);
+          const summary = snapshot.index.threads.find(thread => thread.id === record.id);
+          if (summary) summary.recordBytes = bytes;
+        }
+        await writeAtomic(this.indexFile, snapshot.index);
+        for (const waiter of waiters) waiter.resolve();
+      } catch (error) { for (const waiter of waiters) waiter.reject(error); }
+    }
+    this.writing = false;
+  }
+  remove(threadId) { return fs.unlink(path.join(this.recordsDirectory, recordName(threadId))).catch(error => { if (error.code !== 'ENOENT') throw error; }); }
+  async inspectFiles() {
+    const index = await fs.stat(this.indexFile).catch(() => null);
+    const legacy = await fs.stat(this.legacyFile).catch(() => null);
+    const records = await fs.readdir(this.recordsDirectory, { withFileTypes: true }).catch(() => []);
+    let recordBytes = 0;
+    for (const entry of records) if (entry.isFile() && entry.name.endsWith('.json')) recordBytes += (await fs.stat(path.join(this.recordsDirectory, entry.name))).size;
+    return { storageSchemaVersion: SCHEMA_VERSION, indexFile: this.indexFile, indexBytes: index?.size ?? 0, recordsDirectory: this.recordsDirectory, recordCount: records.filter(entry => entry.isFile() && entry.name.endsWith('.json')).length, recordBytes, legacyFile: this.legacyFile, legacyBytes: legacy?.size ?? 0 };
+  }
+}
+
+module.exports = { ThreadStore, summarize, SCHEMA_VERSION };