noumen 0.2.0 → 0.4.0

package/dist/server/index.js

@@ -2,13 +2,209 @@ import "../chunk-DGUM43GV.js";
 
 // src/server/index.ts
 import { createServer as createHttpServer } from "http";
+
+// src/server/session-state.ts
 import { randomUUID } from "crypto";
+var DEFAULT_PENDING_TIMEOUT_MS = 12e4;
+function createSessionState(sessions, requestedId, overrides) {
+  if (requestedId && sessions.has(requestedId)) {
+    throw new Error(`Session ${requestedId} already exists`);
+  }
+  const sessionId = requestedId ?? randomUUID();
+  const session = {
+    id: sessionId,
+    abortController: new AbortController(),
+    pendingPermission: null,
+    pendingInput: null,
+    pendingPermissionTimer: null,
+    pendingInputTimer: null,
+    lastActivity: Date.now(),
+    sseResponse: null,
+    sseKeepaliveTimer: null,
+    eventBuffer: [],
+    sequenceNum: 0,
+    done: false,
+    cwd: overrides.cwd
+  };
+  sessions.set(sessionId, session);
+  return session;
+}
+function destroySession(sessions, session) {
+  session.abortController.abort();
+  clearSseKeepalive(session);
+  clearPendingPermissionTimer(session);
+  clearPendingInputTimer(session);
+  if (session.pendingPermission) {
+    session.pendingPermission.reject(new Error("Session aborted"));
+    session.pendingPermission = null;
+  }
+  if (session.pendingInput) {
+    session.pendingInput.reject(new Error("Session aborted"));
+    session.pendingInput = null;
+  }
+  if (session.sseResponse) {
+    session.sseResponse.end();
+    session.sseResponse = null;
+  }
+  sessions.delete(session.id);
+}
+function reapIdleSessions(sessions, timeoutMs) {
+  if (!timeoutMs) return;
+  const now = Date.now();
+  for (const session of sessions.values()) {
+    if (now - session.lastActivity > timeoutMs) {
+      destroySession(sessions, session);
+    }
+  }
+}
+function bridgePermission(sessions, sessionId, timeoutMs) {
+  const session = sessions.get(sessionId);
+  if (!session) return Promise.reject(new Error("Session not found"));
+  return new Promise((resolve, reject) => {
+    session.pendingPermission = { resolve, reject };
+    session.pendingPermissionTimer = setTimeout(() => {
+      session.pendingPermissionTimer = null;
+      if (session.pendingPermission) {
+        session.pendingPermission.reject(new Error("Permission request timed out"));
+        session.pendingPermission = null;
+      }
+    }, timeoutMs);
+  });
+}
+function bridgeUserInput(sessions, sessionId, timeoutMs) {
+  const session = sessions.get(sessionId);
+  if (!session) return Promise.reject(new Error("Session not found"));
+  return new Promise((resolve, reject) => {
+    session.pendingInput = { resolve, reject };
+    session.pendingInputTimer = setTimeout(() => {
+      session.pendingInputTimer = null;
+      if (session.pendingInput) {
+        session.pendingInput.reject(new Error("User input request timed out"));
+        session.pendingInput = null;
+      }
+    }, timeoutMs);
+  });
+}
+function clearPendingPermissionTimer(session) {
+  if (session.pendingPermissionTimer) {
+    clearTimeout(session.pendingPermissionTimer);
+    session.pendingPermissionTimer = null;
+  }
+}
+function clearPendingInputTimer(session) {
+  if (session.pendingInputTimer) {
+    clearTimeout(session.pendingInputTimer);
+    session.pendingInputTimer = null;
+  }
+}
+function clearSseKeepalive(session) {
+  if (session.sseKeepaliveTimer) {
+    clearInterval(session.sseKeepaliveTimer);
+    session.sseKeepaliveTimer = null;
+  }
+}
+
+// src/server/event-buffer.ts
+var MAX_EVENT_BUFFER = 1e3;
+function serializeEvent(event) {
+  if (event.type === "error") {
+    return { type: "error", error: { message: event.error.message, name: event.error.name } };
+  }
+  if (event.type === "retry_exhausted") {
+    return { ...event, error: { message: event.error.message, name: event.error.name } };
+  }
+  if (event.type === "retry_attempt") {
+    return { ...event, error: { message: event.error.message, name: event.error.name } };
+  }
+  return event;
+}
+function pushEvent(session, event) {
+  session.sequenceNum++;
+  const seq = session.sequenceNum;
+  if (session.eventBuffer.length >= MAX_EVENT_BUFFER) {
+    session.eventBuffer.shift();
+  }
+  session.eventBuffer.push({ seq, event });
+  if (session.sseResponse) {
+    writeSseEventRaw(session.sseResponse, seq, serializeEvent(event));
+  }
+}
+function getBufferedEventsAfter(buffer, afterSeq) {
+  if (!afterSeq) return [...buffer];
+  return buffer.filter((e) => e.seq > afterSeq);
+}
+function writeSseEventRaw(res, seq, data) {
+  res.write(`id: ${seq}
+data: ${JSON.stringify(data)}
+
+`);
+}
+
+// src/server/ws-dispatch.ts
+function parseWsMessage(raw) {
+  try {
+    return JSON.parse(typeof raw === "string" ? raw : raw.toString());
+  } catch {
+    return null;
+  }
+}
+async function handleWsMessage(msg, ctx, callbacks) {
+  const msgType = msg.type;
+  if (msgType === "run") {
+    if (ctx.maxSessions && ctx.currentSessionCount >= ctx.maxSessions) {
+      return { type: "error", error: "Maximum sessions reached" };
+    }
+    if (typeof msg.prompt !== "string" || !msg.prompt.trim()) {
+      return { type: "error", error: "Missing or empty prompt" };
+    }
+    try {
+      const sessionId = await callbacks.onRun(
+        msg.prompt,
+        msg.sessionId
+      );
+      return { type: "session_created", sessionId };
+    } catch (err) {
+      return { type: "error", error: err instanceof Error ? err.message : String(err) };
+    }
+  }
+  if (msgType === "message") {
+    if (typeof msg.prompt !== "string" || !msg.prompt.trim()) {
+      return { type: "error", error: "Missing or empty prompt" };
+    }
+    const sessionId = msg.sessionId;
+    if (!sessionId) {
+      return { type: "error", error: "Missing sessionId" };
+    }
+    callbacks.onMessage(sessionId, msg.prompt);
+    return { type: "ok" };
+  }
+  if (msgType === "permission_response") {
+    const sessionId = msg.sessionId;
+    const { sessionId: _sid, type: _type, ...response } = msg;
+    callbacks.onPermissionResponse(sessionId, response);
+    return { type: "ok" };
+  }
+  if (msgType === "input_response") {
+    const sessionId = msg.sessionId;
+    callbacks.onInputResponse(sessionId, msg.answer ?? "");
+    return { type: "ok" };
+  }
+  if (msgType === "abort") {
+    const sessionId = msg.sessionId;
+    if (sessionId) callbacks.onAbort(sessionId);
+    return { type: "ok" };
+  }
+  return { type: "ok" };
+}
+function wsSend(ws, data) {
+  if (ws.readyState === 1) ws.send(JSON.stringify(data));
+}
+
+// src/server/index.ts
 var SSE_KEEPALIVE_INTERVAL_MS = 15e3;
 var MAX_BODY_BYTES = 1048576;
-var MAX_EVENT_BUFFER = 1e3;
-var DEFAULT_PENDING_TIMEOUT_MS = 12e4;
-var WS_PING_INTERVAL_MS = 3e4;
 var SHUTDOWN_DRAIN_MS = 500;
+var WS_PING_INTERVAL_MS = 3e4;
 var NoumenServer = class {
   code;
   options;
@@ -27,7 +223,7 @@ var NoumenServer = class {
     }
     this.ensureIdleReaper();
     return new Promise((resolve, reject) => {
-      const host = this.options.host ?? "0.0.0.0";
+      const host = this.options.host ?? "127.0.0.1";
       this.httpServer.listen(this.options.port, host, () => resolve());
       this.httpServer.once("error", reject);
     });
@@ -42,7 +238,7 @@ var NoumenServer = class {
     }
     await new Promise((resolve) => setTimeout(resolve, SHUTDOWN_DRAIN_MS));
     for (const session of this.sessions.values()) {
-      this.destroySession(session);
+      destroySession(this.sessions, session);
     }
     if (this.wss) {
       await new Promise((resolve) => this.wss.close(() => resolve()));
@@ -102,7 +298,7 @@ var NoumenServer = class {
     if (this.idleReaperStarted || !this.options.idleTimeoutMs) return;
     this.idleReaperStarted = true;
     const interval = Math.max(this.options.idleTimeoutMs / 2, 1e3);
-    this.idleTimer = setInterval(() => this.reapIdleSessions(), interval);
+    this.idleTimer = setInterval(() => reapIdleSessions(this.sessions, this.options.idleTimeoutMs), interval);
     this.idleTimer.unref();
   }
   // -------------------------------------------------------------------------
@@ -175,7 +371,7 @@ var NoumenServer = class {
       return jsonResponse(res, 429, { error: "Maximum sessions reached" });
     }
     const overrides = await this.resolveConnectionOverrides(req);
-    const session = this.createSessionState(requestedId, overrides);
+    const session = createSessionState(this.sessions, requestedId, overrides);
     this.runAgentSse(session, prompt, false);
     jsonResponse(res, 201, {
       sessionId: session.id,
@@ -197,7 +393,7 @@ var NoumenServer = class {
       const oldRes = session.sseResponse;
       writeSseEventRaw(oldRes, session.sequenceNum + 1, { type: "subscriber_replaced" });
       oldRes.end();
-      this.clearSseKeepalive(session);
+      clearSseKeepalive(session);
       session.sseResponse = null;
     }
     res.writeHead(200, {
@@ -208,8 +404,8 @@ var NoumenServer = class {
     });
     const lastEventId = req.headers["last-event-id"];
     const resumeAfterSeq = lastEventId ? parseInt(lastEventId, 10) : 0;
-    for (const buffered of session.eventBuffer) {
-      if (resumeAfterSeq && buffered.seq <= resumeAfterSeq) continue;
+    const eventsToReplay = getBufferedEventsAfter(session.eventBuffer, resumeAfterSeq);
+    for (const buffered of eventsToReplay) {
       writeSseEventRaw(res, buffered.seq, serializeEvent(buffered.event));
     }
     session.eventBuffer = [];
@@ -217,7 +413,7 @@ var NoumenServer = class {
     this.startSseKeepalive(session);
     res.on("close", () => {
       if (session.sseResponse === res) {
-        this.clearSseKeepalive(session);
+        clearSseKeepalive(session);
         session.sseResponse = null;
       }
     });
@@ -227,7 +423,7 @@ var NoumenServer = class {
     if (!session) return jsonResponse(res, 404, { error: "Session not found" });
     if (!session.pendingPermission) return jsonResponse(res, 409, { error: "No pending permission request" });
     const body = await readBody(req);
-    this.clearPendingPermissionTimer(session);
+    clearPendingPermissionTimer(session);
     session.pendingPermission.resolve(body);
     session.pendingPermission = null;
     jsonResponse(res, 200, { ok: true });
@@ -240,7 +436,7 @@ var NoumenServer = class {
     if (typeof body.answer !== "string") {
       return jsonResponse(res, 400, { error: "Missing required field: answer" });
     }
-    this.clearPendingInputTimer(session);
+    clearPendingInputTimer(session);
     session.pendingInput.resolve(body.answer);
     session.pendingInput = null;
     jsonResponse(res, 200, { ok: true });
@@ -261,7 +457,7 @@ var NoumenServer = class {
   handleDeleteSession(sessionId, res) {
     const session = this.sessions.get(sessionId);
     if (!session) return jsonResponse(res, 404, { error: "Session not found" });
-    this.destroySession(session);
+    destroySession(this.sessions, session);
     jsonResponse(res, 200, { ok: true });
   }
   // -------------------------------------------------------------------------
@@ -300,10 +496,63 @@ var NoumenServer = class {
     ws.on("pong", () => {
       pongReceived = true;
     });
+    const callbacks = {
+      onRun: async (prompt, requestedSessionId) => {
+        const overrides = await this.resolveConnectionOverrides(req);
+        const session = createSessionState(this.sessions, requestedSessionId, overrides);
+        wsSessions.add(session.id);
+        this.runAgentWs(session, prompt, ws, false);
+        return session.id;
+      },
+      onMessage: (sessionId, prompt) => {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          wsSend(ws, { type: "error", error: "Session not found" });
+          return;
+        }
+        if (!session.done) {
+          wsSend(ws, { type: "error", error: "Session is still running" });
+          return;
+        }
+        session.done = false;
+        session.abortController = new AbortController();
+        this.runAgentWs(session, prompt, ws, true);
+      },
+      onPermissionResponse: (sessionId, response) => {
+        const session = this.sessions.get(sessionId);
+        if (!session?.pendingPermission) return;
+        clearPendingPermissionTimer(session);
+        session.pendingPermission.resolve(response);
+        session.pendingPermission = null;
+      },
+      onInputResponse: (sessionId, answer) => {
+        const session = this.sessions.get(sessionId);
+        if (!session?.pendingInput) return;
+        clearPendingInputTimer(session);
+        session.pendingInput.resolve(answer);
+        session.pendingInput = null;
+      },
+      onAbort: (sessionId) => {
+        const session = this.sessions.get(sessionId);
+        if (session) destroySession(this.sessions, session);
+      }
+    };
     ws.on("message", async (raw) => {
       try {
-        const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString());
-        await this.handleWsMessage(ws, msg, wsSessions, req);
+        const msg = parseWsMessage(raw);
+        if (!msg) {
+          wsSend(ws, { type: "error", error: "Invalid JSON" });
+          return;
+        }
+        const result = await handleWsMessage(msg, {
+          maxSessions: this.options.maxSessions,
+          currentSessionCount: this.sessions.size
+        }, callbacks);
+        if (result.type === "error") {
+          wsSend(ws, { type: "error", error: result.error });
+        } else if (result.type === "session_created") {
+          wsSend(ws, { type: "session_created", sessionId: result.sessionId });
+        }
       } catch (err) {
         wsSend(ws, { type: "error", error: String(err) });
       }
@@ -312,106 +561,36 @@ var NoumenServer = class {
       clearInterval(pingTimer);
       for (const sid of wsSessions) {
         const session = this.sessions.get(sid);
-        if (session) this.destroySession(session);
+        if (session) destroySession(this.sessions, session);
       }
     });
     ws.on("error", () => {
       clearInterval(pingTimer);
     });
   }
-  async handleWsMessage(ws, msg, wsSessions, req) {
-    const msgType = msg.type;
-    if (msgType === "run") {
-      if (this.options.maxSessions && this.sessions.size >= this.options.maxSessions) {
-        wsSend(ws, { type: "error", error: "Maximum sessions reached" });
-        return;
-      }
-      const overrides = await this.resolveConnectionOverrides(req);
-      const session = this.createSessionState(msg.sessionId, overrides);
-      wsSessions.add(session.id);
-      wsSend(ws, { type: "session_created", sessionId: session.id });
-      this.runAgentWs(session, msg.prompt, ws, false);
-      return;
-    }
-    if (msgType === "message") {
-      const session = this.sessions.get(msg.sessionId);
-      if (!session) {
-        wsSend(ws, { type: "error", error: "Session not found" });
-        return;
-      }
-      if (!session.done) {
-        wsSend(ws, { type: "error", error: "Session is still running" });
-        return;
-      }
-      session.done = false;
-      session.abortController = new AbortController();
-      this.runAgentWs(session, msg.prompt, ws, true);
-      return;
-    }
-    if (msgType === "permission_response") {
-      const session = this.sessions.get(msg.sessionId);
-      if (!session?.pendingPermission) return;
-      this.clearPendingPermissionTimer(session);
-      const { sessionId: _sid, type: _type, ...response } = msg;
-      session.pendingPermission.resolve(response);
-      session.pendingPermission = null;
-      return;
-    }
-    if (msgType === "input_response") {
-      const session = this.sessions.get(msg.sessionId);
-      if (!session?.pendingInput) return;
-      this.clearPendingInputTimer(session);
-      session.pendingInput.resolve(msg.answer ?? "");
-      session.pendingInput = null;
-      return;
-    }
-    if (msgType === "abort") {
-      const session = this.sessions.get(msg.sessionId);
-      if (session) this.destroySession(session);
-    }
-  }
   // -------------------------------------------------------------------------
-  // Session management
+  // Agent runners
   // -------------------------------------------------------------------------
-  createSessionState(requestedId, overrides) {
-    const sessionId = requestedId ?? randomUUID();
-    const session = {
-      id: sessionId,
-      abortController: new AbortController(),
-      pendingPermission: null,
-      pendingInput: null,
-      pendingPermissionTimer: null,
-      pendingInputTimer: null,
-      lastActivity: Date.now(),
-      sseResponse: null,
-      sseKeepaliveTimer: null,
-      eventBuffer: [],
-      sequenceNum: 0,
-      done: false,
-      cwd: overrides.cwd
-    };
-    this.sessions.set(sessionId, session);
-    return session;
-  }
-  makeThread(session, resume) {
+  async makeThread(session, resume) {
+    const timeoutMs = this.options.pendingTimeoutMs ?? DEFAULT_PENDING_TIMEOUT_MS;
     const handlers = {
       cwd: session.cwd,
-      permissionHandler: (req) => this.bridgePermission(session.id, req),
-      userInputHandler: (q) => this.bridgeUserInput(session.id, q)
+      permissionHandler: (_req) => bridgePermission(this.sessions, session.id, timeoutMs),
+      userInputHandler: (_q) => bridgeUserInput(this.sessions, session.id, timeoutMs)
     };
     return resume ? this.code.resumeThread(session.id, handlers) : this.code.createThread({ sessionId: session.id, ...handlers });
   }
   runAgentSse(session, prompt, resume) {
     const run = async () => {
       try {
-        const thread = this.makeThread(session, resume);
+        const thread = await this.makeThread(session, resume);
         for await (const event of thread.run(prompt, { signal: session.abortController.signal })) {
-          this.emitSseEvent(session, event);
+          pushEvent(session, event);
           session.lastActivity = Date.now();
         }
       } catch (err) {
         if (err.name !== "AbortError") {
-          this.emitSseEvent(session, {
+          pushEvent(session, {
             type: "error",
             error: err instanceof Error ? err : new Error(String(err))
           });
@@ -425,7 +604,7 @@ var NoumenServer = class {
   runAgentWs(session, prompt, ws, resume) {
     const run = async () => {
       try {
-        const thread = this.makeThread(session, resume);
+        const thread = await this.makeThread(session, resume);
         for await (const event of thread.run(prompt, { signal: session.abortController.signal })) {
           session.sequenceNum++;
           wsSend(ws, { ...serializeEvent(event), sessionId: session.id, seq: session.sequenceNum });
@@ -441,50 +620,8 @@ var NoumenServer = class {
     };
     run().catch((err) => this.options.onError?.(err instanceof Error ? err : new Error(String(err))));
   }
-  emitSseEvent(session, event) {
-    session.sequenceNum++;
-    const seq = session.sequenceNum;
-    if (session.sseResponse) {
-      writeSseEventRaw(session.sseResponse, seq, serializeEvent(event));
-    } else {
-      if (session.eventBuffer.length >= MAX_EVENT_BUFFER) {
-        session.eventBuffer.shift();
-      }
-      session.eventBuffer.push({ seq, event });
-    }
-  }
-  bridgePermission(sessionId, _request) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return Promise.reject(new Error("Session not found"));
-    const timeoutMs = this.options.pendingTimeoutMs ?? DEFAULT_PENDING_TIMEOUT_MS;
-    return new Promise((resolve, reject) => {
-      session.pendingPermission = { resolve, reject };
-      session.pendingPermissionTimer = setTimeout(() => {
-        session.pendingPermissionTimer = null;
-        if (session.pendingPermission) {
-          session.pendingPermission.reject(new Error("Permission request timed out"));
-          session.pendingPermission = null;
-        }
-      }, timeoutMs);
-    });
-  }
-  bridgeUserInput(sessionId, _question) {
-    const session = this.sessions.get(sessionId);
-    if (!session) return Promise.reject(new Error("Session not found"));
-    const timeoutMs = this.options.pendingTimeoutMs ?? DEFAULT_PENDING_TIMEOUT_MS;
-    return new Promise((resolve, reject) => {
-      session.pendingInput = { resolve, reject };
-      session.pendingInputTimer = setTimeout(() => {
-        session.pendingInputTimer = null;
-        if (session.pendingInput) {
-          session.pendingInput.reject(new Error("User input request timed out"));
-          session.pendingInput = null;
-        }
-      }, timeoutMs);
-    });
-  }
   startSseKeepalive(session) {
-    this.clearSseKeepalive(session);
+    clearSseKeepalive(session);
     session.sseKeepaliveTimer = setInterval(() => {
       if (session.sseResponse && !session.sseResponse.destroyed) {
         session.sseResponse.write(":keepalive\n\n");
@@ -492,53 +629,6 @@ var NoumenServer = class {
     }, SSE_KEEPALIVE_INTERVAL_MS);
     session.sseKeepaliveTimer.unref();
   }
-  clearSseKeepalive(session) {
-    if (session.sseKeepaliveTimer) {
-      clearInterval(session.sseKeepaliveTimer);
-      session.sseKeepaliveTimer = null;
-    }
-  }
-  clearPendingPermissionTimer(session) {
-    if (session.pendingPermissionTimer) {
-      clearTimeout(session.pendingPermissionTimer);
-      session.pendingPermissionTimer = null;
-    }
-  }
-  clearPendingInputTimer(session) {
-    if (session.pendingInputTimer) {
-      clearTimeout(session.pendingInputTimer);
-      session.pendingInputTimer = null;
-    }
-  }
-  destroySession(session) {
-    session.abortController.abort();
-    this.clearSseKeepalive(session);
-    this.clearPendingPermissionTimer(session);
-    this.clearPendingInputTimer(session);
-    if (session.pendingPermission) {
-      session.pendingPermission.reject(new Error("Session aborted"));
-      session.pendingPermission = null;
-    }
-    if (session.pendingInput) {
-      session.pendingInput.reject(new Error("Session aborted"));
-      session.pendingInput = null;
-    }
-    if (session.sseResponse) {
-      session.sseResponse.end();
-      session.sseResponse = null;
-    }
-    this.sessions.delete(session.id);
-  }
-  reapIdleSessions() {
-    const timeout = this.options.idleTimeoutMs;
-    if (!timeout) return;
-    const now = Date.now();
-    for (const session of this.sessions.values()) {
-      if (now - session.lastActivity > timeout) {
-        this.destroySession(session);
-      }
-    }
-  }
   async resolveConnectionOverrides(req) {
     if (!this.options.onConnection) return {};
     const auth = await this.authenticate(req) ?? {};
@@ -567,24 +657,6 @@ function jsonResponse(res, status, body) {
   });
   res.end(json);
 }
-function serializeEvent(event) {
-  if (event.type === "error") {
-    return { type: "error", error: { message: event.error.message, name: event.error.name } };
-  }
-  if (event.type === "retry_exhausted") {
-    return { ...event, error: { message: event.error.message, name: event.error.name } };
-  }
-  if (event.type === "retry_attempt") {
-    return { ...event, error: { message: event.error.message, name: event.error.name } };
-  }
-  return event;
-}
-function writeSseEventRaw(res, seq, data) {
-  res.write(`id: ${seq}
-data: ${JSON.stringify(data)}
-
-`);
-}
 function readBody(req) {
   return new Promise((resolve, reject) => {
     let totalBytes = 0;
@@ -615,9 +687,6 @@ function readBody(req) {
     });
   });
 }
-function wsSend(ws, data) {
-  if (ws.readyState === 1) ws.send(JSON.stringify(data));
-}
 export {
   NoumenServer,
   createRequestHandler,