@bondsmith/bondsmithd 0.1.4 → 0.1.6

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 join6 } from "path";
+import { dirname as dirname4, join as join7 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/local-agent-protocol/src/session.ts
@@ -951,7 +951,7 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.4" : "dev";
+var DAEMON_VERSION = true ? "0.1.6" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1378,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) {
@@ -1400,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;
@@ -1432,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);
@@ -1571,10 +1574,13 @@ 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);
+        const status = await getWorkspaceStatus2(
+          session.cwd,
+          sessionManager.getBaseline(session.id)
+        );
         conn.send({
           type: "workspace.status",
           sessionId: message.sessionId,
@@ -1582,15 +1588,20 @@ 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);
+        const diff = await getWorkspaceDiff2(
+          session.cwd,
+          message.path,
+          message.staged,
+          sessionManager.getBaseline(session.id)
+        );
         conn.send({
           type: "workspace.diff",
           sessionId: message.sessionId,
@@ -1598,7 +1609,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;
     }
@@ -2538,6 +2549,10 @@ function presentPendingAuthorizationOnTerminal(store) {
   };
 }
 
+// src/sessions/git/baseline.ts
+import { lstat } from "fs/promises";
+import { join as join5 } from "path";
+
 // src/sessions/git/base.ts
 var EMPTY_TREE_SHA = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
 var DEFAULT_BRANCH_CANDIDATES = ["origin/main", "origin/master", "main", "master"];
@@ -2571,6 +2586,107 @@ async function resolveComparisonBase(cwd) {
   return mergeBase ? { sha: mergeBase, ref: defaultRef } : { sha: "HEAD", ref: null };
 }
 
+// src/sessions/git/baseline.ts
+var SESSION_START_REF = "session start";
+var MAX_PREEXISTING_FILES = 200;
+var DELETED = "deleted";
+async function fingerprintFile(cwd, path) {
+  try {
+    const stats = await lstat(join5(cwd, path));
+    return `${stats.size}:${Math.trunc(stats.mtimeMs)}`;
+  } catch {
+    return DELETED;
+  }
+}
+async function headSha(cwd) {
+  try {
+    return (await runGit(["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], cwd)).trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function listChangedPaths(cwd, baseSha) {
+  const [tracked, untracked] = await Promise.all([
+    runGitDiff(["--relative", "--name-only", "-z", baseSha], cwd),
+    runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd)
+  ]);
+  const paths = [...tracked.split("\0"), ...untracked.split("\0")].filter((p) => p.length > 0);
+  return [...new Set(paths)];
+}
+async function captureBaseline(cwd, options) {
+  try {
+    await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  } catch {
+    return null;
+  }
+  try {
+    const baseSha = await headSha(cwd);
+    const preexisting = /* @__PURE__ */ new Map();
+    if (!options.freshCheckout) {
+      const changed = await listChangedPaths(cwd, baseSha ?? EMPTY_TREE_SHA);
+      for (const path of changed.slice(0, MAX_PREEXISTING_FILES)) {
+        preexisting.set(path, await fingerprintFile(cwd, path));
+      }
+    }
+    return { baseSha, preexisting };
+  } catch (error2) {
+    console.error("Failed to take a session baseline; comparing against the default branch", {
+      cwd,
+      error: error2
+    });
+    return null;
+  }
+}
+async function commitExists(cwd, sha) {
+  try {
+    await runGit(["rev-parse", "--verify", "--quiet", `${sha}^{commit}`], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveBaseFor(cwd, baseline) {
+  if (!baseline) return resolveComparisonBase(cwd);
+  if (baseline.baseSha !== null && !await commitExists(cwd, baseline.baseSha)) {
+    return resolveComparisonBase(cwd);
+  }
+  return { sha: baseline.baseSha ?? EMPTY_TREE_SHA, ref: SESSION_START_REF };
+}
+async function dropPreexisting(cwd, entries, baseline) {
+  if (baseline.preexisting.size === 0) return entries;
+  const untouched = await Promise.all(
+    entries.map(async (entry) => {
+      const before = baseline.preexisting.get(entry.path);
+      return before !== void 0 && before === await fingerprintFile(cwd, entry.path);
+    })
+  );
+  return entries.filter((_, index) => !untouched[index]);
+}
+function encodeBaseline(baseline) {
+  const serialized = {
+    v: 1,
+    base: baseline.baseSha,
+    files: [...baseline.preexisting]
+  };
+  return Buffer.from(JSON.stringify(serialized), "utf8").toString("base64url");
+}
+function isSerializedBaseline(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return candidate.v === 1 && (candidate.base === null || typeof candidate.base === "string") && Array.isArray(candidate.files) && candidate.files.every(
+    (file) => Array.isArray(file) && file.length === 2 && typeof file[0] === "string" && typeof file[1] === "string"
+  );
+}
+function decodeBaseline(encoded) {
+  try {
+    const parsed = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+    if (!isSerializedBaseline(parsed)) return null;
+    return { baseSha: parsed.base, preexisting: new Map(parsed.files) };
+  } catch {
+    return null;
+  }
+}
+
 // src/sessions/git/status.ts
 async function getCurrentBranch(cwd) {
   try {
@@ -2666,15 +2782,15 @@ function parseNameStatus(output) {
   }
   return changed;
 }
-async function getWorkspaceStatus(cwd) {
+async function getWorkspaceStatus(cwd, baseline) {
   const branch = await getCurrentBranch(cwd);
   if (branch === null && !await isGitRepo(cwd)) {
     return { isGitRepo: false, branch: null, files: [] };
   }
-  const base = await resolveComparisonBase(cwd);
+  const base = await resolveBaseFor(cwd, baseline);
   const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
-    runGitDiff(["--name-status", "-z", "-M", base.sha], cwd),
-    runGitDiff(["--numstat", "-z", "-M", base.sha], cwd),
+    runGitDiff(["--relative", "--name-status", "-z", "-M", base.sha], cwd),
+    runGitDiff(["--relative", "--numstat", "-z", "-M", base.sha], cwd),
     runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd)
   ]);
   const numstat = parseNumstat(numstatRaw);
@@ -2698,13 +2814,19 @@ async function getWorkspaceStatus(cwd) {
     deletions: null,
     binary: false
   }));
-  return { isGitRepo: true, branch, baseRef: base.ref, files: [...tracked, ...untracked] };
+  const files = [...tracked, ...untracked];
+  return {
+    isGitRepo: true,
+    branch,
+    baseRef: base.ref,
+    files: baseline ? await dropPreexisting(cwd, files, baseline) : files
+  };
 }
-async function enrichSessionWithGitMetadata(session) {
+async function enrichSessionWithGitMetadata(session, baseline) {
   const [branch, repositoryFullName, status, lastActivityAt] = await Promise.all([
     getCurrentBranch(session.cwd),
     getRepositoryFullName(session.cwd),
-    getWorkspaceStatus(session.cwd),
+    getWorkspaceStatus(session.cwd, baseline),
     getPaneActivity(session.tmuxSessionName)
   ]);
   const changedFileCount = status.isGitRepo ? new Set(status.files.map((f) => f.path)).size : null;
@@ -2719,7 +2841,7 @@ 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 nameStatus = await runGitDiff(["--relative", "--name-status", "-z", "-M", baseSha], cwd);
   const previousPath = parseNameStatus(nameStatus).find((c) => c.path === path)?.previousPath;
   return previousPath === void 0 ? [path] : [previousPath, path];
 }
@@ -2727,15 +2849,18 @@ 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);
+async function getWorkspaceDiff(cwd, path, staged, baseline) {
+  const base = await resolveBaseFor(cwd, baseline);
   const pathspec = await withRenameSource(cwd, base.sha, path);
-  const numstat = await runGitDiff(["--numstat", "-M", base.sha, "--", ...pathspec], cwd);
+  const numstat = await runGitDiff(
+    ["--relative", "--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);
+  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
@@ -2814,7 +2939,7 @@ ${new TmuxNotFoundError().message}
         }
         return false;
       }
-      const created = { process: ptyProcess, refCount: 0, dataListeners: /* @__PURE__ */ new Set() };
+      const created = { process: ptyProcess, dataListeners: /* @__PURE__ */ new Set([onData]) };
       this.handles.set(sessionId, created);
       ptyProcess.onData((data) => {
         for (const listener of created.dataListeners) listener(data);
@@ -2822,12 +2947,9 @@ ${new TmuxNotFoundError().message}
       ptyProcess.onExit(() => {
         if (this.handles.get(sessionId) === created) this.handles.delete(sessionId);
       });
-      created.refCount += 1;
-      created.dataListeners.add(onData);
       return true;
     }
     await this.sendPaneSnapshot(tmuxSessionName, onData);
-    handle.refCount += 1;
     handle.dataListeners.add(onData);
     return true;
   }
@@ -2854,8 +2976,7 @@ ${new TmuxNotFoundError().message}
   release(sessionId, onData) {
     const handle = this.handles.get(sessionId);
     if (!handle?.dataListeners.delete(onData)) return;
-    handle.refCount -= 1;
-    if (handle.refCount <= 0) {
+    if (handle.dataListeners.size === 0) {
       handle.process.kill();
       this.handles.delete(sessionId);
     }
@@ -2936,7 +3057,7 @@ async function removeWorktree(sourceCwd, worktreePath) {
 // src/sessions/tmux/create.ts
 import { access } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var InvalidCwdError = class extends Error {
   constructor(cwd) {
     super(`working directory does not exist: ${cwd}`);
@@ -2944,7 +3065,7 @@ var InvalidCwdError = class extends Error {
   }
 };
 function worktreePathFor(sessionId) {
-  return join5(homedir5(), ".bondsmith", "worktrees", sessionId);
+  return join6(homedir5(), ".bondsmith", "worktrees", sessionId);
 }
 async function createTmuxSession(input) {
   const sourceCwd = expandHome(input.cwd);
@@ -2963,6 +3084,7 @@ async function createTmuxSession(input) {
   }
   const tmuxSessionName = tmuxSessionNameFor(input.id);
   const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const baseline = await captureBaseline(cwd, { freshCheckout: worktreeOf !== null });
   await runTmux(["new-session", "-d", "-s", tmuxSessionName, "-c", cwd, input.command], {
     env: filterSpawnEnv(process.env)
   });
@@ -2974,6 +3096,15 @@ async function createTmuxSession(input) {
   if (worktreeOf) {
     await runTmux(["set-option", "-t", tmuxSessionName, "@bondsmith-worktree-of", worktreeOf]);
   }
+  if (baseline) {
+    await runTmux([
+      "set-option",
+      "-t",
+      tmuxSessionName,
+      "@bondsmith-baseline",
+      encodeBaseline(baseline)
+    ]);
+  }
   const session = {
     id: input.id,
     title: input.title,
@@ -2988,7 +3119,7 @@ async function createTmuxSession(input) {
     changedFileCount: null,
     worktreeOf
   };
-  return enrichSessionWithGitMetadata(session);
+  return { session: await enrichSessionWithGitMetadata(session, baseline), baseline };
 }
 async function stopTmuxSession(tmuxSessionName) {
   await runTmux(["kill-session", "-t", tmuxSessionName]);
@@ -2996,6 +3127,7 @@ async function stopTmuxSession(tmuxSessionName) {
 
 // src/sessions/tmux/parse.ts
 var FIELD_COUNT = 7;
+var BASELINE_FIELD_INDEX = 7;
 function parseTmuxSessions(output) {
   const sessions = [];
   for (const line of output.split("\n")) {
@@ -3025,6 +3157,19 @@ function parseTmuxSessions(output) {
   }
   return sessions;
 }
+function parseSessionBaselines(output) {
+  const baselines = /* @__PURE__ */ new Map();
+  for (const line of output.split("\n")) {
+    const fields = line.split("	");
+    const sessionName = fields[0];
+    const id = fields[1];
+    const encoded = fields[BASELINE_FIELD_INDEX];
+    if (!sessionName || !isBondsmithTmuxSessionName(sessionName) || !id || !encoded) continue;
+    const baseline = decodeBaseline(encoded);
+    if (baseline) baselines.set(id, baseline);
+  }
+  return baselines;
+}
 
 // src/sessions/tmux/discover.ts
 var LIST_FORMAT = [
@@ -3034,15 +3179,21 @@ var LIST_FORMAT = [
   "#{@bondsmith-command}",
   "#{@bondsmith-cwd}",
   "#{@bondsmith-started-at}",
-  "#{@bondsmith-worktree-of}"
+  "#{@bondsmith-worktree-of}",
+  "#{@bondsmith-baseline}"
 ].join("	");
 async function discoverSessions() {
   try {
     const output = await listTmuxSessions(LIST_FORMAT);
-    const sessions = parseTmuxSessions(output);
-    return Promise.all(sessions.map((session) => enrichSessionWithGitMetadata(session)));
+    const baselines = parseSessionBaselines(output);
+    const sessions = await Promise.all(
+      parseTmuxSessions(output).map(
+        (session) => enrichSessionWithGitMetadata(session, baselines.get(session.id))
+      )
+    );
+    return { sessions, baselines };
   } catch (error2) {
-    if (error2 instanceof TmuxNoServerRunningError) return [];
+    if (error2 instanceof TmuxNoServerRunningError) return { sessions: [], baselines: /* @__PURE__ */ new Map() };
     if (error2 instanceof TmuxNotFoundError) {
       console.error(`
 ${error2.message}
@@ -3056,13 +3207,19 @@ ${error2.message}
 // src/sessions/session-manager.ts
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
+  // What each session's folder looked like when it started, so its file list shows only its own changes.
+  baselines = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
   async initialize() {
     const discovered = await discoverSessions();
     this.sessions.clear();
-    for (const session of discovered) {
+    this.baselines.clear();
+    for (const session of discovered.sessions) {
       this.sessions.set(session.id, session);
     }
+    for (const [id, baseline] of discovered.baselines) {
+      this.baselines.set(id, baseline);
+    }
   }
   list() {
     return Array.from(this.sessions.values());
@@ -3070,6 +3227,10 @@ var SessionManager = class {
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  /** Undefined for a session started before baselines existed, which compares against the default branch. */
+  getBaseline(sessionId) {
+    return this.baselines.get(sessionId);
+  }
   onSessionUpdated(listener) {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -3079,8 +3240,9 @@ var SessionManager = class {
   }
   async create(input) {
     const id = uuidv4();
-    const session = await createTmuxSession({ id, ...input });
+    const { session, baseline } = await createTmuxSession({ id, ...input });
     this.sessions.set(id, session);
+    if (baseline) this.baselines.set(id, baseline);
     return session;
   }
   async stop(sessionId) {
@@ -3140,7 +3302,10 @@ ${error2.message}
           return;
         }
         try {
-          const updated = await enrichSessionWithGitMetadata(session);
+          const updated = await enrichSessionWithGitMetadata(
+            session,
+            this.baselines.get(session.id)
+          );
           if (!gitSnapshotEquals(session, updated)) {
             this.sessions.set(session.id, updated);
             this.emitUpdated(updated);
@@ -3157,6 +3322,7 @@ ${error2.message}
   removeAsExited(session) {
     const updated = { ...session, status: "exited" };
     this.sessions.delete(session.id);
+    this.baselines.delete(session.id);
     this.emitUpdated(updated);
     return updated;
   }
@@ -3317,10 +3483,10 @@ if (isVersionRequest(process.argv.slice(2))) {
   process.exit(0);
 }
 function loadRepoRootEnv() {
-  const repoRoot = join6(dirname4(fileURLToPath(import.meta.url)), "..", "..", "..");
-  if (!existsSync(join6(repoRoot, "pnpm-workspace.yaml"))) return;
-  const envLocal = join6(repoRoot, ".env.local");
-  const envDefault = join6(repoRoot, ".env");
+  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");
   loadEnv({ path: existsSync(envLocal) ? envLocal : envDefault });
 }
 loadRepoRootEnv();

package/package.json

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