@caspian2026/agent-sdk 0.0.8 → 0.0.9

package/dist/cli.js

@@ -28,22 +28,22 @@ async function main() {
     console.log(`${"2.1.888"} (Claude Code)`);
     return;
   }
-  const { profileCheckpoint } = await import("./chunk-97wgdsab.js");
+  const { profileCheckpoint } = await import("./chunk-z16txqz0.js");
   profileCheckpoint("cli_entry");
   if (false) {}
   if (process.argv[2] === "--claude-in-chrome-mcp") {
     profileCheckpoint("cli_claude_in_chrome_mcp_path");
-    const { runClaudeInChromeMcpServer } = await import("./chunk-jgzxmtpf.js");
+    const { runClaudeInChromeMcpServer } = await import("./chunk-ay5fvc2r.js");
     await runClaudeInChromeMcpServer();
     return;
   } else if (process.argv[2] === "--chrome-native-host") {
     profileCheckpoint("cli_chrome_native_host_path");
-    const { runChromeNativeHost } = await import("./chunk-hwn8vetn.js");
+    const { runChromeNativeHost } = await import("./chunk-pwpk3gm6.js");
     await runChromeNativeHost();
     return;
   } else if (process.argv[2] === "--computer-use-mcp") {
     profileCheckpoint("cli_computer_use_mcp_path");
-    const { runComputerUseMcpServer } = await import("./chunk-gdhz1652.js");
+    const { runComputerUseMcpServer } = await import("./chunk-jqfrz5g9.js");
     await runComputerUseMcpServer();
     return;
   }
@@ -62,11 +62,11 @@ async function main() {
   const hasTmuxFlag = args.includes("--tmux") || args.includes("--tmux=classic");
   if (hasTmuxFlag && (args.includes("-w") || args.includes("--worktree") || args.some((a) => a.startsWith("--worktree=")))) {
     profileCheckpoint("cli_tmux_worktree_fast_path");
-    const { enableConfigs } = await import("./chunk-gvrjgq1n.js");
+    const { enableConfigs } = await import("./chunk-rjq5nf1c.js");
     enableConfigs();
     const { isWorktreeModeEnabled } = await import("./chunk-pwwa7s62.js");
     if (isWorktreeModeEnabled()) {
-      const { execIntoTmuxWorktree } = await import("./chunk-veap97he.js");
+      const { execIntoTmuxWorktree } = await import("./chunk-0gpem3pk.js");
       const result = await execIntoTmuxWorktree(args);
       if (result.handled) {
         return;
@@ -80,10 +80,10 @@ async function main() {
   if (args.includes("--bare")) {
     process.env.CLAUDE_CODE_SIMPLE = "1";
   }
-  const { startCapturingEarlyInput } = await import("./chunk-jgpmpgx6.js");
+  const { startCapturingEarlyInput } = await import("./chunk-etdt1xz3.js");
   startCapturingEarlyInput();
   profileCheckpoint("cli_before_main_import");
-  const { main: cliMain } = await import("./chunk-qyqpb15f.js");
+  const { main: cliMain } = await import("./chunk-35nft36d.js");
   profileCheckpoint("cli_after_main_import");
   await cliMain();
   profileCheckpoint("cli_after_main_complete");

package/dist/gateway/index.js

@@ -0,0 +1,326 @@
+// src/entrypoints/gateway/index.ts
+import { createInterface } from "node:readline";
+import { resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/entrypoints/gateway/protocol.ts
+function writeJsonRpc(msg) {
+  return JSON.stringify({ jsonrpc: "2.0", ...msg }) + `
+`;
+}
+function parseJsonRpc(line) {
+  if (!line.trim())
+    return null;
+  try {
+    const obj = JSON.parse(line);
+    if (obj && typeof obj === "object" && typeof obj.method === "string") {
+      return obj;
+    }
+  } catch {}
+  return null;
+}
+
+// src/entrypoints/gateway/sessionRouter.ts
+import { Worker } from "node:worker_threads";
+import { createHash } from "node:crypto";
+var DEFAULT_MAX_SESSIONS = 16;
+var DEFAULT_IDLE_TTL_MS = 10 * 60 * 1000;
+var IDLE_CHECK_INTERVAL_MS = 60 * 1000;
+
+class SessionRouter {
+  sessions = new Map;
+  workerPath;
+  maxSessions;
+  idleTtlMs;
+  onWorkerMessage;
+  onWorkerExit;
+  idleTimer = null;
+  constructor(options) {
+    this.workerPath = options.workerPath;
+    this.maxSessions = options.maxSessions ?? DEFAULT_MAX_SESSIONS;
+    this.idleTtlMs = options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
+    this.onWorkerMessage = options.onWorkerMessage;
+    this.onWorkerExit = options.onWorkerExit;
+  }
+  start() {
+    this.idleTimer = setInterval(() => this.evictIdle(), IDLE_CHECK_INTERVAL_MS);
+  }
+  async create(sessionKey, config) {
+    if (this.sessions.has(sessionKey)) {
+      throw new Error(`Session already exists: ${sessionKey}`);
+    }
+    if (this.sessions.size >= this.maxSessions) {
+      this.evictLRU();
+    }
+    const configHash = computeConfigHash(config);
+    const worker = new Worker(this.workerPath, {
+      workerData: config
+    });
+    const entry = {
+      sessionKey,
+      worker,
+      sessionId: null,
+      configHash,
+      lastActive: new Date,
+      created: new Date
+    };
+    worker.on("message", (msg) => {
+      if (msg.type === "ready") {
+        entry.sessionId = msg.session_id;
+      }
+      entry.lastActive = new Date;
+      this.onWorkerMessage(sessionKey, msg);
+    });
+    worker.on("exit", (code) => {
+      this.sessions.delete(sessionKey);
+      this.onWorkerExit(sessionKey, code);
+    });
+    worker.on("error", (err) => {
+      this.onWorkerMessage(sessionKey, {
+        type: "error",
+        session_key: sessionKey,
+        error: `Worker thread error: ${err.message}`
+      });
+    });
+    this.sessions.set(sessionKey, entry);
+  }
+  get(sessionKey) {
+    return this.sessions.get(sessionKey);
+  }
+  has(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  getConfigHash(sessionKey) {
+    return this.sessions.get(sessionKey)?.configHash;
+  }
+  send(sessionKey, msg) {
+    const entry = this.sessions.get(sessionKey);
+    if (!entry)
+      throw new Error(`Session not found: ${sessionKey}`);
+    entry.lastActive = new Date;
+    entry.worker.postMessage(msg);
+  }
+  async destroy(sessionKey) {
+    const entry = this.sessions.get(sessionKey);
+    if (!entry)
+      return;
+    this.sessions.delete(sessionKey);
+    entry.worker.postMessage({ type: "destroy" });
+    await entry.worker.terminate();
+  }
+  async destroyAll() {
+    const keys = [...this.sessions.keys()];
+    await Promise.all(keys.map((k) => this.destroy(k)));
+  }
+  get activeCount() {
+    return this.sessions.size;
+  }
+  get entries() {
+    return this.sessions;
+  }
+  stop() {
+    if (this.idleTimer) {
+      clearInterval(this.idleTimer);
+      this.idleTimer = null;
+    }
+  }
+  evictIdle() {
+    const now = Date.now();
+    const toEvict = [];
+    for (const [key, entry] of this.sessions) {
+      if (now - entry.lastActive.getTime() > this.idleTtlMs) {
+        toEvict.push(key);
+      }
+    }
+    for (const key of toEvict) {
+      this.destroy(key).catch(() => {});
+    }
+  }
+  evictLRU() {
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.sessions) {
+      if (entry.lastActive.getTime() < oldestTime) {
+        oldestTime = entry.lastActive.getTime();
+        oldest = key;
+      }
+    }
+    if (oldest) {
+      this.destroy(oldest).catch(() => {});
+    }
+  }
+}
+function computeConfigHash(config) {
+  const parts = [
+    config.session.model ?? "",
+    config.session.cwd ?? "",
+    config.session.systemPrompt ?? "",
+    config.session.appendSystemPrompt ?? "",
+    config.session.permissionMode ?? "",
+    config.permission.mode ?? "",
+    ...(config.permission.allowed_tools ?? []).sort(),
+    ...(config.permission.denied_tools ?? []).sort()
+  ];
+  return createHash("sha256").update(JSON.stringify(parts)).digest("hex").slice(0, 16);
+}
+
+// src/entrypoints/gateway/index.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var WORKER_PATH = resolve(__dirname2, "worker.js");
+var outputBuffer = "";
+var drainResolve = null;
+var MAX_OUTPUT_BUFFER_SIZE = 10 * 1024 * 1024;
+function notify(msg) {
+  let line;
+  try {
+    line = writeJsonRpc(msg);
+  } catch (err) {
+    process.stderr.write(`Failed to serialize notification: ${err instanceof Error ? err.message : String(err)}
+`);
+    return;
+  }
+  if (outputBuffer.length + line.length > MAX_OUTPUT_BUFFER_SIZE) {
+    process.stderr.write(`Output buffer overflow, dropping notification
+`);
+    return;
+  }
+  outputBuffer += line;
+  flushOutput();
+}
+function flushOutput() {
+  if (!outputBuffer)
+    return;
+  const canContinue = process.stdout.write(outputBuffer);
+  outputBuffer = "";
+  if (!canContinue && !drainResolve) {
+    drainResolve = () => {
+      drainResolve = null;
+      flushOutput();
+    };
+    process.stdout.once("drain", drainResolve);
+  }
+}
+var router = new SessionRouter({
+  workerPath: WORKER_PATH,
+  onWorkerMessage: (sessionKey, msg) => {
+    switch (msg.type) {
+      case "ready":
+        notify({ method: "session.ready", params: { session_key: msg.session_key, session_id: msg.session_id } });
+        break;
+      case "stream":
+        notify({ method: "session.stream", params: { session_key: msg.session_key, data: msg.data } });
+        break;
+      case "complete":
+        notify({ method: "session.complete", params: { session_key: msg.session_key, session_id: msg.session_id } });
+        break;
+      case "error":
+        notify({ method: "session.error", params: { session_key: msg.session_key, error: msg.error } });
+        break;
+      case "permission_request":
+        notify({
+          method: "session.permission_request",
+          params: {
+            session_key: msg.session_key,
+            request_id: msg.request_id,
+            tool_name: msg.tool_name,
+            input: msg.input,
+            description: msg.description,
+            tool_use_id: msg.tool_use_id
+          }
+        });
+        break;
+    }
+  },
+  onWorkerExit: (sessionKey, code) => {
+    notify({ method: "session.error", params: { session_key: sessionKey, error: `Worker exited with code ${code}` } });
+  }
+});
+async function handleRequest(req) {
+  switch (req.method) {
+    case "session.create": {
+      const { session_key, config, permission, env } = req.params;
+      const workerConfig = {
+        sessionKey: session_key,
+        session: config,
+        permission,
+        env
+      };
+      try {
+        await router.create(session_key, workerConfig);
+      } catch (err) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      break;
+    }
+    case "session.prompt": {
+      const { session_key, text } = req.params;
+      try {
+        router.send(session_key, { type: "prompt", text });
+      } catch (err) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      break;
+    }
+    case "session.interrupt": {
+      const { session_key } = req.params;
+      try {
+        router.send(session_key, { type: "interrupt" });
+      } catch (err) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      break;
+    }
+    case "session.destroy": {
+      const { session_key } = req.params;
+      await router.destroy(session_key);
+      break;
+    }
+    case "session.permission_response": {
+      const { session_key, request_id, result } = req.params;
+      try {
+        router.send(session_key, { type: "permission_response", request_id, result });
+      } catch (err) {}
+      break;
+    }
+  }
+}
+async function main() {
+  router.start();
+  const rl = createInterface({ input: process.stdin });
+  for await (const line of rl) {
+    if (line.length > 1024 * 1024) {
+      process.stderr.write(`Line too long (${line.length} bytes), skipping
+`);
+      continue;
+    }
+    const req = parseJsonRpc(line);
+    if (req) {
+      await handleRequest(req);
+    }
+  }
+  await router.destroyAll();
+  router.stop();
+}
+main().catch((err) => {
+  process.stderr.write(`Gateway fatal error: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});
+var shuttingDown = false;
+process.on("SIGTERM", async () => {
+  if (shuttingDown)
+    return;
+  shuttingDown = true;
+  await router.destroyAll();
+  router.stop();
+  process.exit(0);
+});