@caspian2026/agent-sdk 0.0.8 → 0.0.11

package/dist/gateway/index.js

@@ -0,0 +1,430 @@
+// 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";
+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;
+  pendingReady = new Map;
+  pendingUpdate = new Map;
+  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)) {
+      process.stderr.write(`[SessionRouter] Session already exists, destroying old: ${sessionKey}
+`);
+      await this.destroy(sessionKey);
+    }
+    if (this.sessions.size >= this.maxSessions) {
+      process.stderr.write(`[SessionRouter] Max sessions reached, evicting LRU session
+`);
+      this.evictLRU();
+    }
+    process.stderr.write(`[SessionRouter] Creating worker for session: ${sessionKey}
+`);
+    const worker = new Worker(this.workerPath, {
+      workerData: config
+    });
+    const entry = {
+      sessionKey,
+      worker,
+      sessionId: null,
+      lastActive: new Date,
+      created: new Date,
+      destroyed: false
+    };
+    worker.on("message", (msg) => {
+      if (msg.type === "ready") {
+        entry.sessionId = msg.session_id;
+        this.pendingReady.get(sessionKey)?.resolve();
+        this.pendingReady.delete(sessionKey);
+      }
+      if (msg.type === "updated") {
+        this.pendingUpdate.get(sessionKey)?.resolve();
+        this.pendingUpdate.delete(sessionKey);
+      }
+      entry.lastActive = new Date;
+      this.onWorkerMessage(sessionKey, msg);
+    });
+    worker.on("exit", (code) => {
+      this.sessions.delete(sessionKey);
+      if (!entry.destroyed) {
+        process.stderr.write(`[SessionRouter] Worker exited unexpectedly for session: ${sessionKey}, code: ${code}
+`);
+        this.onWorkerExit(sessionKey, code);
+      } else {
+        process.stderr.write(`[SessionRouter] Worker destroyed for session: ${sessionKey}, code: ${code}
+`);
+      }
+    });
+    worker.on("error", (err) => {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[SessionRouter] Worker thread error for session: ${sessionKey} - ${errMsg}
+`);
+      this.onWorkerMessage(sessionKey, {
+        type: "error",
+        session_key: sessionKey,
+        error: `Worker thread error: ${errMsg}`
+      });
+    });
+    this.sessions.set(sessionKey, entry);
+  }
+  get(sessionKey) {
+    return this.sessions.get(sessionKey);
+  }
+  has(sessionKey) {
+    return this.sessions.has(sessionKey);
+  }
+  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;
+    process.stderr.write(`[SessionRouter] Destroying worker for session: ${sessionKey}
+`);
+    this.pendingReady.get(sessionKey)?.reject(new Error("Session destroyed"));
+    this.pendingReady.delete(sessionKey);
+    this.pendingUpdate.get(sessionKey)?.reject(new Error("Session destroyed"));
+    this.pendingUpdate.delete(sessionKey);
+    this.sessions.delete(sessionKey);
+    entry.destroyed = true;
+    entry.worker.postMessage({ type: "destroy" });
+    const exitPromise = new Promise((resolve) => {
+      entry.worker.once("exit", () => resolve());
+    });
+    const timeout = new Promise((resolve) => setTimeout(resolve, 2000));
+    await Promise.race([exitPromise, timeout]);
+    await entry.worker.terminate();
+  }
+  async destroyAll() {
+    const keys = [...this.sessions.keys()];
+    await Promise.all(keys.map((k) => this.destroy(k)));
+  }
+  waitForReady(sessionKey, timeoutMs = 30000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingReady.delete(sessionKey);
+        reject(new Error(`Session creation timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      this.pendingReady.set(sessionKey, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+    });
+  }
+  waitForUpdate(sessionKey, timeoutMs = 15000) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingUpdate.delete(sessionKey);
+        reject(new Error(`Session update timed out after ${timeoutMs / 1000}s`));
+      }, timeoutMs);
+      this.pendingUpdate.set(sessionKey, {
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (err) => {
+          clearTimeout(timer);
+          reject(err);
+        }
+      });
+    });
+  }
+  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 (this.pendingReady.has(key))
+        continue;
+      if (now - entry.lastActive.getTime() > this.idleTtlMs) {
+        toEvict.push(key);
+      }
+    }
+    if (toEvict.length > 0) {
+      process.stderr.write(`[SessionRouter] Evicting ${toEvict.length} idle session(s): ${toEvict.join(", ")}
+`);
+    }
+    for (const key of toEvict) {
+      this.destroy(key).catch(() => {});
+    }
+  }
+  evictLRU() {
+    let oldest = null;
+    let oldestTime = Infinity;
+    for (const [key, entry] of this.sessions) {
+      if (this.pendingReady.has(key))
+        continue;
+      if (entry.lastActive.getTime() < oldestTime) {
+        oldestTime = entry.lastActive.getTime();
+        oldest = key;
+      }
+    }
+    if (oldest) {
+      process.stderr.write(`[SessionRouter] Evicting LRU session: ${oldest}
+`);
+      this.destroy(oldest).catch(() => {});
+    }
+  }
+}
+
+// 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;
+var lastWorkerErrors = new Map;
+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":
+        process.stderr.write(`[Gateway] Session ready: ${sessionKey}, sessionId: ${msg.session_id}
+`);
+        notify({ method: "session.ready", params: { session_key: msg.session_key, session_id: msg.session_id, state_session_id: msg.state_session_id } });
+        break;
+      case "stream":
+        notify({ method: "session.stream", params: { session_key: msg.session_key, data: msg.data } });
+        break;
+      case "complete":
+        process.stderr.write(`[Gateway] Session complete: ${sessionKey}, sessionId: ${msg.session_id}
+`);
+        notify({ method: "session.complete", params: { session_key: msg.session_key, session_id: msg.session_id } });
+        break;
+      case "error":
+        process.stderr.write(`[Gateway] Session error: ${sessionKey} - ${msg.error}
+`);
+        lastWorkerErrors.set(sessionKey, msg.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;
+      case "updated":
+        process.stderr.write(`[Gateway] Session updated: ${sessionKey}
+`);
+        break;
+    }
+  },
+  onWorkerExit: (sessionKey, code) => {
+    const lastError = lastWorkerErrors.get(sessionKey);
+    const enrichedError = lastError ? `Worker exited with code ${code}. Last error: ${lastError}` : `Worker exited with code ${code}`;
+    process.stderr.write(`[Gateway] Worker exited: ${sessionKey}, code: ${code}. Last error: ${lastError || "none"}
+`);
+    notify({ method: "session.error", params: { session_key: sessionKey, error: enrichedError } });
+    lastWorkerErrors.delete(sessionKey);
+  }
+});
+async function handleRequest(req) {
+  switch (req.method) {
+    case "session.create": {
+      const { session_key, config, permission, env, resume } = req.params;
+      const workerConfig = {
+        sessionKey: session_key,
+        session: config,
+        permission,
+        env,
+        resume
+      };
+      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.update": {
+      const { session_key, config } = req.params;
+      if (!router.has(session_key)) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: `Session not found: ${session_key}` }
+        });
+        break;
+      }
+      try {
+        const updatePromise = router.waitForUpdate(session_key);
+        router.send(session_key, { type: "update", config });
+        await updatePromise;
+        notify({ method: "session.updated", params: { session_key } });
+      } catch (err) {
+        notify({
+          method: "session.error",
+          params: { session_key, error: err instanceof Error ? err.message : String(err) }
+        });
+      }
+      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);
+});