chatroom-cli 1.16.4 → 1.16.6

package/dist/index.js

@@ -15948,6 +15948,194 @@ var init_state_recovery = __esm(() => {
   init_api3();
 });
 
+// src/infrastructure/local-api/routes/identity.ts
+async function handleIdentity(_req, ctx) {
+  const identity = {
+    machineId: ctx.machineId,
+    hostname: ctx.config?.hostname ?? "unknown",
+    os: ctx.config?.os ?? "unknown",
+    version: getVersion()
+  };
+  return {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(identity)
+  };
+}
+var identityRoute;
+var init_identity = __esm(() => {
+  init_version();
+  identityRoute = {
+    method: "GET",
+    path: "/api/identity",
+    handler: handleIdentity
+  };
+});
+
+// src/infrastructure/local-api/cors.ts
+function applyCorsHeaders(response) {
+  return {
+    ...response,
+    headers: {
+      ...CORS_HEADERS,
+      ...response.headers ?? {}
+    }
+  };
+}
+function buildPreflightResponse() {
+  return {
+    status: 204,
+    headers: CORS_HEADERS,
+    body: ""
+  };
+}
+var CORS_HEADERS;
+var init_cors = __esm(() => {
+  CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type"
+  };
+});
+
+// src/infrastructure/local-api/router.ts
+class LocalApiRouter {
+  routes = [];
+  registerRoute(route) {
+    this.routes.push(route);
+  }
+  async handleRequest(req, ctx) {
+    if (req.method === "OPTIONS") {
+      return buildPreflightResponse();
+    }
+    const pathname = req.url.split("?")[0] ?? req.url;
+    const route = this.routes.find((r) => r.method === req.method && r.path === pathname);
+    let response;
+    if (route) {
+      try {
+        response = await route.handler(req, ctx);
+      } catch (error) {
+        response = {
+          status: 500,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ error: "Internal server error" })
+        };
+      }
+    } else {
+      response = {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: "Not found" })
+      };
+    }
+    return applyCorsHeaders(response);
+  }
+}
+var init_router = __esm(() => {
+  init_cors();
+});
+
+// src/infrastructure/local-api/server.ts
+import { createServer } from "node:http";
+function readBody(req) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf-8")));
+    req.on("error", reject);
+  });
+}
+async function normalizeRequest(req) {
+  const body = await readBody(req);
+  const headers = {};
+  for (const [key, value] of Object.entries(req.headers)) {
+    if (typeof value === "string") {
+      headers[key] = value;
+    } else if (Array.isArray(value)) {
+      headers[key] = value.join(", ");
+    }
+  }
+  return {
+    method: (req.method ?? "GET").toUpperCase(),
+    url: req.url ?? "/",
+    headers,
+    body: body || undefined
+  };
+}
+function writeResponse(res, status, headers, body) {
+  res.writeHead(status, headers);
+  res.end(body);
+}
+function createRouter() {
+  const router = new LocalApiRouter;
+  router.registerRoute(identityRoute);
+  return router;
+}
+function resolvePort() {
+  const envPort = process.env.CHATROOM_LOCAL_API_PORT;
+  if (envPort) {
+    const parsed = parseInt(envPort, 10);
+    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) {
+      return parsed;
+    }
+  }
+  return LOCAL_API_PORT;
+}
+function ts() {
+  return new Date().toISOString().replace("T", " ").slice(0, 19);
+}
+async function startLocalApi(ctx, port = resolvePort()) {
+  const router = createRouter();
+  const server = createServer(async (req, res) => {
+    try {
+      const localReq = await normalizeRequest(req);
+      const localRes = await router.handleRequest(localReq, ctx);
+      writeResponse(res, localRes.status, { "Content-Type": "application/json", ...localRes.headers ?? {} }, localRes.body);
+    } catch {
+      writeResponse(res, 500, { "Content-Type": "application/json" }, JSON.stringify({ error: "Internal server error" }));
+    }
+  });
+  await new Promise((resolve2) => {
+    server.listen(port, "127.0.0.1", () => {
+      console.log(`[${ts()}] \uD83C\uDF10 Local API started on http://localhost:${port}`);
+      resolve2();
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        console.warn(`[${ts()}] ⚠️  Local API port ${port} already in use — skipping local API`);
+      } else {
+        console.warn(`[${ts()}] ⚠️  Local API failed to start: ${err.message}`);
+      }
+      resolve2();
+    });
+  });
+  const stop = () => new Promise((resolve2, reject) => {
+    if (!server.listening) {
+      resolve2();
+      return;
+    }
+    server.close((err) => {
+      if (err) {
+        reject(err);
+      } else {
+        console.log(`[${ts()}] \uD83C\uDF10 Local API stopped`);
+        resolve2();
+      }
+    });
+  });
+  return { stop };
+}
+var LOCAL_API_PORT = 19847;
+var init_server2 = __esm(() => {
+  init_identity();
+  init_router();
+});
+
+// src/infrastructure/local-api/index.ts
+var init_local_api = __esm(() => {
+  init_server2();
+});
+
 // src/events/daemon/event-bus.ts
 class DaemonEventBus {
   listeners = new Map;
@@ -15990,15 +16178,15 @@ function onAgentExited(ctx, payload) {
 
 // src/events/daemon/agent/on-agent-started.ts
 function onAgentStarted(ctx, payload) {
-  const ts = formatTimestamp();
-  console.log(`[${ts}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
+  const ts2 = formatTimestamp();
+  console.log(`[${ts2}] \uD83D\uDFE2 Agent started: ${payload.role} (PID: ${payload.pid}, harness: ${payload.harness})`);
 }
 var init_on_agent_started = () => {};
 
 // src/events/daemon/agent/on-agent-stopped.ts
 function onAgentStopped(ctx, payload) {
-  const ts = formatTimestamp();
-  console.log(`[${ts}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
+  const ts2 = formatTimestamp();
+  console.log(`[${ts2}] \uD83D\uDD34 Agent stopped: ${payload.role} (PID: ${payload.pid})`);
 }
 var init_on_agent_stopped = () => {};
 
@@ -16127,7 +16315,7 @@ class CrashLoopTracker {
     const key = `${chatroomId}:${role.toLowerCase()}`;
     const windowStart = now - CRASH_LOOP_WINDOW_MS;
     const raw = this.history.get(key) ?? [];
-    const recent = raw.filter((ts) => ts >= windowStart);
+    const recent = raw.filter((ts2) => ts2 >= windowStart);
     recent.push(now);
     this.history.set(key, recent);
     const restartCount = recent.length;
@@ -16142,7 +16330,7 @@ class CrashLoopTracker {
     const key = `${chatroomId}:${role.toLowerCase()}`;
     const windowStart = now - CRASH_LOOP_WINDOW_MS;
     const raw = this.history.get(key) ?? [];
-    return raw.filter((ts) => ts >= windowStart).length;
+    return raw.filter((ts2) => ts2 >= windowStart).length;
   }
 }
 var CRASH_LOOP_MAX_RESTARTS = 3, CRASH_LOOP_WINDOW_MS;
@@ -16785,6 +16973,8 @@ async function initDaemon() {
       registerEventListeners(ctx);
       logStartup(ctx, availableModels);
       await recoverState(ctx);
+      const localApiHandle = await startLocalApi(ctx);
+      ctx.stopLocalApi = localApiHandle.stop;
       return ctx;
     } catch (error) {
       if (isNetworkError(error)) {
@@ -16802,6 +16992,7 @@ var CONNECTION_RETRY_INTERVAL_MS = 1000;
 var init_init2 = __esm(() => {
   init_state_recovery();
   init_api3();
+  init_local_api();
   init_register_listeners();
   init_storage();
   init_client2();
@@ -16872,16 +17063,16 @@ async function refreshModels(ctx) {
 }
 function evictStaleDedupEntries(processedCommandIds, processedPingIds, processedGitRefreshIds) {
   const evictBefore = Date.now() - AGENT_REQUEST_DEADLINE_MS;
-  for (const [id, ts] of processedCommandIds) {
-    if (ts < evictBefore)
+  for (const [id, ts2] of processedCommandIds) {
+    if (ts2 < evictBefore)
       processedCommandIds.delete(id);
   }
-  for (const [id, ts] of processedPingIds) {
-    if (ts < evictBefore)
+  for (const [id, ts2] of processedPingIds) {
+    if (ts2 < evictBefore)
       processedPingIds.delete(id);
   }
-  for (const [id, ts] of processedGitRefreshIds) {
-    if (ts < evictBefore)
+  for (const [id, ts2] of processedGitRefreshIds) {
+    if (ts2 < evictBefore)
       processedGitRefreshIds.delete(id);
   }
 }
@@ -16943,6 +17134,9 @@ async function startCommandLoop(ctx) {
     if (gitSubscriptionHandle)
       gitSubscriptionHandle.stop();
     await onDaemonShutdown(ctx);
+    if (ctx.stopLocalApi) {
+      await ctx.stopLocalApi().catch(() => {});
+    }
     releaseLock();
     process.exit(0);
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatroom-cli",
-  "version": "1.16.4",
+  "version": "1.16.6",
   "description": "CLI for multi-agent chatroom collaboration",
   "type": "module",
   "bin": {