@couralabs/claudin 0.1.6 → 0.1.7

package/claudin.js

@@ -1,5 +1,16 @@
 #!/usr/bin/env bun
 // @bun
+
+// packages/daemon/src/auth/connectionCredentials.ts
+import { randomBytes } from "crypto";
+var createRunId = () => crypto.randomUUID();
+var createAccessToken = () => randomBytes(32).toString("base64url");
+function appendCredentials(url, { token, runId }) {
+  const target = new URL(url);
+  target.searchParams.set("token", token);
+  target.searchParams.set("runId", runId);
+  return target.toString();
+}
 // node_modules/.bun/zod@4.6.7/node_modules/zod/v4/core/util.js
 function getEnumValues(entries) {
   const numericValues = Object.values(entries).filter((v) => typeof v === "number");
@@ -7550,8 +7561,8 @@ class DaemonClient {
     this.socket = socket;
     socket.addEventListener("message", (event) => this.notifyListeners(String(event.data)));
   }
-  static async connect(url) {
-    const socket = new WebSocket(url);
+  static async connect(url, credentials) {
+    const socket = new WebSocket(appendCredentials(url, credentials));
     await new Promise((resolve, reject) => {
       socket.addEventListener("open", () => resolve(), { once: true });
       socket.addEventListener("error", () => reject(new Error(`Cannot reach ${url}`)), {
@@ -8816,8 +8827,10 @@ class PermissionGate {
   }
   open(kind, toolUseId, input, signal, announcement) {
     return new Promise((settle) => {
-      this.pending.set(toolUseId, { kind, input, settle });
-      signal.addEventListener("abort", () => this.dismiss(kind, toolUseId), { once: true });
+      const onAbort = () => this.dismiss(kind, toolUseId);
+      const detach = () => signal.removeEventListener("abort", onAbort);
+      this.pending.set(toolUseId, { kind, input, settle, detach });
+      signal.addEventListener("abort", onAbort, { once: true });
       this.emit(announcement);
     });
   }
@@ -8832,6 +8845,7 @@ class PermissionGate {
     if (pending?.kind !== kind)
       return;
     this.pending.delete(toolUseId);
+    pending.detach();
     return pending;
   }
   listIds(kind) {
@@ -9211,7 +9225,6 @@ class AgentSession {
     try {
       yield* sink;
     } finally {
-      this.pumping = false;
       this.listenGates(() => {});
     }
   }
@@ -9306,9 +9319,11 @@ class AgentSession {
         if (this.pendingTurns === 0 && this.liveTaskIds.size === 0)
           break;
       }
+      this.pumping = false;
       sink.end();
     } catch (error) {
       this.pendingTurns = 0;
+      this.pumping = false;
       sink.end(error);
     }
   }
@@ -9332,14 +9347,13 @@ class AgentSessionManager {
   }
   createSession(options = {}) {
     const sessionId = options.sessionId ?? crypto.randomUUID();
-    this.sessions.set(sessionId, new AgentSession(sessionId, { ...options, sessionId }, this.runtime));
+    this.replaceSession(sessionId, { ...options, sessionId });
     return sessionId;
   }
   async resumeSession(sessionId, options = {}) {
     if (!await this.runtime.getInfo(sessionId))
       return this.createSession({ ...options, sessionId });
-    const resumed = new AgentSession(sessionId, { ...options, resume: sessionId }, this.runtime);
-    this.sessions.set(sessionId, resumed);
+    this.replaceSession(sessionId, { ...options, resume: sessionId });
     return sessionId;
   }
   async forkSession(sessionId, forkOptions, options = {}) {
@@ -9354,6 +9368,10 @@ class AgentSessionManager {
     for (const sessionId of [...this.sessions.keys()])
       this.closeSession(sessionId);
   }
+  replaceSession(sessionId, options) {
+    this.closeSession(sessionId);
+    this.sessions.set(sessionId, new AgentSession(sessionId, options, this.runtime));
+  }
   requireSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (!session)
@@ -9503,6 +9521,31 @@ class ReplayClient {
 import { once } from "events";
 import { WebSocketServer } from "ws";
 
+// packages/daemon/src/auth/checkConnection.ts
+import { timingSafeEqual } from "crypto";
+var isSameSecret = (given, expected) => {
+  const givenBytes = Buffer.from(given);
+  const expectedBytes = Buffer.from(expected);
+  return givenBytes.length === expectedBytes.length && timingSafeEqual(givenBytes, expectedBytes);
+};
+function readRunId(request) {
+  return new URL(request.url ?? "/", "ws://127.0.0.1").searchParams.get("runId");
+}
+function checkConnection(request, token, liveRunIds) {
+  if (request.headers.origin)
+    return { status: 403, reason: "Browser origins are not allowed" };
+  const params = new URL(request.url ?? "/", "ws://127.0.0.1").searchParams;
+  if (!isSameSecret(params.get("token") ?? "", token)) {
+    return { status: 401, reason: "Invalid access token" };
+  }
+  const runId = params.get("runId");
+  if (!runId)
+    return { status: 400, reason: "Missing run id" };
+  if (liveRunIds.has(runId))
+    return { status: 409, reason: "Run id already connected" };
+  return;
+}
+
 // packages/daemon/src/persistence/rateLimitCache.ts
 import { mkdir as mkdir2, readFile, writeFile } from "fs/promises";
 import { homedir as homedir4 } from "os";
@@ -11360,11 +11403,18 @@ var workspaceHandlers = {
 
 // packages/daemon/src/server/handleRequest.ts
 var handlers = { ...sessionHandlers, ...agentHandlers, ...workspaceHandlers, ...optionsHandlers };
+var SESSION_SWITCH_TYPES = new Set([
+  "session.created",
+  "session.restored",
+  "session.forked"
+]);
 async function* handleRequest(context, request) {
-  await context.session.dispatch(request);
+  const origin = context.session;
+  await origin.dispatch(request);
   const handler = handlers[request.type];
   for await (const response of handler(context, request)) {
-    await context.session.dispatch(response);
+    const target = SESSION_SWITCH_TYPES.has(response.type) ? context.session : origin;
+    await target.dispatch(response);
     yield response;
   }
 }
@@ -11382,7 +11432,12 @@ function publishEvent(clients, origin, event, toOrigin = true) {
 }
 
 // packages/daemon/src/server/startDaemon.ts
-var DEFAULT_PORT = 7777;
+var LOOPBACK_HOST = "127.0.0.1";
+async function reportFailure(context, server, socket, error) {
+  const failure = { type: "request.failed", reason: String(error) };
+  await context.session.dispatch(failure).catch(() => {});
+  publishEvent(server.clients, socket, failure);
+}
 async function answerMessage(context, server, socket, data) {
   try {
     const request = requestEventSchema.parse(JSON.parse(data));
@@ -11391,15 +11446,27 @@ async function answerMessage(context, server, socket, data) {
       publishEvent(server.clients, socket, response);
     }
   } catch (error) {
-    const failure = { type: "request.failed", reason: String(error) };
-    await context.session.dispatch(failure);
-    publishEvent(server.clients, socket, failure);
+    await reportFailure(context, server, socket, error);
   }
 }
-async function startDaemon(port = DEFAULT_PORT, context) {
+async function startDaemon(port, token, context) {
   const daemonContext = context ?? await createDaemonContext();
-  const server = new WebSocketServer({ port });
-  server.on("connection", (socket) => {
+  const liveRunIds = new Set;
+  const server = new WebSocketServer({
+    port,
+    host: LOOPBACK_HOST,
+    verifyClient: ({ req }, respond) => {
+      const rejection = checkConnection(req, token, liveRunIds);
+      if (rejection)
+        respond(false, rejection.status, rejection.reason);
+      else
+        respond(true);
+    }
+  });
+  server.on("connection", (socket, request) => {
+    const runId = readRunId(request) ?? "";
+    liveRunIds.add(runId);
+    socket.once("close", () => liveRunIds.delete(runId));
     socket.on("message", (data) => answerMessage(daemonContext, server, socket, data.toString()));
   });
   server.once("close", () => daemonContext.agents.closeAll());
@@ -24302,7 +24369,8 @@ function useColor() {
 var program = new Command;
 
 // apps/cli/src/index.ts
-var DEFAULT_PORT2 = "7777";
+var DEFAULT_PORT = "7777";
+var runId = createRunId();
 var program2 = new Command().name("claudin").enablePositionalOptions();
 var printResumeHint = (sessionId) => {
   if (!sessionId)
@@ -24316,10 +24384,12 @@ var exitOnDestroy = (renderer) => {
   renderer.on("destroy", () => process.exit(0));
 };
 var openContext = (sessionId) => createDaemonContext(undefined, sessionId).catch((error) => program2.error(error.message));
-var daemonUrl = (port) => `ws://localhost:${Number(port)}`;
-program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, --session <id>", "resume a previous session").action(async (opts) => {
-  const server = await startDaemon(Number(opts.port), await openContext(opts.session));
-  const renderer = await startTui(await DaemonClient.connect(daemonUrl(opts.port)), {
+var daemonUrl = (port) => `ws://127.0.0.1:${Number(port)}`;
+program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-s, --session <id>", "resume a previous session").action(async (opts) => {
+  const token = createAccessToken();
+  const server = await startDaemon(Number(opts.port), token, await openContext(opts.session));
+  const client = await DaemonClient.connect(daemonUrl(opts.port), { token, runId });
+  const renderer = await startTui(client, {
     resumeSessionId: opts.session,
     onExit: printResumeHint
   });
@@ -24329,14 +24399,16 @@ program2.option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, -
     server.close(() => process.exit(0));
   });
 });
-program2.command("daemon").description("Run the daemon without a UI so terminals can attach to it").option("-p, --port <port>", "daemon port", DEFAULT_PORT2).option("-s, --session <id>", "serve a previous session").action(async (opts) => {
-  await startDaemon(Number(opts.port), await openContext(opts.session));
-  process.stdout.write(`Daemon on ${daemonUrl(opts.port)}
-Attach with: claudin attach -p ${opts.port}
+program2.command("daemon").description("Run the daemon without a UI so terminals can attach to it").option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-s, --session <id>", "serve a previous session").action(async (opts) => {
+  const token = createAccessToken();
+  await startDaemon(Number(opts.port), token, await openContext(opts.session));
+  process.stdout.write(`Daemon on ${daemonUrl(opts.port)} (run ${runId})
+Attach with: claudin attach -p ${opts.port} --token ${token}
 `);
 });
-program2.command("attach").description("Attach another terminal to a running daemon's live session").option("-p, --port <port>", "daemon port", DEFAULT_PORT2).action(async (opts) => {
-  const client = await DaemonClient.connect(daemonUrl(opts.port)).catch((error) => program2.error(error.message));
+program2.command("attach").description("Attach another terminal to a running daemon's live session").option("-p, --port <port>", "daemon port", DEFAULT_PORT).option("-t, --token <token>", "access token printed by the daemon (or CLAUDIN_TOKEN)").action(async (opts) => {
+  const token = opts.token ?? process.env.CLAUDIN_TOKEN ?? program2.error("An access token is required: pass --token or set CLAUDIN_TOKEN");
+  const client = await DaemonClient.connect(daemonUrl(opts.port), { token, runId }).catch((error) => program2.error(error.message));
   const renderer = await startTui(client, { attach: true, onExit: printResumeHint });
   client.onDisconnect(() => renderer.destroy());
   exitOnDestroy(renderer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@couralabs/claudin",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "type": "module",
   "bin": {
     "claudin": "claudin.js"