@bondsmith/bondsmithd 0.1.3 → 0.1.5

package/dist/index.js

@@ -15,7 +15,7 @@ var REPLAYED_COMMAND_MESSAGE = "command already used (replay rejected)";
 var INVALID_MESSAGE_ERROR = "invalid message";
 
 // ../../packages/local-agent-protocol/src/protocol-version.ts
-var PROTOCOL_VERSION = 1;
+var PROTOCOL_VERSION = 4;
 
 // ../../packages/local-agent-protocol/src/project-path.ts
 var PROJECT_PATH_INVALID_REASONS = [
@@ -57,6 +57,13 @@ var signedConnectionChallengeSchema = z.object({
 
 // ../../packages/local-agent-protocol/src/schemas.ts
 var MAX_INSERT_TEXT_BYTES = 32 * 1024;
+var MAX_INPUT_CHARS = 16 * 1024;
+var MAX_WIRE_MESSAGE_BYTES = 256 * 1024;
+var MAX_TERMINAL_DIMENSION = 1e3;
+var terminalSizeSchema = z2.object({
+  cols: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
+  rows: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION)
+});
 var localSessionSchema = z2.object({
   id: z2.string(),
   title: z2.string(),
@@ -83,6 +90,8 @@ var workspaceFileEntrySchema = z2.object({
 var workspaceStatusSchema = z2.object({
   isGitRepo: z2.boolean(),
   branch: z2.string().nullable(),
+  // .catch(undefined): a malformed informational field must never drop the whole status message.
+  baseRef: z2.string().nullable().optional().catch(void 0),
   files: z2.array(workspaceFileEntrySchema)
 });
 var workspaceFileDiffSchema = z2.object({
@@ -128,12 +137,15 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
     // misattributes a daemon error for ANY other in-flight command
     // (observed: a session.resize racing ahead of its own session.attach)
     // to the wrong promise — a confirmed bug, not a hypothetical.
-    requestId: z2.string().min(1).max(200).optional()
+    requestId: z2.string().min(1).max(200).optional(),
+    // Tolerant like baseRef: an unreadable size must not make the daemon drop the attach itself.
+    size: terminalSizeSchema.optional().catch(void 0)
   }),
+  z2.object({ type: z2.literal("session.detach"), sessionId: z2.string() }),
   z2.object({
     type: z2.literal("session.input"),
     sessionId: z2.string(),
-    data: z2.string()
+    data: z2.string().max(MAX_INPUT_CHARS)
   }),
   z2.object({
     type: z2.literal("session.insertText"),
@@ -143,8 +155,7 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
   z2.object({
     type: z2.literal("session.resize"),
     sessionId: z2.string(),
-    cols: z2.number().int().positive(),
-    rows: z2.number().int().positive()
+    ...terminalSizeSchema.shape
   }),
   z2.object({ type: z2.literal("session.stop"), sessionId: z2.string() }),
   z2.object({
@@ -348,6 +359,7 @@ import { z as z3 } from "zod";
 var SIGNABLE_ACTIONS = [
   "session.create",
   "session.attach",
+  "session.detach",
   "session.input",
   "session.insertText",
   "session.resize",
@@ -838,6 +850,8 @@ function expandHome(cwd) {
 import { execFile as execFileCb } from "child_process";
 import { promisify } from "util";
 var execFile = promisify(execFileCb);
+var MAX_GIT_OUTPUT_BYTES = 64 * 1024 * 1024;
+var SAFE_DIFF_FLAGS = ["--no-ext-diff", "--no-textconv"];
 var GitNotARepoError = class extends Error {
   constructor() {
     super("not a git repository");
@@ -851,7 +865,7 @@ function isNotARepoError(error2) {
 }
 async function runGit(args, cwd) {
   try {
-    const { stdout } = await execFile("git", args, { cwd });
+    const { stdout } = await execFile("git", args, { cwd, maxBuffer: MAX_GIT_OUTPUT_BYTES });
     return stdout;
   } catch (error2) {
     if (isNotARepoError(error2)) throw new GitNotARepoError();
@@ -860,7 +874,7 @@ async function runGit(args, cwd) {
 }
 async function runGitAllowingExitCodes(args, cwd, allowedExitCodes) {
   try {
-    const { stdout } = await execFile("git", args, { cwd });
+    const { stdout } = await execFile("git", args, { cwd, maxBuffer: MAX_GIT_OUTPUT_BYTES });
     return stdout;
   } catch (error2) {
     if (isNotARepoError(error2)) throw new GitNotARepoError();
@@ -872,6 +886,12 @@ async function runGitAllowingExitCodes(args, cwd, allowedExitCodes) {
     throw error2;
   }
 }
+function runGitDiff(args, cwd) {
+  return runGit(["diff", ...SAFE_DIFF_FLAGS, ...args], cwd);
+}
+function runGitDiffAllowingExitCodes(args, cwd, allowedExitCodes) {
+  return runGitAllowingExitCodes(["diff", ...SAFE_DIFF_FLAGS, ...args], cwd, allowedExitCodes);
+}
 
 // src/projects/validate-path.ts
 var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
@@ -883,6 +903,27 @@ function invalidReasonForFsError(error2) {
   if (PERMISSION_CODES.has(code)) return "permission_denied";
   return null;
 }
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function gitFailure(error2, path) {
+  const { code, stderr } = error2;
+  if (code === "ENOENT") {
+    return new Error(
+      "git isn't installed, or isn't on the PATH of the terminal running bondsmithd."
+    );
+  }
+  const text = typeof stderr === "string" ? stderr : "";
+  if (text.includes("dubious ownership")) {
+    return new Error(
+      `git doesn't trust this folder because another user owns it. If you trust it, run: git config --global --add safe.directory ${shellQuote(path)}`
+    );
+  }
+  const fatal = text.split("\n").find((line) => line.startsWith("fatal:"));
+  return new Error(
+    fatal ?? (error2 instanceof Error ? error2.message : "git failed to inspect that folder.")
+  );
+}
 async function validateProjectPath(input) {
   const expanded = expandHome(input.trim());
   if (!isAbsolute(expanded)) return { valid: false, reason: "relative_path" };
@@ -900,7 +941,7 @@ async function validateProjectPath(input) {
     if (insideWorkTree !== "true") return { valid: false, reason: "not_a_git_repo" };
   } catch (error2) {
     if (error2 instanceof GitNotARepoError) return { valid: false, reason: "not_a_git_repo" };
-    throw error2;
+    throw gitFailure(error2, path);
   }
   return { valid: true, path };
 }
@@ -910,7 +951,14 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.3" : "dev";
+var DAEMON_VERSION = true ? "0.1.5" : "dev";
+var VERSION_FLAGS = ["--version", "-v"];
+function versionLine() {
+  return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
+}
+function isVersionRequest(argv) {
+  return argv.some((arg) => VERSION_FLAGS.includes(arg));
+}
 
 // src/sessions/tmux/client.ts
 import { execFile as execFileCb2 } from "child_process";
@@ -982,9 +1030,18 @@ async function listTmuxSessions(formatString) {
     throw error2;
   }
 }
+var NO_SERVER_MESSAGE_PATTERNS = [
+  /no server running/i,
+  /no current session/i,
+  /no sessions/i,
+  /failed to connect to server/i,
+  /error connecting to .*\((no such file or directory|connection refused)\)/i
+];
 function isNoServerError(error2) {
-  if (typeof error2 !== "object" || error2 === null) return true;
-  return error2.code !== "ENOENT";
+  if (typeof error2 !== "object" || error2 === null) return false;
+  const { message, stderr } = error2;
+  const text = [message, stderr].filter((part) => typeof part === "string").join("\n");
+  return NO_SERVER_MESSAGE_PATTERNS.some((pattern) => pattern.test(text));
 }
 
 // src/security/verify-command.ts
@@ -1165,6 +1222,76 @@ async function verifyCommand(command, daemonFingerprint, connectionState, truste
   return { ok: true };
 }
 
+// src/ws/output-pacer.ts
+var OUTPUT_HIGH_WATER_BYTES = 1024 * 1024;
+var OUTPUT_LOW_WATER_BYTES = 256 * 1024;
+var DRAIN_POLL_MS = 50;
+var MAX_CAPTURE_FAILURES = 5;
+var REPAINT_PREFIX = "\x1B[0m\x1B[2J\x1B[H";
+function createOutputPacer(options) {
+  const highWater = options.highWaterBytes ?? OUTPUT_HIGH_WATER_BYTES;
+  const lowWater = options.lowWaterBytes ?? OUTPUT_LOW_WATER_BYTES;
+  const pollMs = options.pollMs ?? DRAIN_POLL_MS;
+  let behind = false;
+  let disposed = false;
+  let captureFailures = 0;
+  let timer;
+  function scheduleRepaint() {
+    timer = setTimeout(() => void repaintWhenDrained(), pollMs);
+  }
+  async function repaintWhenDrained() {
+    timer = void 0;
+    if (disposed) return;
+    if (options.bufferedBytes() > lowWater) {
+      scheduleRepaint();
+      return;
+    }
+    let snapshot;
+    try {
+      snapshot = await options.snapshot();
+    } catch (error2) {
+      if (disposed) return;
+      captureFailures += 1;
+      if (captureFailures < MAX_CAPTURE_FAILURES) {
+        scheduleRepaint();
+        return;
+      }
+      console.warn("bondsmithd: giving up repainting a terminal after repeated capture failures", error2);
+      behind = false;
+      captureFailures = 0;
+      return;
+    }
+    if (disposed) return;
+    captureFailures = 0;
+    if (options.bufferedBytes() > lowWater) {
+      scheduleRepaint();
+      return;
+    }
+    try {
+      options.send(REPAINT_PREFIX + snapshot);
+    } catch (error2) {
+      console.error("bondsmithd: terminal repaint failed", error2);
+    }
+    behind = false;
+  }
+  return {
+    write(data) {
+      if (disposed || behind) return;
+      if (options.bufferedBytes() > highWater) {
+        behind = true;
+        scheduleRepaint();
+        return;
+      }
+      options.send(data);
+    },
+    dispose() {
+      disposed = true;
+      if (timer !== void 0) clearTimeout(timer);
+      timer = void 0;
+    }
+  };
+}
+
 // src/ws/router.ts
 var SIGNABLE_ACTION_SET = new Set(SIGNABLE_ACTIONS);
 function isSignableAction(type) {
@@ -1191,17 +1318,31 @@ function verifyRejectionMessage(reason) {
 var REVOKED_REJECTION_MESSAGE = "connection has not completed its handshake";
 var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
-function createRouterConnection(connectionAuth, send, markControllerId, ptyAttachments) {
+function releaseSession(conn, ptyAttachments, sessionId) {
+  const listener = conn.getOutputListener(sessionId);
+  if (listener) ptyAttachments.release(sessionId, listener);
+  conn.unregisterOutputListener(sessionId);
+  conn.subscriptions.delete(sessionId);
+}
+function createRouterConnection(connectionAuth, send, markControllerId, ptyAttachments, bufferedBytes) {
   const outputListeners = /* @__PURE__ */ new Map();
   const attachLocks = /* @__PURE__ */ new Map();
+  let closed = false;
   let admissionChain = Promise.resolve();
   const conn = {
     subscriptions: /* @__PURE__ */ new Set(),
     send,
-    registerOutputListener: (sessionId, listener) => {
-      outputListeners.set(sessionId, listener);
+    bufferedBytes,
+    isClosed: () => closed,
+    registerOutputListener: (sessionId, listener, dispose) => {
+      outputListeners.get(sessionId)?.dispose?.();
+      outputListeners.set(sessionId, { listener, dispose });
+    },
+    getOutputListener: (sessionId) => outputListeners.get(sessionId)?.listener,
+    unregisterOutputListener: (sessionId) => {
+      outputListeners.get(sessionId)?.dispose?.();
+      outputListeners.delete(sessionId);
     },
-    getOutputListener: (sessionId) => outputListeners.get(sessionId),
     connectionAuth,
     markControllerId,
     admitInOrder: (fn) => {
@@ -1224,9 +1365,9 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
     }
   };
   function releaseAllSubscriptions() {
-    for (const sessionId of conn.subscriptions) {
-      const listener = outputListeners.get(sessionId);
-      if (listener) ptyAttachments.release(sessionId, listener);
+    closed = true;
+    for (const sessionId of [...conn.subscriptions]) {
+      releaseSession(conn, ptyAttachments, sessionId);
     }
   }
   return { conn, releaseAllSubscriptions };
@@ -1237,9 +1378,12 @@ function error(message, requestId) {
 function errorMessageOf(err, fallback) {
   return err instanceof Error ? err.message : fallback;
 }
-function getSessionOrError(sessionManager, conn, sessionId) {
+function requestIdOf(message) {
+  return "requestId" in message ? message.requestId : void 0;
+}
+function getSessionOrError(sessionManager, conn, sessionId, requestId) {
   const session = sessionManager.get(sessionId);
-  if (!session) conn.send(error("unknown session"));
+  if (!session) conn.send(error("unknown session", requestId));
   return session;
 }
 async function handleBrowserMessage(conn, raw, deps) {
@@ -1259,11 +1403,11 @@ async function handleBrowserMessage(conn, raw, deps) {
         deps.trustedControllersPath
       );
       if (!verdict.ok) {
-        conn.send(error(verifyRejectionMessage(verdict.reason)));
+        conn.send(error(verifyRejectionMessage(verdict.reason), requestIdOf(innerMessage.data)));
         return false;
       }
       if (conn.connectionAuth.isRevoked()) {
-        conn.send(error(REVOKED_REJECTION_MESSAGE));
+        conn.send(error(REVOKED_REJECTION_MESSAGE, requestIdOf(innerMessage.data)));
         return false;
       }
       return true;
@@ -1291,7 +1435,7 @@ async function handleBrowserMessage(conn, raw, deps) {
     return;
   }
   if (isSignableAction(parsed.data.type)) {
-    conn.send(error("signature required for this command"));
+    conn.send(error("signature required for this command", requestIdOf(parsed.data)));
     return;
   }
   await dispatch(conn, parsed.data, deps);
@@ -1336,8 +1480,17 @@ async function dispatch(conn, message, {
       }
       await conn.withAttachLock(message.sessionId, async () => {
         const previousListener = conn.getOutputListener(message.sessionId);
-        const onData = (data) => {
-          conn.send({ type: "terminal.output", sessionId: message.sessionId, data });
+        const output = createOutputPacer({
+          send: (data) => conn.send({ type: "terminal.output", sessionId: message.sessionId, data }),
+          bufferedBytes: conn.bufferedBytes,
+          snapshot: () => ptyAttachments.paneSnapshot(session.tmuxSessionName)
+        });
+        const onData = output.write;
+        const abandonedBecauseClosed = () => {
+          if (!conn.isClosed()) return false;
+          ptyAttachments.release(message.sessionId, onData);
+          output.dispose();
+          return true;
         };
         if (previousListener && await ptyAttachments.swapListener(
           message.sessionId,
@@ -1345,29 +1498,41 @@ async function dispatch(conn, message, {
           previousListener,
           onData
         )) {
+          if (abandonedBecauseClosed()) return;
           conn.subscriptions.add(message.sessionId);
-          conn.registerOutputListener(message.sessionId, onData);
+          conn.registerOutputListener(message.sessionId, onData, output.dispose);
           conn.send({ type: "session.attached", sessionId: message.sessionId, requestId });
           return;
         }
         if (previousListener) {
           ptyAttachments.release(message.sessionId, previousListener);
+          conn.unregisterOutputListener(message.sessionId);
         }
         const attached = await ptyAttachments.ensureAttached(
           message.sessionId,
           session.tmuxSessionName,
-          onData
+          onData,
+          message.size
         );
         if (!attached) {
+          output.dispose();
           conn.send(error("failed to attach to session", requestId));
           return;
         }
+        if (abandonedBecauseClosed()) return;
         conn.subscriptions.add(message.sessionId);
-        conn.registerOutputListener(message.sessionId, onData);
+        conn.registerOutputListener(message.sessionId, onData, output.dispose);
         conn.send({ type: "session.attached", sessionId: message.sessionId, requestId });
       });
       return;
     }
+    case "session.detach": {
+      if (!isValidSessionId(message.sessionId)) return;
+      await conn.withAttachLock(message.sessionId, async () => {
+        releaseSession(conn, ptyAttachments, message.sessionId);
+      });
+      return;
+    }
     case "session.input": {
       if (!conn.subscriptions.has(message.sessionId)) {
         conn.send(error("not attached to session"));
@@ -1409,7 +1574,7 @@ async function dispatch(conn, message, {
       return;
     }
     case "workspace.getStatus": {
-      const session = getSessionOrError(sessionManager, conn, message.sessionId);
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
       if (!session) return;
       try {
         const status = await getWorkspaceStatus2(session.cwd);
@@ -1420,12 +1585,12 @@ async function dispatch(conn, message, {
           status
         });
       } catch (err) {
-        conn.send(error(errorMessageOf(err, "failed to read workspace status")));
+        conn.send(error(errorMessageOf(err, "failed to read workspace status"), message.requestId));
       }
       return;
     }
     case "workspace.getDiff": {
-      const session = getSessionOrError(sessionManager, conn, message.sessionId);
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
       if (!session) return;
       try {
         const diff = await getWorkspaceDiff2(session.cwd, message.path, message.staged);
@@ -1436,7 +1601,7 @@ async function dispatch(conn, message, {
           diff
         });
       } catch (err) {
-        conn.send(error(errorMessageOf(err, "failed to read workspace diff")));
+        conn.send(error(errorMessageOf(err, "failed to read workspace diff"), message.requestId));
       }
       return;
     }
@@ -1771,7 +1936,9 @@ function startRelayClient(deps) {
       },
       () => {
       },
-      deps.ptyAttachments
+      deps.ptyAttachments,
+      // One socket carries every browser session, so a backed-up relay link slows all of them together.
+      () => ws.bufferedAmount
     );
   }
   function handleSessionOpened(ws, relaySessionId) {
@@ -1999,12 +2166,27 @@ async function persistToken(tokenPath, token) {
 
 // src/security/pending-authorizations.ts
 import { createHash, randomUUID } from "crypto";
+
+// src/security/controller-label.ts
+var MAX_LABEL_CHARACTERS = 60;
+var MAX_STACKED_MARKS = 3;
+var FALLBACK_LABEL = "Unnamed browser";
+var EXCESS_MARKS = new RegExp(`(\\p{M}{${MAX_STACKED_MARKS}})\\p{M}+`, "gu");
+function sanitizeControllerLabel(raw) {
+  const printable = raw.replace(/\p{C}/gu, " ").replace(EXCESS_MARKS, "$1").replace(/\s+/g, " ").trim();
+  const clipped = Array.from(printable).slice(0, MAX_LABEL_CHARACTERS).join("").trim();
+  return clipped === "" ? FALLBACK_LABEL : clipped;
+}
+
+// src/security/pending-authorizations.ts
 function controllerIdFromPublicKeySync(publicKeyPem) {
   return createHash("sha256").update(publicKeyPem).digest("hex").slice(0, 32);
 }
 var REQUEST_EXPIRY_MS = 5 * 6e4;
 var MAX_REQUESTS_PER_WINDOW = 5;
 var RATE_LIMIT_WINDOW_MS = 6e4;
+var MAX_PENDING_REQUESTS = 5;
+var MAX_NEW_REQUESTS_PER_WINDOW = 10;
 var PendingAuthorizationStore = class {
   // Invariant: at most one PendingEntry per controllerId at any time. A
   // conflicting requestEnrollment call for a controllerId that already has
@@ -2015,6 +2197,7 @@ var PendingAuthorizationStore = class {
   // resolve a newer, unrelated one.
   pending = /* @__PURE__ */ new Map();
   requestTimestamps = /* @__PURE__ */ new Map();
+  allRequestTimestamps = [];
   isInteractive;
   trustedControllersPath;
   constructor(options = {}) {
@@ -2060,7 +2243,7 @@ var PendingAuthorizationStore = class {
         result: existing.resultPromise
       };
     }
-    if (this.isRateLimited(controllerId)) {
+    if (this.isRateLimited(controllerId) || this.isOverGlobalLimits()) {
       return { ok: false, reason: "rate_limited" };
     }
     this.recordRequestTimestamp(controllerId);
@@ -2068,7 +2251,7 @@ var PendingAuthorizationStore = class {
     const authorization = {
       controllerId,
       publicKeyPem: params.publicKeyPem,
-      label: params.label,
+      label: sanitizeControllerLabel(params.label),
       fingerprint: "",
       requestedAt: now,
       expiresAt: now + REQUEST_EXPIRY_MS,
@@ -2156,19 +2339,33 @@ var PendingAuthorizationStore = class {
       entry.settle("cancelled");
     }
   }
+  /** True while this exact request is still waiting for an answer, so a queued prompt can skip one that expired or was cancelled. */
+  isPending(controllerId, requestToken) {
+    const entry = this.pending.get(controllerId);
+    return entry !== void 0 && !entry.settled && entry.authorization.requestToken === requestToken && entry.authorization.expiresAt > Date.now();
+  }
   isRateLimited(controllerId) {
     const timestamps = this.requestTimestamps.get(controllerId) ?? [];
     const windowStart = Date.now() - RATE_LIMIT_WINDOW_MS;
     const recent = timestamps.filter((t) => t > windowStart);
     return recent.length >= MAX_REQUESTS_PER_WINDOW;
   }
-  recordRequestTimestamp(controllerId) {
+  isOverGlobalLimits() {
     const windowStart = Date.now() - RATE_LIMIT_WINDOW_MS;
-    const timestamps = (this.requestTimestamps.get(controllerId) ?? []).filter(
-      (t) => t > windowStart
-    );
-    timestamps.push(Date.now());
-    this.requestTimestamps.set(controllerId, timestamps);
+    const recent = this.allRequestTimestamps.filter((t) => t > windowStart);
+    return recent.length >= MAX_NEW_REQUESTS_PER_WINDOW || this.pending.size >= MAX_PENDING_REQUESTS;
+  }
+  recordRequestTimestamp(controllerId) {
+    const now = Date.now();
+    const windowStart = now - RATE_LIMIT_WINDOW_MS;
+    this.allRequestTimestamps = this.allRequestTimestamps.filter((t) => t > windowStart);
+    this.allRequestTimestamps.push(now);
+    for (const [key, timestamps] of this.requestTimestamps) {
+      if (!timestamps.some((t) => t > windowStart)) this.requestTimestamps.delete(key);
+    }
+    const recent = (this.requestTimestamps.get(controllerId) ?? []).filter((t) => t > windowStart);
+    recent.push(now);
+    this.requestTimestamps.set(controllerId, recent);
   }
 };
 
@@ -2280,42 +2477,101 @@ function startRevocationSync(deps) {
 // src/security/terminal-approval.ts
 import { createInterface } from "readline";
 function presentPendingAuthorizationOnTerminal(store) {
-  return (pending) => {
+  const waiting = [];
+  let prompting = false;
+  let inputEnded = false;
+  const record = (pending, approved) => {
+    store.resolve(pending.controllerId, pending.requestToken, approved).catch((error2) => {
+      console.error("Failed to record controller authorization decision", error2);
+    });
+  };
+  const askNext = () => {
+    if (prompting) return;
+    const pending = waiting.shift();
+    if (!pending) return;
+    if (!store.isPending(pending.controllerId, pending.requestToken)) {
+      askNext();
+      return;
+    }
+    if (inputEnded) {
+      record(pending, false);
+      askNext();
+      return;
+    }
+    prompting = true;
     console.log("");
     console.log("  Bondsmith controller authorization request");
-    console.log(`  Browser:     ${pending.label}`);
+    console.log(`  Browser:     "${pending.label}"`);
     console.log(`  Fingerprint: ${pending.fingerprint}`);
+    if (waiting.length > 0) console.log(`  (${waiting.length} more waiting after this one)`);
     console.log("");
     console.log("  Allow this browser to control local sessions? [y/N]");
     const rl = createInterface({ input: process.stdin, output: process.stdout });
-    rl.question("  > ", (answer) => {
+    let answered = false;
+    let expired = false;
+    const expiryTimer = setTimeout(
+      () => {
+        expired = true;
+        rl.close();
+      },
+      Math.max(0, pending.expiresAt - Date.now())
+    );
+    const finish = (approved) => {
+      if (answered) return;
+      answered = true;
+      clearTimeout(expiryTimer);
       rl.close();
-      const approved = answer.trim().toLowerCase() === "y";
-      store.resolve(pending.controllerId, pending.requestToken, approved).catch((error2) => {
-        console.error("Failed to record controller authorization decision", error2);
-      });
-      console.log(approved ? "  Approved." : "  Denied.");
+      record(pending, approved);
+      if (expired) console.log("  Request expired.");
+      else console.log(approved ? "  Approved." : "  Denied.");
       console.log("");
+      prompting = false;
+      askNext();
+    };
+    rl.question("  > ", (answer) => finish(answer.trim().toLowerCase() === "y"));
+    rl.on("SIGINT", () => finish(false));
+    rl.on("close", () => {
+      if (!answered && !expired) inputEnded = true;
+      finish(false);
     });
   };
+  return (pending) => {
+    waiting.push(pending);
+    askNext();
+  };
 }
 
-// src/sessions/git/diff.ts
-async function getWorkspaceDiff(cwd, path, staged) {
-  const numstatArgs = staged ? ["diff", "--cached", "--numstat", "--", path] : ["diff", "--numstat", "--", path];
-  const numstat = await runGit(numstatArgs, cwd);
-  const binary = /^(-\t-\t)/.test(numstat.trim());
-  if (binary) {
-    return { path, staged, patch: null, binary: true };
+// src/sessions/git/base.ts
+var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+var DEFAULT_BRANCH_CANDIDATES = ["origin/main", "origin/master", "main", "master"];
+async function tryGit(args, cwd) {
+  try {
+    return (await runGit(args, cwd)).trim() || null;
+  } catch {
+    return null;
   }
-  const diffArgs = staged ? ["diff", "--cached", "--", path] : ["diff", "--", path];
-  let patch = await runGit(diffArgs, cwd);
-  if (patch.trim() === "" && !staged) {
-    patch = await runGitAllowingExitCodes(["diff", "--no-index", "--", "/dev/null", path], cwd, [
-      1
-    ]).catch(() => "");
+}
+async function findDefaultBranchRef(cwd) {
+  const remoteHead = await tryGit(
+    ["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"],
+    cwd
+  );
+  if (remoteHead) return remoteHead;
+  for (const candidate of DEFAULT_BRANCH_CANDIDATES) {
+    if (await tryGit(["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`], cwd)) {
+      return candidate;
+    }
   }
-  return { path, staged, patch: patch || null, binary: false };
+  return null;
+}
+async function resolveComparisonBase(cwd) {
+  if (!await tryGit(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd)) {
+    return { sha: EMPTY_TREE_SHA, ref: null };
+  }
+  const defaultRef = await findDefaultBranchRef(cwd);
+  if (!defaultRef) return { sha: "HEAD", ref: null };
+  const mergeBase = await tryGit(["merge-base", "HEAD", defaultRef], cwd);
+  return mergeBase ? { sha: mergeBase, ref: defaultRef } : { sha: "HEAD", ref: null };
 }
 
 // src/sessions/git/status.ts
@@ -2325,7 +2581,11 @@ async function getCurrentBranch(cwd) {
     return out === "" || out === "HEAD" ? null : out;
   } catch (err) {
     if (err instanceof GitNotARepoError) return null;
-    throw err;
+    try {
+      return (await runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], cwd)).trim() || null;
+    } catch {
+      throw err;
+    }
   }
 }
 async function getRepositoryFullName(cwd) {
@@ -2375,88 +2635,73 @@ function parseNumstat(output) {
   }
   return map;
 }
-var STATUS_CODE_MAP = {
+var STATUS_BY_LETTER = {
   A: "added",
   M: "modified",
   D: "deleted",
   R: "renamed",
   C: "copied",
+  T: "modified",
+  // type change, such as a file becoming a symlink
   U: "modified"
-  // unmerged — treated as modified, no conflict-resolution UI in scope
+  // unmerged: no conflict-resolution UI yet, so it reads as modified
 };
-async function getWorkspaceStatus(cwd) {
-  const branch = await getCurrentBranch(cwd);
-  if (branch === null && !await isGitRepo(cwd)) {
-    return { isGitRepo: false, branch: null, files: [] };
-  }
-  const [porcelain, unstagedRaw, stagedRaw] = await Promise.all([
-    runGit(["status", "--porcelain=v1", "-z"], cwd),
-    runGit(["diff", "--numstat", "-z"], cwd),
-    runGit(["diff", "--cached", "--numstat", "-z"], cwd)
-  ]);
-  const unstagedNumstat = parseNumstat(unstagedRaw);
-  const stagedNumstat = parseNumstat(stagedRaw);
-  const files = parsePorcelain(porcelain, unstagedNumstat, stagedNumstat);
-  return { isGitRepo: true, branch, files };
-}
-function parsePorcelain(porcelain, unstagedNumstat, stagedNumstat) {
-  const entries = [];
-  const fields = porcelain.split("\0").filter((f) => f.length > 0);
+function isStatusLetter(letter) {
+  return letter in STATUS_BY_LETTER;
+}
+function parseNameStatus(output) {
+  const fields = output.split("\0").filter((f) => f.length > 0);
+  const changed = [];
   let i = 0;
   while (i < fields.length) {
-    const raw = fields[i];
-    const x = raw[0] ?? " ";
-    const y = raw[1] ?? " ";
-    const path = raw.slice(3);
-    i++;
-    if (x === "R" || x === "C" || y === "R" || y === "C") {
-      const previousPath = fields[i];
-      i++;
-      if (previousPath === void 0) continue;
-      pushEntriesForPath(entries, path, x, y, previousPath, unstagedNumstat, stagedNumstat);
-      continue;
+    const letter = fields[i++][0] ?? "";
+    const status = isStatusLetter(letter) ? STATUS_BY_LETTER[letter] : "modified";
+    if (status === "renamed" || status === "copied") {
+      const previousPath = fields[i++];
+      const path = fields[i++];
+      if (previousPath === void 0 || path === void 0) break;
+      changed.push({ path, previousPath, status });
+    } else {
+      const path = fields[i++];
+      if (path === void 0) break;
+      changed.push({ path, status });
     }
-    pushEntriesForPath(entries, path, x, y, void 0, unstagedNumstat, stagedNumstat);
   }
-  return entries;
+  return changed;
 }
-function pushEntriesForPath(entries, path, x, y, previousPath, unstagedNumstat, stagedNumstat) {
-  if (x === "?" && y === "?") {
-    const numstat = unstagedNumstat.get(path);
-    entries.push({
-      path,
-      status: "untracked",
-      staged: false,
-      additions: numstat?.additions ?? null,
-      deletions: numstat?.deletions ?? null,
-      binary: numstat?.binary ?? false
-    });
-    return;
-  }
-  if (x !== " " && x !== "?") {
-    const numstat = stagedNumstat.get(path);
-    entries.push({
-      path,
-      previousPath,
-      status: STATUS_CODE_MAP[x] ?? "modified",
-      staged: true,
-      additions: numstat?.additions ?? null,
-      deletions: numstat?.deletions ?? null,
-      binary: numstat?.binary ?? false
-    });
+async function getWorkspaceStatus(cwd) {
+  const branch = await getCurrentBranch(cwd);
+  if (branch === null && !await isGitRepo(cwd)) {
+    return { isGitRepo: false, branch: null, files: [] };
   }
-  if (y !== " " && y !== "?") {
-    const numstat = unstagedNumstat.get(path);
-    entries.push({
-      path,
-      previousPath,
-      status: STATUS_CODE_MAP[y] ?? "modified",
+  const base = await resolveComparisonBase(cwd);
+  const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+    runGitDiff(["--name-status", "-z", "-M", base.sha], cwd),
+    runGitDiff(["--numstat", "-z", "-M", base.sha], cwd),
+    runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd)
+  ]);
+  const numstat = parseNumstat(numstatRaw);
+  const tracked = parseNameStatus(nameStatusRaw).map((changed) => {
+    const counts = numstat.get(changed.path);
+    return {
+      path: changed.path,
+      previousPath: changed.previousPath,
+      status: changed.status,
       staged: false,
-      additions: numstat?.additions ?? null,
-      deletions: numstat?.deletions ?? null,
-      binary: numstat?.binary ?? false
-    });
-  }
+      additions: counts?.additions ?? null,
+      deletions: counts?.deletions ?? null,
+      binary: counts?.binary ?? false
+    };
+  });
+  const untracked = untrackedRaw.split("\0").filter((path) => path.length > 0).map((path) => ({
+    path,
+    status: "untracked",
+    staged: false,
+    additions: null,
+    deletions: null,
+    binary: false
+  }));
+  return { isGitRepo: true, branch, baseRef: base.ref, files: [...tracked, ...untracked] };
 }
 async function enrichSessionWithGitMetadata(session) {
   const [branch, repositoryFullName, status, lastActivityAt] = await Promise.all([
@@ -2475,6 +2720,33 @@ async function enrichSessionWithGitMetadata(session) {
   };
 }
 
+// src/sessions/git/diff.ts
+async function withRenameSource(cwd, baseSha, path) {
+  const nameStatus = await runGitDiff(["--name-status", "-z", "-M", baseSha], cwd);
+  const previousPath = parseNameStatus(nameStatus).find((c) => c.path === path)?.previousPath;
+  return previousPath === void 0 ? [path] : [previousPath, path];
+}
+async function isUntracked(cwd, path) {
+  const out = await runGit(["ls-files", "--others", "--exclude-standard", "--", path], cwd);
+  return out.trim() !== "";
+}
+async function getWorkspaceDiff(cwd, path, staged) {
+  const base = await resolveComparisonBase(cwd);
+  const pathspec = await withRenameSource(cwd, base.sha, path);
+  const numstat = await runGitDiff(["--numstat", "-M", base.sha, "--", ...pathspec], cwd);
+  const binary = /^(-\t-\t)/.test(numstat.trim());
+  if (binary) {
+    return { path, staged, patch: null, binary: true };
+  }
+  let patch = await runGitDiff(["-M", base.sha, "--", ...pathspec], cwd);
+  if (patch.trim() === "" && await isUntracked(cwd, path)) {
+    patch = await runGitDiffAllowingExitCodes(["--no-index", "--", "/dev/null", path], cwd, [
+      1
+    ]).catch(() => "");
+  }
+  return { path, staged, patch: patch || null, binary: false };
+}
+
 // src/ws/server.ts
 import { hostname } from "os";
 import { WebSocketServer } from "ws";
@@ -2500,23 +2772,40 @@ function isAllowedOrigin(origin, allowlist) {
 
 // src/sessions/pty-attachment.ts
 import * as pty from "node-pty";
+var DEFAULT_PTY_SIZE = { cols: 80, rows: 24 };
+var MAX_SNAPSHOT_JSON_BYTES = 128 * 1024;
+function keepBottomRows(rows) {
+  let budget = MAX_SNAPSHOT_JSON_BYTES;
+  let first = rows.length;
+  while (first > 0) {
+    budget -= JSON.stringify(rows[first - 1]).length;
+    if (budget < 0) break;
+    first -= 1;
+  }
+  return rows.slice(first);
+}
+function snapshotToTerminalOutput(snapshot) {
+  const rows = snapshot.replace(/\r?\n$/, "").split(/\r?\n/);
+  return keepBottomRows(rows).join("\r\n");
+}
 var PtyAttachmentManager = class {
   handles = /* @__PURE__ */ new Map();
   /**
    * Attempts to attach (spawning a pty if one isn't already running for this
    * session). Returns false, without throwing, if the pty could not be
    * spawned — a spawn failure here must never take down the whole daemon
-   * process, since every other session's pty would die with it.
+   * process, since every other session's pty would die with it. `size` only
+   * applies to a pty spawned here; an existing one keeps its current size.
    */
-  async ensureAttached(sessionId, tmuxSessionName, onData) {
+  async ensureAttached(sessionId, tmuxSessionName, onData, size = DEFAULT_PTY_SIZE) {
     let handle = this.handles.get(sessionId);
     if (!handle) {
       let ptyProcess;
       try {
         ptyProcess = pty.spawn("tmux", ["attach-session", "-t", tmuxSessionName], {
           name: "xterm-256color",
-          cols: 80,
-          rows: 24,
+          cols: size.cols,
+          rows: size.rows,
           cwd: process.env.HOME,
           env: filterSpawnEnv(process.env)
         });
@@ -2528,20 +2817,17 @@ ${new TmuxNotFoundError().message}
         }
         return false;
       }
-      handle = { process: ptyProcess, refCount: 0, dataListeners: /* @__PURE__ */ new Set() };
-      this.handles.set(sessionId, handle);
+      const created = { process: ptyProcess, dataListeners: /* @__PURE__ */ new Set([onData]) };
+      this.handles.set(sessionId, created);
       ptyProcess.onData((data) => {
-        for (const listener of handle?.dataListeners ?? []) listener(data);
+        for (const listener of created.dataListeners) listener(data);
       });
       ptyProcess.onExit(() => {
-        this.handles.delete(sessionId);
+        if (this.handles.get(sessionId) === created) this.handles.delete(sessionId);
       });
-      handle.refCount += 1;
-      handle.dataListeners.add(onData);
       return true;
     }
     await this.sendPaneSnapshot(tmuxSessionName, onData);
-    handle.refCount += 1;
     handle.dataListeners.add(onData);
     return true;
   }
@@ -2554,19 +2840,21 @@ ${new TmuxNotFoundError().message}
     handle.dataListeners.add(nextOnData);
     return true;
   }
+  /** The pane's current screen as terminal output; rejects if tmux cannot capture it. */
+  async paneSnapshot(tmuxSessionName) {
+    return snapshotToTerminalOutput(await capturePane(tmuxSessionName));
+  }
   // Best-effort: a capture failure just leaves this listener blank until the next real write.
   async sendPaneSnapshot(tmuxSessionName, onData) {
     try {
-      onData(await capturePane(tmuxSessionName));
+      onData(await this.paneSnapshot(tmuxSessionName));
     } catch {
     }
   }
   release(sessionId, onData) {
     const handle = this.handles.get(sessionId);
-    if (!handle) return;
-    handle.dataListeners.delete(onData);
-    handle.refCount -= 1;
-    if (handle.refCount <= 0) {
+    if (!handle?.dataListeners.delete(onData)) return;
+    if (handle.dataListeners.size === 0) {
       handle.process.kill();
       this.handles.delete(sessionId);
     }
@@ -2837,7 +3125,12 @@ var SessionManager = class {
       if (error2 instanceof TmuxNotFoundError) console.error(`
 ${error2.message}
 `);
-      if (!(error2 instanceof TmuxNoServerRunningError)) return;
+      if (!(error2 instanceof TmuxNoServerRunningError)) {
+        if (!(error2 instanceof TmuxNotFoundError)) {
+          console.error("tmux list-sessions failed; skipping reconcile", error2);
+        }
+        return;
+      }
     }
     await Promise.all(
       Array.from(this.sessions.values()).map(async (session) => {
@@ -2911,6 +3204,8 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
   const rejectionReasonByRequest = /* @__PURE__ */ new WeakMap();
   const wss = new WebSocketServer({
     server: httpServer,
+    // ws defaults to 100 MiB per frame, parsed before any signature is checked.
+    maxPayload: MAX_WIRE_MESSAGE_BYTES,
     // Client always sends the dev-tunnel token as the sole entry (see
     // isValidDevTunnelToken); echoing it back is required for a spec-
     // compliant handshake once a Sec-WebSocket-Protocol is offered.
@@ -2934,6 +3229,9 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
     broadcast({ type: "session.updated", session });
   });
   wss.on("connection", (socket, request) => {
+    socket.on("error", (error2) => {
+      console.warn("bondsmithd: browser socket error", error2.message);
+    });
     const rejectionReason = rejectionReasonByRequest.get(request);
     if (rejectionReason) {
       rejectionReasonByRequest.delete(request);
@@ -2948,7 +3246,8 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         if (socket.readyState === socket.OPEN) socket.send(JSON.stringify(message));
       },
       (controllerId) => registerControllerConnection(controllerId, socket),
-      ptyAttachments
+      ptyAttachments,
+      () => socket.bufferedAmount
     );
     cleanupBySocket.set(socket, releaseAllSubscriptions);
     connectionAuthBySocket.set(socket, connectionAuth);
@@ -3012,6 +3311,10 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
 }
 
 // src/index.ts
+if (isVersionRequest(process.argv.slice(2))) {
+  console.log(versionLine());
+  process.exit(0);
+}
 function loadRepoRootEnv() {
   const repoRoot = join6(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
   if (!existsSync(join6(repoRoot, "pnpm-workspace.yaml"))) return;
@@ -3021,6 +3324,7 @@ function loadRepoRootEnv() {
 }
 loadRepoRootEnv();
 async function start() {
+  console.log(versionLine());
   let config = getDaemonConfig();
   if (!config.devTunnelToken) {
     const generatedToken = await loadOrCreateDevTunnelToken();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.3",
+	"version": "0.1.5",
 	"private": false,
 	"description": "Local daemon for Bondsmith agent sessions — runs on the user's own machine, pairs with a Bondsmith account, and exposes tmux-backed terminal sessions to the Bondsmith web app over a signed WebSocket protocol.",
 	"homepage": "https://bondsmith.dev",