@dev-anywhere/proxy 0.0.4 → 0.0.6

package/dist/serve.js

@@ -5,7 +5,7 @@ import {
   KnownContentBlockSchema,
   SeqCounter,
   StreamJsonEventSchema
-} from "./chunk-2Q3Z3ICU.js";
+} from "./chunk-2XDZRLST.js";
 import {
   createFSM,
   defineFSM,
@@ -14,7 +14,7 @@ import {
   serviceLogger,
   shouldReleaseApprovalWait,
   stateAfterApprovalRelease
-} from "./chunk-UGFYGF3Y.js";
+} from "./chunk-XRTTHTM2.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-VHCL7NVJ.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 writeFileSync5, chmodSync, rmSync as rmSync2 } from "fs";
 
 // src/serve/session-manager.ts
 import { mkdirSync, readFileSync, renameSync, writeFileSync, existsSync } from "fs";
@@ -764,7 +766,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 +866,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();
@@ -2008,6 +2084,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;
     }
@@ -2047,32 +2138,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 +2186,9 @@ var RelayHistoryHandlers = class {
           type: "session_history_messages",
           requestId,
           sessionId: sid,
-          messages: []
+          ...before !== void 0 ? { before } : {},
+          messages: [],
+          hasMore: false
         })
       );
     }
@@ -2834,19 +2940,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 +2981,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
@@ -3808,6 +3926,21 @@ function handleTerminalConnection(socket, deps) {
 
 // src/serve/hook-registry.ts
 import { createHash, randomBytes } from "crypto";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync2, writeFileSync as writeFileSync4 } 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 +3949,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 +3966,7 @@ var HookRegistry = class {
       createdAt: now,
       ...options.ttlMs ? { expiresAt: now + options.ttlMs } : {}
     });
+    this.save();
     return { sessionId, provider, marker, token };
   }
   verify(options) {
@@ -3843,7 +3982,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 {
+      mkdirSync4(dirname4(this.persistPath), { recursive: true });
+      const tmpPath = `${this.persistPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync4(
+        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"
+      );
+    }
   }
 };
 
@@ -4038,7 +4220,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,
@@ -4331,7 +4513,7 @@ async function startService(options) {
     });
   });
   server.listen(SOCK_PATH, () => {
-    writeFileSync4(PID_PATH, String(process.pid));
+    writeFileSync5(PID_PATH, String(process.pid));
     chmodSync(SOCK_PATH, 384);
     serviceLogger.info({ pid: process.pid, sock: SOCK_PATH }, "Service started");
   });