@dev-anywhere/proxy 0.0.5 → 0.1.0

package/dist/serve.js

@@ -5,7 +5,7 @@ import {
   KnownContentBlockSchema,
   SeqCounter,
   StreamJsonEventSchema
-} from "./chunk-2Q3Z3ICU.js";
+} from "./chunk-JPJMOVQ5.js";
 import {
   createFSM,
   defineFSM,
@@ -14,7 +14,7 @@ import {
   serviceLogger,
   shouldReleaseApprovalWait,
   stateAfterApprovalRelease
-} from "./chunk-UGFYGF3Y.js";
+} from "./chunk-WXWH6L7J.js";
 import {
   spawnScript
 } from "./chunk-ZUWAB67J.js";
@@ -27,6 +27,8 @@ import {
   CONFIG_PATH,
   ControlErrorCode,
   DATA_DIR,
+  HOOK_REGISTRY_PATH,
+  MessageEnvelopeSchema,
   PID_PATH,
   SESSIONS_PATH,
   SOCK_PATH,
@@ -39,11 +41,11 @@ import {
   serializeWorkerMsg,
   sessionPaths,
   tildify
-} from "./chunk-QJ5CQDK7.js";
+} from "./chunk-QWPI6YON.js";
 
 // src/serve.ts
 import { createServer as createServer2 } from "net";
-import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync4, chmodSync, rmSync as rmSync2 } from "fs";
+import { unlinkSync as unlinkSync3, writeFileSync as writeFileSync6, chmodSync, rmSync as rmSync2 } from "fs";
 
 // src/serve/session-manager.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync } from "fs";
@@ -181,6 +183,14 @@ var SessionManager = class {
     serviceLogger.info({ sessionId: id, from: oldState, to: newState }, "Session state changed");
     return true;
   }
+  touchSession(id, now = Date.now(), minIntervalMs = 0) {
+    const session = this.sessions.get(id);
+    if (!session) return false;
+    if (now - session.updatedAt < minIntervalMs) return false;
+    session.updatedAt = now;
+    this.save();
+    return true;
+  }
   terminateSession(id, context) {
     const session = this.sessions.get(id);
     if (!session) {
@@ -764,7 +774,7 @@ import { readdir as readdir2, mkdir } from "fs/promises";
 import { join as join4, isAbsolute as isAbsolute2, normalize } from "path";
 
 // src/serve/session-history.ts
-import { readdir, stat, access } from "fs/promises";
+import { readdir, stat, access, open } from "fs/promises";
 import { createReadStream } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -864,49 +874,123 @@ async function scanCodexSessionHistory() {
   }
   return entries;
 }
-async function readSessionMessages(claudeSessionId) {
+var DEFAULT_HISTORY_PAGE_LIMIT = 50;
+var MAX_HISTORY_PAGE_LIMIT = 200;
+var HISTORY_READ_CHUNK_BYTES = 64 * 1024;
+var HISTORY_CURSOR_PREFIX = "b:";
+function normalizeHistoryPageLimit(limit) {
+  if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_HISTORY_PAGE_LIMIT;
+  return Math.max(1, Math.min(MAX_HISTORY_PAGE_LIMIT, Math.floor(limit)));
+}
+function encodeHistoryCursor(offset) {
+  return `${HISTORY_CURSOR_PREFIX}${Math.max(0, Math.floor(offset))}`;
+}
+function decodeHistoryCursor(cursor, fileSize) {
+  if (!cursor) return fileSize;
+  const raw = cursor.startsWith(HISTORY_CURSOR_PREFIX) ? cursor.slice(HISTORY_CURSOR_PREFIX.length) : cursor;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) return fileSize;
+  return Math.min(parsed, fileSize);
+}
+async function findClaudeSessionFile(claudeSessionId) {
   let projectDirs;
   try {
     projectDirs = await readdir(claudeProjectsDir());
   } catch {
-    return [];
+    return null;
   }
   for (const encodedDir of projectDirs) {
     const filePath = join2(claudeProjectsDir(), encodedDir, `${claudeSessionId}.jsonl`);
     try {
       await access(filePath);
+      return filePath;
     } catch {
       continue;
     }
-    const messages = [];
-    return new Promise((resolve) => {
-      const rl = createInterface({
-        input: createReadStream(filePath, { encoding: "utf-8" }),
-        crlfDelay: Infinity
-      });
-      rl.on("line", (line) => {
-        if (!line.trim()) return;
+  }
+  return null;
+}
+function extractConversationMessageFromJson(obj) {
+  if (!obj || typeof obj !== "object") return null;
+  const record = obj;
+  if (record.type === "user") {
+    if (record.isMeta) return null;
+    const text = extractConversationText(record.message);
+    if (!text) return null;
+    const ts = typeof record.timestamp === "string" ? new Date(record.timestamp).getTime() : void 0;
+    return { role: "user", text, timestamp: ts };
+  }
+  if (record.type === "assistant") {
+    const text = extractConversationText(record.message);
+    if (!text) return null;
+    const ts = typeof record.timestamp === "string" ? new Date(record.timestamp).getTime() : void 0;
+    return { role: "assistant", text, timestamp: ts };
+  }
+  return null;
+}
+function splitLineSegments(block, blockStart) {
+  const segments = [];
+  let start = 0;
+  for (let i = 0; i < block.length; i += 1) {
+    if (block[i] !== 10) continue;
+    segments.push({ start: blockStart + start, line: block.subarray(start, i) });
+    start = i + 1;
+  }
+  segments.push({ start: blockStart + start, line: block.subarray(start) });
+  return segments;
+}
+function stripCarriageReturn(line) {
+  return line.length > 0 && line[line.length - 1] === 13 ? line.subarray(0, -1) : line;
+}
+async function readSessionMessagesPageFromFile(filePath, options = {}) {
+  const limit = normalizeHistoryPageLimit(options.limit);
+  const file = await open(filePath, "r");
+  try {
+    const fileStat = await file.stat();
+    const endOffset = decodeHistoryCursor(options.before, fileStat.size);
+    if (endOffset <= 0) return { messages: [], hasMore: false };
+    let position = endOffset;
+    let carry = Buffer.alloc(0);
+    const collected = [];
+    while (position > 0 && collected.length <= limit) {
+      const readSize = Math.min(HISTORY_READ_CHUNK_BYTES, position);
+      position -= readSize;
+      const chunk = Buffer.alloc(readSize);
+      await file.read(chunk, 0, readSize, position);
+      const block = carry.length > 0 ? Buffer.concat([chunk, carry]) : chunk;
+      const segments = splitLineSegments(block, position);
+      const firstCompleteIndex = position > 0 ? 1 : 0;
+      carry = position > 0 ? segments[0]?.line ?? Buffer.alloc(0) : Buffer.alloc(0);
+      for (let i = segments.length - 1; i >= firstCompleteIndex; i -= 1) {
+        const segment = segments[i];
+        if (!segment) continue;
+        const line = stripCarriageReturn(segment.line);
+        if (line.length === 0) continue;
         try {
-          const obj = JSON.parse(line);
-          if (obj.type === "user") {
-            if (obj.isMeta) return;
-            const text = extractConversationText(obj.message);
-            if (!text) return;
-            const ts = typeof obj.timestamp === "string" ? new Date(obj.timestamp).getTime() : void 0;
-            messages.push({ role: "user", text, timestamp: ts });
-          } else if (obj.type === "assistant") {
-            const text = extractConversationText(obj.message);
-            const ts = typeof obj.timestamp === "string" ? new Date(obj.timestamp).getTime() : void 0;
-            if (text) messages.push({ role: "assistant", text, timestamp: ts });
-          }
+          const parsed = JSON.parse(line.toString("utf-8"));
+          const message = extractConversationMessageFromJson(parsed);
+          if (!message) continue;
+          collected.push({ ...message, cursor: encodeHistoryCursor(segment.start) });
+          if (collected.length > limit) break;
         } catch {
         }
-      });
-      rl.on("close", () => resolve(messages));
-      rl.on("error", () => resolve(messages));
-    });
+      }
+    }
+    const page = collected.slice(0, limit).reverse();
+    const hasMore = collected.length > limit;
+    return {
+      messages: page,
+      hasMore,
+      ...hasMore && page[0]?.cursor ? { nextBefore: page[0].cursor } : {}
+    };
+  } finally {
+    await file.close();
   }
-  return [];
+}
+async function readSessionMessagesPage(claudeSessionId, options = {}) {
+  const filePath = await findClaudeSessionFile(claudeSessionId);
+  if (!filePath) return { messages: [], hasMore: false };
+  return readSessionMessagesPageFromFile(filePath, options);
 }
 function collapseWhitespace(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -1002,7 +1086,7 @@ function extractConversationText(msg) {
   return null;
 }
 async function extractTitleAndCwd(filePath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface({
       input: createReadStream(filePath, { encoding: "utf-8" }),
       crlfDelay: Infinity
@@ -1030,10 +1114,10 @@ async function extractTitleAndCwd(filePath) {
       }
     });
     rl.on("close", () => {
-      if (!resolved) resolve({ title, cwd });
-      else resolve({ title, cwd });
+      if (!resolved) resolve2({ title, cwd });
+      else resolve2({ title, cwd });
     });
-    rl.on("error", () => resolve({ title, cwd }));
+    rl.on("error", () => resolve2({ title, cwd }));
   });
 }
 async function collectJsonlFiles(root) {
@@ -1055,7 +1139,7 @@ async function collectJsonlFiles(root) {
   return files;
 }
 async function extractCodexTitleAndCwd(filePath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const rl = createInterface({
       input: createReadStream(filePath, { encoding: "utf-8" }),
       crlfDelay: Infinity
@@ -1079,8 +1163,8 @@ async function extractCodexTitleAndCwd(filePath) {
       } catch {
       }
     });
-    rl.on("close", () => resolve({ id, title, cwd }));
-    rl.on("error", () => resolve({ id, title, cwd }));
+    rl.on("close", () => resolve2({ id, title, cwd }));
+    rl.on("error", () => resolve2({ id, title, cwd }));
   });
 }
 function extractCodexUserText(payload) {
@@ -1645,16 +1729,16 @@ var WorkerRegistry = class {
     return workerPid;
   }
   connect(sessionId, sockPath) {
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const sock = connect(sockPath);
       sock.on("connect", () => {
         this.sockets.set(sessionId, sock);
         createWorkerReader(sock, (msg) => this.handleWorkerMessage(sessionId, msg));
         sock.on("close", () => this.onDisconnect(sessionId));
         sock.on("error", () => this.onDisconnect(sessionId));
-        resolve(sock);
+        resolve2(sock);
       });
-      sock.on("error", () => resolve(null));
+      sock.on("error", () => resolve2(null));
     });
   }
   // 枚举 DATA_DIR 下所有 session 目录，尝试连接存活的 worker.sock；失败则清理 stale socket。
@@ -1780,6 +1864,7 @@ var WorkerRegistry = class {
       return;
     }
     const ev = parsed.data;
+    this.deps.touchSessionActivity?.(sessionId);
     const isStreamDeltaSession = this.streamDeltaSessions.has(sessionId);
     if (ev.type === "stream_event") {
       const delta = ContentBlockDeltaSchema.safeParse(ev.event);
@@ -1977,6 +2062,80 @@ function terminateSessionByOwnership(deps, sessionId) {
   return { success: false, action: "not_found" };
 }
 
+// src/serve/clipboard-image-upload.ts
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { isAbsolute as isAbsolute3, join as join5, relative, resolve } from "path";
+import { nanoid as nanoid3 } from "nanoid";
+var MAX_CLIPBOARD_IMAGE_BYTES = 10 * 1024 * 1024;
+var MAX_CLIPBOARD_IMAGE_BASE64_LENGTH = Math.ceil(MAX_CLIPBOARD_IMAGE_BYTES / 3) * 4;
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Map([
+  ["image/png", "png"],
+  ["image/jpeg", "jpg"],
+  ["image/webp", "webp"],
+  ["image/gif", "gif"]
+]);
+function formatTimestamp(ms) {
+  const [date, time = "000000"] = new Date(ms).toISOString().replace(/\.\d{3}Z$/, "").split("T");
+  return `${date.replace(/-/g, "")}-${time.replace(/:/g, "")}`;
+}
+function normalizeBase64(input) {
+  return input.replace(/^data:[^;]+;base64,/i, "").replace(/\s/g, "");
+}
+function decodeBase64Image(dataBase64) {
+  const normalized = normalizeBase64(dataBase64);
+  if (normalized.length > MAX_CLIPBOARD_IMAGE_BASE64_LENGTH) {
+    throw new Error("\u56FE\u7247\u8D85\u8FC7 10MB \u9650\u5236");
+  }
+  if (!normalized || !/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
+    throw new Error("\u56FE\u7247\u6570\u636E\u4E0D\u662F\u6709\u6548\u7684 base64");
+  }
+  const buffer = Buffer.from(normalized, "base64");
+  if (buffer.length === 0) throw new Error("\u56FE\u7247\u6570\u636E\u4E3A\u7A7A");
+  if (buffer.length > MAX_CLIPBOARD_IMAGE_BYTES) {
+    throw new Error("\u56FE\u7247\u8D85\u8FC7 10MB \u9650\u5236");
+  }
+  return buffer;
+}
+function resolveSessionClipboardDir(dataDir, sessionId) {
+  const root = resolve(dataDir);
+  const uploadDir = resolve(root, sessionId, "clipboard");
+  const relativePath = relative(root, uploadDir);
+  if (!relativePath || relativePath.startsWith("..") || isAbsolute3(relativePath)) {
+    throw new Error("\u4F1A\u8BDD\u8DEF\u5F84\u65E0\u6548");
+  }
+  return uploadDir;
+}
+function saveClipboardImageUpload(request, options = {}) {
+  const extension = IMAGE_EXTENSIONS.get(request.mimeType);
+  if (!extension) {
+    return {
+      success: false,
+      path: "",
+      error: "\u4E0D\u652F\u6301\u8FD9\u79CD\u56FE\u7247\u683C\u5F0F",
+      errorCode: ControlErrorCode.UNKNOWN
+    };
+  }
+  try {
+    const dataDir = options.dataDir ?? DATA_DIR;
+    const uploadDir = resolveSessionClipboardDir(dataDir, request.sessionId);
+    const buffer = decodeBase64Image(request.dataBase64);
+    const now = options.now ?? Date.now;
+    const suffix = options.randomSuffix?.() ?? nanoid3(6);
+    const fileName = `pasted-${formatTimestamp(now())}-${suffix}.${extension}`;
+    const path = join5(uploadDir, fileName);
+    mkdirSync4(uploadDir, { recursive: true });
+    writeFileSync4(path, buffer, { mode: 384 });
+    return { success: true, path };
+  } catch (err) {
+    return {
+      success: false,
+      path: "",
+      error: err instanceof Error ? err.message : String(err),
+      errorCode: ControlErrorCode.UNKNOWN
+    };
+  }
+}
+
 // src/serve/pty-input.ts
 function serializeRawPtyInput(sessionId, data) {
   return serializeIpc({ type: "pty_input", sessionId, data });
@@ -2008,6 +2167,21 @@ var RelayInputHandlers = class {
         serviceLogger.warn({ sessionId }, "Remote input dropped: JSON worker socket not available");
         return;
       }
+      const timestamp = typeof msg.timestamp === "number" && Number.isFinite(msg.timestamp) ? msg.timestamp : Date.now();
+      const seq = typeof msg.seq === "number" && Number.isInteger(msg.seq) && msg.seq >= 0 ? msg.seq : 0;
+      const version = typeof msg.version === "string" ? msg.version : "1";
+      const messageId = typeof payload?.messageId === "string" && payload.messageId.length > 0 ? payload.messageId : `${sessionId}-user-${timestamp}`;
+      this.deps.relayConnection.sendEnvelope(
+        MessageEnvelopeSchema.parse({
+          type: "user_input",
+          sessionId,
+          seq,
+          timestamp,
+          source: "proxy",
+          version,
+          payload: { text, messageId }
+        })
+      );
       serviceLogger.info({ sessionId }, "Remote input forwarded to JSON worker");
       return;
     }
@@ -2035,6 +2209,42 @@ var RelayInputHandlers = class {
     ts.write(serializeRawPtyInput(sessionId, data));
     serviceLogger.info({ sessionId, bytes: data.length }, "Raw PTY input forwarded");
   }
+  onClipboardImageUpload(msg) {
+    const sessionId = msg.sessionId;
+    const requestId = msg.requestId;
+    if (!sessionId) return;
+    const session = this.deps.sessionManager.getSession(sessionId);
+    if (!session) {
+      this.deps.relayConnection.sendRaw(
+        JSON.stringify({
+          type: "clipboard_image_upload_response",
+          requestId,
+          sessionId,
+          success: false,
+          path: "",
+          error: "\u4F1A\u8BDD\u4E0D\u5B58\u5728",
+          errorCode: ControlErrorCode.SESSION_NOT_FOUND
+        })
+      );
+      serviceLogger.warn({ sessionId }, "Clipboard image upload rejected: session not found");
+      return;
+    }
+    const result = saveClipboardImageUpload({
+      sessionId,
+      mimeType: typeof msg.mimeType === "string" ? msg.mimeType : "",
+      dataBase64: typeof msg.dataBase64 === "string" ? msg.dataBase64 : "",
+      fileName: typeof msg.fileName === "string" ? msg.fileName : void 0
+    });
+    this.deps.relayConnection.sendRaw(
+      JSON.stringify({
+        type: "clipboard_image_upload_response",
+        requestId,
+        sessionId,
+        ...result
+      })
+    );
+    serviceLogger.info({ sessionId, success: result.success }, "Clipboard image upload handled");
+  }
 };
 
 // src/serve/relay-history-handlers.ts
@@ -2047,32 +2257,45 @@ var RelayHistoryHandlers = class {
     const sid = msg.sessionId;
     if (!sid) return;
     const requestId = msg.requestId;
+    const before = msg.before;
+    const limit = msg.limit;
     const session = this.deps.sessionManager.getSession(sid);
     if (session?.claudeSessionId) {
-      readSessionMessages(session.claudeSessionId).then((messages) => {
+      readSessionMessagesPage(session.claudeSessionId, { before, limit }).then((page) => {
         this.deps.relaySend(
           JSON.stringify({
             type: "session_history_messages",
             requestId,
             sessionId: sid,
-            messages
+            ...before !== void 0 ? { before } : {},
+            messages: page.messages,
+            hasMore: page.hasMore,
+            ...page.nextBefore !== void 0 ? { nextBefore: page.nextBefore } : {}
           })
         );
         serviceLogger.info(
-          { sessionId: sid, messageCount: messages.length },
-          "History messages sent on request"
+          {
+            sessionId: sid,
+            before,
+            hasMore: page.hasMore,
+            nextBefore: page.nextBefore,
+            messageCount: page.messages.length
+          },
+          "History message page sent on request"
         );
       }).catch((err) => {
         serviceLogger.warn(
           { sessionId: sid, error: String(err) },
-          "Failed to read session history messages on request"
+          "Failed to read session history page on request"
         );
         this.deps.relaySend(
           JSON.stringify({
             type: "session_history_messages",
             requestId,
             sessionId: sid,
-            messages: []
+            ...before !== void 0 ? { before } : {},
+            messages: [],
+            hasMore: false
           })
         );
       });
@@ -2082,7 +2305,9 @@ var RelayHistoryHandlers = class {
           type: "session_history_messages",
           requestId,
           sessionId: sid,
-          messages: []
+          ...before !== void 0 ? { before } : {},
+          messages: [],
+          hasMore: false
         })
       );
     }
@@ -2336,8 +2561,8 @@ var RelayResourceHandlers = class {
 
 // src/serve/relay-session-create-handler.ts
 import { rmSync, statSync as statSync2 } from "fs";
-import { isAbsolute as isAbsolute3 } from "path";
-import { nanoid as nanoid3 } from "nanoid";
+import { isAbsolute as isAbsolute4 } from "path";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/serve/hosted-pty-registry.ts
 import * as pty from "node-pty";
@@ -2489,6 +2714,7 @@ var HostedPtyRegistry = class {
     hosted.lastOutputTime = Date.now();
     hosted.outputSeq += 1;
     hosted.terminal.write(data);
+    this.deps.touchSessionActivity(sessionId);
     this.sendBinary(sessionId, Buffer.from(data, "utf-8"), hosted.outputSeq);
     const oscSequences = extractOscSequences(data);
     const session = this.deps.sessionManager.getSession(sessionId);
@@ -2625,7 +2851,7 @@ function validateSessionCwd(cwd) {
     return { message: "\u8BF7\u8F93\u5165\u5DE5\u4F5C\u76EE\u5F55", code: ControlErrorCode.INVALID_PATH };
   }
   const trimmed = cwd.trim();
-  if (!isAbsolute3(trimmed)) {
+  if (!isAbsolute4(trimmed)) {
     return { message: "\u5DE5\u4F5C\u76EE\u5F55\u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84", code: ControlErrorCode.INVALID_PATH };
   }
   try {
@@ -2684,7 +2910,7 @@ var RelaySessionCreateHandler = class {
     const resumeSessionId = msg.resumeSessionId;
     const streamDelta = msg.streamDelta === true;
     const name = tildify(sessionCwd);
-    const pendingId = nanoid3();
+    const pendingId = nanoid4();
     const hook = this.deps.createHookContext(pendingId, provider);
     const workerPid = this.deps.workerRegistry.spawn(pendingId, {
       cwd: sessionCwd,
@@ -2769,7 +2995,7 @@ var RelaySessionCreateHandler = class {
       return;
     }
     const resumeSessionId = msg.resumeSessionId;
-    const pendingId = nanoid3();
+    const pendingId = nanoid4();
     const name = tildify(cwd);
     const hook = this.deps.createHookContext(pendingId, provider);
     try {
@@ -2834,19 +3060,30 @@ var RelaySessionCreateHandler = class {
     }
   }
   pushHistoryMessages(sessionId, resumeSessionId) {
-    readSessionMessages(resumeSessionId).then((messages) => {
-      if (messages.length === 0) return;
+    readSessionMessagesPage(resumeSessionId).then((page) => {
+      if (page.messages.length === 0) return;
       this.deps.relaySend(
-        JSON.stringify({ type: "session_history_messages", sessionId, messages })
+        JSON.stringify({
+          type: "session_history_messages",
+          sessionId,
+          messages: page.messages,
+          hasMore: page.hasMore,
+          ...page.nextBefore !== void 0 ? { nextBefore: page.nextBefore } : {}
+        })
       );
       serviceLogger.info(
-        { sessionId, resumeSessionId, messageCount: messages.length },
-        "History messages sent for resumed session"
+        {
+          sessionId,
+          resumeSessionId,
+          messageCount: page.messages.length,
+          hasMore: page.hasMore
+        },
+        "History message page sent for resumed session"
       );
     }).catch((err) => {
       serviceLogger.warn(
         { sessionId, error: String(err) },
-        "Failed to read session history messages"
+        "Failed to read session history page"
       );
     });
   }
@@ -2864,6 +3101,7 @@ var RelayRouter = class {
     this.inputHandlers = new RelayInputHandlers({
       sessionManager: deps.sessionManager,
       workerRegistry: deps.workerRegistry,
+      relayConnection: deps.relayConnection,
       terminalSockets: deps.terminalSockets,
       hostedPtyRegistry: deps.hostedPtyRegistry,
       jsonObserver: deps.jsonObserver
@@ -2924,6 +3162,7 @@ var RelayRouter = class {
   handlers = {
     user_input: (msg) => this.inputHandlers.onUserInput(msg),
     remote_input_raw: (msg) => this.inputHandlers.onRemoteInputRaw(msg),
+    clipboard_image_upload: (msg) => this.inputHandlers.onClipboardImageUpload(msg),
     tool_approve: (msg) => this.permissionHandlers.onToolApprove(msg),
     tool_deny: (msg) => this.permissionHandlers.onToolDeny(msg),
     proxy_info_request: (msg) => this.resourceHandlers.onProxyInfoRequest(msg),
@@ -3114,11 +3353,11 @@ var PermissionBroker = class {
         message: "Duplicate permission request id."
       });
     }
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       this.pending.set(request.requestId, {
         ...request,
         source: "hook",
-        resolve,
+        resolve: resolve2,
         createdAt: Date.now()
       });
     });
@@ -3342,6 +3581,7 @@ var AgentStatusRegistry = class {
 };
 
 // src/serve/session-broadcast.ts
+var ACTIVITY_STATUS_PUSH_INTERVAL_MS = 15e3;
 function toSessionListPayload(s) {
   return {
     sessionId: s.id,
@@ -3404,6 +3644,11 @@ function changeSessionState(sessionManager, relay, sessionId, next) {
   if (changed) pushSessionStatus(relay, sessionManager, sessionId);
   return changed;
 }
+function touchSessionActivity(sessionManager, relay, sessionId, now = Date.now()) {
+  const touched = sessionManager.touchSession(sessionId, now, ACTIVITY_STATUS_PUSH_INTERVAL_MS);
+  if (touched) pushSessionStatus(relay, sessionManager, sessionId);
+  return touched;
+}
 
 // src/serve/service-files.ts
 import { execSync } from "child_process";
@@ -3411,10 +3656,10 @@ import { existsSync as existsSync5, readFileSync as readFileSync5, unlinkSync as
 import { hostname } from "os";
 import { connect as connect2 } from "net";
 function tryConnectSocket(sockPath) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const s = connect2(sockPath);
-    s.on("connect", () => resolve(s));
-    s.on("error", () => resolve(null));
+    s.on("connect", () => resolve2(s));
+    s.on("error", () => resolve2(null));
   });
 }
 function isProcessAlive(pid) {
@@ -3758,6 +4003,7 @@ function handleTerminalConnection(socket, deps) {
     },
     (sessionId, data, outputSeq) => {
       if (!sessionManager.getSession(sessionId)) return;
+      touchSessionActivity(sessionManager, relayConnection, sessionId);
       const sessionIdBuf = Buffer.from(sessionId, "utf-8");
       const wsFrame = Buffer.alloc(1 + sessionIdBuf.length + 4 + data.length);
       wsFrame[0] = sessionIdBuf.length;
@@ -3808,6 +4054,21 @@ function handleTerminalConnection(socket, deps) {
 
 // src/serve/hook-registry.ts
 import { createHash, randomBytes } from "crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname4 } from "path";
+import { z } from "zod";
+var PersistedHookSessionBindingSchema = z.object({
+  sessionId: z.string(),
+  provider: z.enum(["claude", "codex"]),
+  marker: z.string(),
+  tokenHash: z.string(),
+  createdAt: z.number(),
+  expiresAt: z.number().optional()
+});
+var PersistedHookRegistrySchema = z.object({
+  version: z.literal(1),
+  bindings: z.array(PersistedHookSessionBindingSchema)
+});
 function hashToken(token) {
   return createHash("sha256").update(token).digest("hex");
 }
@@ -3816,6 +4077,11 @@ function randomSecret() {
 }
 var HookRegistry = class {
   bindingsBySession = /* @__PURE__ */ new Map();
+  persistPath;
+  constructor(options = {}) {
+    this.persistPath = options.persistPath;
+    this.load();
+  }
   registerSession(sessionId, provider, options = {}) {
     const now = options.now ?? Date.now();
     const token = randomSecret();
@@ -3828,6 +4094,7 @@ var HookRegistry = class {
       createdAt: now,
       ...options.ttlMs ? { expiresAt: now + options.ttlMs } : {}
     });
+    this.save();
     return { sessionId, provider, marker, token };
   }
   verify(options) {
@@ -3843,7 +4110,50 @@ var HookRegistry = class {
     return this.bindingsBySession.get(sessionId) ?? null;
   }
   unregisterSession(sessionId) {
-    this.bindingsBySession.delete(sessionId);
+    if (this.bindingsBySession.delete(sessionId)) {
+      this.save();
+    }
+  }
+  load() {
+    if (!this.persistPath || !existsSync6(this.persistPath)) return;
+    try {
+      const parsed = PersistedHookRegistrySchema.parse(
+        JSON.parse(readFileSync6(this.persistPath, "utf8"))
+      );
+      this.bindingsBySession.clear();
+      for (const binding of parsed.bindings) {
+        this.bindingsBySession.set(binding.sessionId, binding);
+      }
+    } catch (err) {
+      serviceLogger.warn(
+        { path: this.persistPath, error: String(err) },
+        "Failed to load hook registry state"
+      );
+    }
+  }
+  save() {
+    if (!this.persistPath) return;
+    try {
+      mkdirSync5(dirname4(this.persistPath), { recursive: true });
+      const tmpPath = `${this.persistPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync5(
+        tmpPath,
+        JSON.stringify(
+          {
+            version: 1,
+            bindings: Array.from(this.bindingsBySession.values())
+          },
+          null,
+          2
+        )
+      );
+      renameSync2(tmpPath, this.persistPath);
+    } catch (err) {
+      serviceLogger.warn(
+        { path: this.persistPath, error: String(err) },
+        "Failed to persist hook registry state"
+      );
+    }
   }
 };
 
@@ -3878,7 +4188,7 @@ var HookServer = class {
         this.writeJson(res, 500, { error: "internal_error" });
       });
     });
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const onError = (err) => {
         this.server?.off("listening", onListening);
         reject(err);
@@ -3886,7 +4196,7 @@ var HookServer = class {
       const onListening = () => {
         this.server?.off("error", onError);
         serviceLogger.info({ host: this.host, port: this.options.port }, "Hook server listening");
-        resolve();
+        resolve2();
       };
       this.server.once("error", onError);
       this.server.once("listening", onListening);
@@ -3897,8 +4207,8 @@ var HookServer = class {
     if (!this.server) return Promise.resolve();
     const server = this.server;
     this.server = null;
-    return new Promise((resolve, reject) => {
-      server.close((err) => err ? reject(err) : resolve());
+    return new Promise((resolve2, reject) => {
+      server.close((err) => err ? reject(err) : resolve2());
     });
   }
   getListeningPort() {
@@ -4012,7 +4322,7 @@ var HookServer = class {
     this.writeJson(res, 200, payload);
   }
   readBody(req) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let body = "";
       let size = 0;
       req.setEncoding("utf8");
@@ -4025,7 +4335,7 @@ var HookServer = class {
         }
         body += chunk;
       });
-      req.on("end", () => resolve(body));
+      req.on("end", () => resolve2(body));
       req.on("error", reject);
     });
   }
@@ -4038,7 +4348,7 @@ var HookServer = class {
 
 // src/serve/provider-hook-runtime.ts
 async function createProviderHookRuntime(options) {
-  const hookRegistry = new HookRegistry();
+  const hookRegistry = new HookRegistry({ persistPath: HOOK_REGISTRY_PATH });
   const hookEventRouter = new HookEventRouter({
     relayConnection: options.relayConnection,
     agentStatusRegistry: options.agentStatusRegistry,
@@ -4209,6 +4519,7 @@ async function startService(options) {
   const relaySend = (data) => relayConnection.sendRaw(data);
   const controlHandlers = createControlMessageHandlers(relaySend, sessionManager);
   const observerChangeState = (sessionId, next) => changeSessionState(sessionManager, relayConnection, sessionId, next);
+  const observerTouchActivity = (sessionId) => touchSessionActivity(sessionManager, relayConnection, sessionId);
   const emitAgentStatus = (sessionId, phase) => {
     const session = sessionManager.getSession(sessionId);
     if (!session) return;
@@ -4239,6 +4550,7 @@ async function startService(options) {
     permissionBroker,
     relayConnection,
     jsonObserver,
+    touchSessionActivity: observerTouchActivity,
     getProviderEnv
   });
   const hostedPtyRegistry = new HostedPtyRegistry({
@@ -4246,6 +4558,7 @@ async function startService(options) {
     relayConnection,
     getProviderEnv,
     changeSessionState: observerChangeState,
+    touchSessionActivity: observerTouchActivity,
     onTurnComplete: (sessionId) => {
       resolveInterruptedApprovals(
         permissionBroker,
@@ -4331,7 +4644,7 @@ async function startService(options) {
     });
   });
   server.listen(SOCK_PATH, () => {
-    writeFileSync4(PID_PATH, String(process.pid));
+    writeFileSync6(PID_PATH, String(process.pid));
     chmodSync(SOCK_PATH, 384);
     serviceLogger.info({ pid: process.pid, sock: SOCK_PATH }, "Service started");
   });