@bondsmith/bondsmithd 0.1.7 → 0.1.8

package/dist/index.js

@@ -4,7 +4,7 @@
 import { createServer } from "http";
 import { existsSync } from "fs";
 import { hostname as hostname2 } from "os";
-import { dirname as dirname4, join as join7 } from "path";
+import { dirname as dirname4, join as join8 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/local-agent-protocol/src/session.ts
@@ -16,7 +16,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 = 4;
+var PROTOCOL_VERSION = 7;
 
 // ../../packages/local-agent-protocol/src/project-path.ts
 var PROJECT_PATH_INVALID_REASONS = [
@@ -60,6 +60,8 @@ var signedConnectionChallengeSchema = z.object({
 var MAX_INSERT_TEXT_BYTES = 32 * 1024;
 var MAX_INPUT_CHARS = 16 * 1024;
 var MAX_WIRE_MESSAGE_BYTES = 256 * 1024;
+var MAX_DAEMON_REPLY_BYTES = 200 * 1024;
+var MAX_RANGE_LINES = 500;
 var MAX_TERMINAL_DIMENSION = 1e3;
 var terminalSizeSchema = z2.object({
   cols: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
@@ -95,14 +97,32 @@ var workspaceStatusSchema = z2.object({
   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)
+  files: z2.array(workspaceFileEntrySchema),
+  totalFiles: z2.number().int().nonnegative().optional().catch(void 0)
 });
 var workspaceFileDiffSchema = z2.object({
   path: z2.string(),
   staged: z2.boolean(),
   patch: z2.string().nullable(),
-  binary: z2.boolean()
+  binary: z2.boolean(),
+  tooLarge: z2.boolean().optional(),
+  version: z2.string().optional()
 });
+var workspaceFileRangeSchema = z2.discriminatedUnion("ok", [
+  z2.object({
+    ok: z2.literal(true),
+    path: z2.string(),
+    startLine: z2.number().int().min(1),
+    lines: z2.array(z2.string()).max(MAX_RANGE_LINES),
+    totalLines: z2.number().int().nonnegative(),
+    version: z2.string()
+  }),
+  z2.object({
+    ok: z2.literal(false),
+    path: z2.string(),
+    reason: z2.enum(["changed", "missing", "binary", "too_large", "not_allowed"])
+  })
+]);
 var projectPathValidationSchema = z2.discriminatedUnion("valid", [
   z2.object({ valid: z2.literal(true), path: z2.string() }),
   z2.object({ valid: z2.literal(false), reason: z2.enum(PROJECT_PATH_INVALID_REASONS) })
@@ -166,6 +186,15 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
     sessionId: z2.string(),
     requestId: z2.string().min(1).max(200)
   }),
+  z2.object({
+    type: z2.literal("workspace.readFileRange"),
+    sessionId: z2.string(),
+    path: z2.string().min(1).max(4096),
+    startLine: z2.number().int().min(1),
+    lineCount: z2.number().int().min(1).max(MAX_RANGE_LINES),
+    version: z2.string().min(1).max(100),
+    requestId: z2.string().min(1).max(200)
+  }),
   z2.object({
     type: z2.literal("workspace.getDiff"),
     sessionId: z2.string(),
@@ -250,6 +279,12 @@ var daemonMessageSchema = z2.discriminatedUnion("type", [
     requestId: z2.string(),
     status: workspaceStatusSchema
   }),
+  z2.object({
+    type: z2.literal("workspace.fileRange"),
+    sessionId: z2.string(),
+    requestId: z2.string(),
+    range: workspaceFileRangeSchema
+  }),
   z2.object({
     type: z2.literal("workspace.diff"),
     sessionId: z2.string(),
@@ -370,6 +405,7 @@ var SIGNABLE_ACTIONS = [
   "session.list",
   "workspace.getStatus",
   "workspace.getDiff",
+  "workspace.readFileRange",
   "project.validatePath"
 ];
 var envelopeSchema = z3.object({
@@ -954,7 +990,7 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.7" : "dev";
+var DAEMON_VERSION = true ? "0.1.8" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1378,12 +1414,42 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
 function error(message, requestId) {
   return { type: "error", message, requestId };
 }
+function fitDiffReply(reply) {
+  const { patch, tooLarge } = reply.diff;
+  const fits = (patch === null || patch.length <= MAX_DAEMON_REPLY_BYTES) && Buffer.byteLength(JSON.stringify(reply)) <= MAX_DAEMON_REPLY_BYTES;
+  if (tooLarge || fits) return reply;
+  return { ...reply, diff: { ...reply.diff, patch: null, tooLarge: true } };
+}
+function fitStatusReply(reply) {
+  if (Buffer.byteLength(JSON.stringify(reply)) <= MAX_DAEMON_REPLY_BYTES) return reply;
+  const { files } = reply.status;
+  const bare = { ...reply, status: { ...reply.status, files: [], totalFiles: files.length } };
+  let budget = MAX_DAEMON_REPLY_BYTES - Buffer.byteLength(JSON.stringify(bare));
+  const kept = [];
+  for (const file of files) {
+    const cost = Buffer.byteLength(JSON.stringify(file)) + 1;
+    if (cost > budget) break;
+    budget -= cost;
+    kept.push(file);
+  }
+  return { ...bare, status: { ...bare.status, files: kept } };
+}
 function errorMessageOf(err, fallback) {
   return err instanceof Error ? err.message : fallback;
 }
 function requestIdOf(message) {
   return "requestId" in message ? message.requestId : void 0;
 }
+function stringRequestId(value) {
+  if (typeof value !== "object" || value === null || !("requestId" in value)) return void 0;
+  const { requestId } = value;
+  return typeof requestId === "string" && requestId !== "" ? requestId.slice(0, 200) : void 0;
+}
+function requestIdOfUnparsed(raw) {
+  const envelope = typeof raw === "object" && raw !== null && "envelope" in raw ? raw.envelope : void 0;
+  const payload = typeof envelope === "object" && envelope !== null && "payload" in envelope ? envelope.payload : void 0;
+  return stringRequestId(payload) ?? stringRequestId(raw);
+}
 function getSessionOrError(sessionManager, conn, sessionId, requestId) {
   const session = sessionManager.get(sessionId);
   if (!session) conn.send(error("unknown session", requestId));
@@ -1395,7 +1461,7 @@ async function handleBrowserMessage(conn, raw, deps) {
     const { envelope } = signedCommand.data;
     const innerMessage = browserMessageSchema.safeParse(envelope.payload);
     if (!innerMessage.success || innerMessage.data.type !== envelope.action) {
-      conn.send(error(INVALID_MESSAGE_ERROR));
+      conn.send(error(INVALID_MESSAGE_ERROR, requestIdOfUnparsed(raw)));
       return;
     }
     const admitted = await conn.admitInOrder(async () => {
@@ -1421,7 +1487,7 @@ async function handleBrowserMessage(conn, raw, deps) {
   }
   const parsed = browserMessageSchema.safeParse(raw);
   if (!parsed.success) {
-    conn.send(error(INVALID_MESSAGE_ERROR));
+    conn.send(error(INVALID_MESSAGE_ERROR, requestIdOfUnparsed(raw)));
     return;
   }
   if (parsed.data.type === "connection.authenticate") {
@@ -1449,6 +1515,7 @@ async function dispatch(conn, message, {
   broadcast,
   getWorkspaceStatus: getWorkspaceStatus2,
   getWorkspaceDiff: getWorkspaceDiff2,
+  readFileRange: readFileRange2,
   validateProjectPath: validateProjectPath2,
   hostname: hostname3,
   daemonFingerprint,
@@ -1584,12 +1651,14 @@ async function dispatch(conn, message, {
           session.cwd,
           sessionManager.getBaseline(session.id)
         );
-        conn.send({
-          type: "workspace.status",
-          sessionId: message.sessionId,
-          requestId: message.requestId,
-          status
-        });
+        conn.send(
+          fitStatusReply({
+            type: "workspace.status",
+            sessionId: message.sessionId,
+            requestId: message.requestId,
+            status
+          })
+        );
       } catch (err) {
         conn.send(error(errorMessageOf(err, "failed to read workspace status"), message.requestId));
       }
@@ -1605,14 +1674,38 @@ async function dispatch(conn, message, {
           message.staged,
           sessionManager.getBaseline(session.id)
         );
+        conn.send(
+          fitDiffReply({
+            type: "workspace.diff",
+            sessionId: message.sessionId,
+            requestId: message.requestId,
+            diff
+          })
+        );
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to read workspace diff"), message.requestId));
+      }
+      return;
+    }
+    case "workspace.readFileRange": {
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
+      if (!session) return;
+      try {
+        const range = await readFileRange2(
+          session.cwd,
+          message.path,
+          message.startLine,
+          message.lineCount,
+          message.version
+        );
         conn.send({
-          type: "workspace.diff",
+          type: "workspace.fileRange",
           sessionId: message.sessionId,
           requestId: message.requestId,
-          diff
+          range
         });
       } catch (err) {
-        conn.send(error(errorMessageOf(err, "failed to read workspace diff"), message.requestId));
+        conn.send(error(errorMessageOf(err, "failed to read file range"), message.requestId));
       }
       return;
     }
@@ -2552,9 +2645,99 @@ function presentPendingAuthorizationOnTerminal(store) {
   };
 }
 
+// src/sessions/files/read-range.ts
+import { constants } from "fs";
+import { lstat, open, realpath, stat as stat2 } from "fs/promises";
+import { isAbsolute as isAbsolute2, join as join5, sep } from "path";
+var MAX_RANGE_FILE_BYTES = 2 * 1024 * 1024;
+var REPLY_ENVELOPE_BYTES = 8 * 1024;
+var BINARY_SNIFF_BYTES = 8e3;
+function fileVersion(stats) {
+  return `${stats.size}:${stats.mtimeMs}:${stats.ctimeMs}:${stats.ino}`;
+}
+async function locateInside(cwd, path) {
+  if (isAbsolute2(path)) return { refused: "not_allowed" };
+  try {
+    const root = await realpath(cwd);
+    const lexical = join5(root, path);
+    if ((await lstat(lexical)).isSymbolicLink()) return { refused: "not_allowed" };
+    const real = await realpath(lexical);
+    return real === root || real.startsWith(root + sep) ? { found: real } : { refused: "missing" };
+  } catch {
+    return { refused: "missing" };
+  }
+}
+async function readExactly(handle, size) {
+  const buffer = Buffer.allocUnsafe(size + 1);
+  let filled = 0;
+  while (filled < buffer.length) {
+    const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
+    if (bytesRead === 0) break;
+    filled += bytesRead;
+  }
+  return filled === size ? buffer.subarray(0, size) : void 0;
+}
+async function currentFileVersion(cwd, path) {
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return void 0;
+  try {
+    return fileVersion(await stat2(located.found));
+  } catch {
+    return void 0;
+  }
+}
+function splitLines(text) {
+  if (text === "") return [];
+  const lines = text.split("\n");
+  if (lines[lines.length - 1] === "") lines.pop();
+  return lines.map((line) => line.endsWith("\r") ? line.slice(0, -1) : line);
+}
+async function readFileRange(cwd, path, startLine, lineCount, version) {
+  const refuse = (reason) => ({ ok: false, path, reason });
+  const located = await locateInside(cwd, path);
+  if (!("found" in located)) return refuse(located.refused);
+  let content;
+  let handle;
+  try {
+    handle = await open(
+      located.found,
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK
+    );
+    const before = await handle.stat();
+    if (!before.isFile()) return refuse("not_allowed");
+    if (fileVersion(before) !== version) return refuse("changed");
+    if (before.size > MAX_RANGE_FILE_BYTES) return refuse("too_large");
+    const bytes = await readExactly(handle, before.size);
+    if (bytes === void 0 || fileVersion(await handle.stat()) !== version) {
+      return refuse("changed");
+    }
+    content = bytes;
+  } catch {
+    return refuse("missing");
+  } finally {
+    await handle?.close();
+  }
+  if (content.subarray(0, BINARY_SNIFF_BYTES).includes(0)) return refuse("binary");
+  const lines = splitLines(content.toString("utf8"));
+  const page = [];
+  let budget = MAX_DAEMON_REPLY_BYTES - REPLY_ENVELOPE_BYTES;
+  const wanted = Math.min(lineCount, MAX_RANGE_LINES);
+  for (let index = startLine - 1; index < lines.length && page.length < wanted; index++) {
+    const line = lines[index];
+    const cost = Buffer.byteLength(JSON.stringify(line)) + 1;
+    if (cost > budget) {
+      if (page.length === 0) return refuse("too_large");
+      break;
+    }
+    budget -= cost;
+    page.push(line);
+  }
+  return { ok: true, path, startLine, lines: page, totalLines: lines.length, version };
+}
+
 // src/sessions/git/baseline.ts
-import { lstat } from "fs/promises";
-import { join as join5 } from "path";
+import { lstat as lstat2 } from "fs/promises";
+import { join as join6 } from "path";
 
 // src/sessions/git/base.ts
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
@@ -2595,7 +2778,7 @@ var MAX_PREEXISTING_FILES = 200;
 var DELETED = "deleted";
 async function fingerprintFile(cwd, path) {
   try {
-    const stats = await lstat(join5(cwd, path));
+    const stats = await lstat2(join6(cwd, path));
     return `${stats.size}:${Math.trunc(stats.mtimeMs)}`;
   } catch {
     return DELETED;
@@ -2852,8 +3035,12 @@ async function isUntracked(cwd, path) {
   const out = await runGit(["ls-files", "--others", "--exclude-standard", "--", path], cwd);
   return out.trim() !== "";
 }
+function isOutputOverflow(err) {
+  return err?.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER";
+}
 async function getWorkspaceDiff(cwd, path, staged, baseline) {
   const base = await resolveBaseFor(cwd, baseline);
+  const version = await currentFileVersion(cwd, path);
   const pathspec = await withRenameSource(cwd, base.sha, path);
   const numstat = await runGitDiff(
     ["--relative", "--numstat", "-M", base.sha, "--", ...pathspec],
@@ -2863,13 +3050,27 @@ async function getWorkspaceDiff(cwd, path, staged, baseline) {
   if (binary) {
     return { path, staged, patch: null, binary: true };
   }
-  let patch = await runGitDiff(["--relative", "-M", base.sha, "--", ...pathspec], cwd);
-  if (patch.trim() === "" && await isUntracked(cwd, path)) {
-    patch = await runGitDiffAllowingExitCodes(["--no-index", "--", "/dev/null", path], cwd, [
-      1
-    ]).catch(() => "");
+  try {
+    let patch = await runGitDiff(["--relative", "-M", base.sha, "--", ...pathspec], cwd);
+    if (patch.trim() === "" && await isUntracked(cwd, path)) {
+      patch = await runGitDiffAllowingExitCodes(["--no-index", "--", "/dev/null", path], cwd, [
+        1
+      ]).catch((err) => {
+        if (isOutputOverflow(err)) throw err;
+        return "";
+      });
+    }
+    return {
+      path,
+      staged,
+      patch: patch || null,
+      binary: false,
+      ...version === void 0 ? {} : { version }
+    };
+  } catch (err) {
+    if (isOutputOverflow(err)) return { path, staged, patch: null, binary: false, tooLarge: true };
+    throw err;
   }
-  return { path, staged, patch: patch || null, binary: false };
 }
 
 // src/ws/server.ts
@@ -3092,7 +3293,7 @@ function resolveSessionAttention(report, lastActivityAt, nowMs) {
 // src/sessions/tmux/create.ts
 import { access } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 var InvalidCwdError = class extends Error {
   constructor(cwd) {
     super(`working directory does not exist: ${cwd}`);
@@ -3100,7 +3301,7 @@ var InvalidCwdError = class extends Error {
   }
 };
 function worktreePathFor(sessionId) {
-  return join6(homedir5(), ".bondsmith", "worktrees", sessionId);
+  return join7(homedir5(), ".bondsmith", "worktrees", sessionId);
 }
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
@@ -3484,6 +3685,7 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
         broadcast,
         getWorkspaceStatus,
         getWorkspaceDiff,
+        readFileRange,
         validateProjectPath,
         hostname: () => hostname(),
         daemonFingerprint,
@@ -3524,10 +3726,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join7(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join7(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join7(repoRoot, ".env.local");
-  const envDefault = join7(repoRoot, ".env");
+  const repoRoot = join8(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
+  if (!existsSync(join8(repoRoot, "pnpm-workspace.yaml"))) return;
+  const envLocal = join8(repoRoot, ".env.local");
+  const envDefault = join8(repoRoot, ".env");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();
@@ -3581,6 +3783,7 @@ async function start() {
     ptyAttachments,
     getWorkspaceStatus,
     getWorkspaceDiff,
+    readFileRange,
     validateProjectPath,
     hostname: hostname2,
     pendingAuthorizations,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.7",
+	"version": "0.1.8",
 	"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",