@bondsmith/bondsmithd 0.1.8 → 0.1.10

package/README.md

@@ -81,6 +81,21 @@ The daemon reads it on its 5-second tick and shows it on the session. Anything e
 a report dated in the future. A `waiting` or `done` report is dropped once the pane writes output more
 than 2 seconds after it, since that means the agent moved on; a `working` report is not.
 
+An agent can also share the plan it is working against, which Bondsmith shows above the session's
+changes. Run this from inside the session's pane once the plan is agreed, and again whenever it changes:
+
+```sh
+tmux set-option -t "$TMUX_PANE" -q @bondsmith-plan "$(cat <<'EOF'
+# What the session is doing
+- step one
+- step two
+EOF
+)"
+```
+
+The value is markdown, cut at 32,768 characters. The daemon reads it only when the browser asks, so
+unlike the state report it has no timestamp and is not dropped when the pane writes output.
+
 An agent with no hook can still get attention by ringing the terminal bell (`printf '\a'`). A bell
 rung in a session nobody has looked at marks it as waiting, whatever its last report said, until tmux
 clears the flag when someone attaches to the session. Agents that can ring the bell for approvals or

package/dist/index.js

@@ -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 = 7;
+var PROTOCOL_VERSION = 8;
 
 // ../../packages/local-agent-protocol/src/project-path.ts
 var PROJECT_PATH_INVALID_REASONS = [
@@ -62,6 +62,7 @@ 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_PLAN_CHARS = 32 * 1024;
 var MAX_TERMINAL_DIMENSION = 1e3;
 var terminalSizeSchema = z2.object({
   cols: z2.number().int().min(1).max(MAX_TERMINAL_DIMENSION),
@@ -202,6 +203,11 @@ var browserMessageSchema = z2.discriminatedUnion("type", [
     staged: z2.boolean(),
     requestId: z2.string().min(1).max(200)
   }),
+  z2.object({
+    type: z2.literal("workspace.getPlan"),
+    sessionId: z2.string(),
+    requestId: z2.string().min(1).max(200)
+  }),
   z2.object({
     type: z2.literal("project.validatePath"),
     path: z2.string().min(1).max(4096),
@@ -291,6 +297,12 @@ var daemonMessageSchema = z2.discriminatedUnion("type", [
     requestId: z2.string(),
     diff: workspaceFileDiffSchema
   }),
+  z2.object({
+    type: z2.literal("workspace.plan"),
+    sessionId: z2.string(),
+    requestId: z2.string(),
+    plan: z2.string().max(MAX_PLAN_CHARS).nullable()
+  }),
   z2.object({
     type: z2.literal("project.pathValidated"),
     requestId: z2.string(),
@@ -406,6 +418,7 @@ var SIGNABLE_ACTIONS = [
   "workspace.getStatus",
   "workspace.getDiff",
   "workspace.readFileRange",
+  "workspace.getPlan",
   "project.validatePath"
 ];
 var envelopeSchema = z3.object({
@@ -891,6 +904,9 @@ 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"];
+function splitNulList(output) {
+  return output.split("\0").filter((entry) => entry.length > 0);
+}
 var GitNotARepoError = class extends Error {
   constructor() {
     super("not a git repository");
@@ -990,7 +1006,7 @@ import { sign } from "crypto";
 import WebSocket from "ws";
 
 // src/version.ts
-var DAEMON_VERSION = true ? "0.1.8" : "dev";
+var DAEMON_VERSION = true ? "0.1.10" : "dev";
 var VERSION_FLAGS = ["--version", "-v"];
 function versionLine() {
   return `bondsmithd ${DAEMON_VERSION} (protocol ${PROTOCOL_VERSION})`;
@@ -1061,6 +1077,16 @@ async function getSessionActivity(tmuxSessionName) {
     return null;
   }
 }
+var PLAN_OPTION = "@bondsmith-plan";
+async function getSessionPlan(tmuxSessionName) {
+  try {
+    const plan = (await runTmux(["show-options", "-qv", "-t", tmuxSessionName, PLAN_OPTION])).trim();
+    return plan ? plan.slice(0, MAX_PLAN_CHARS) : null;
+  } catch (error2) {
+    if (error2 instanceof TmuxNotFoundError) throw error2;
+    return null;
+  }
+}
 async function listTmuxSessions(formatString) {
   try {
     return await runTmux(["list-sessions", "-F", formatString]);
@@ -1331,6 +1357,14 @@ function createOutputPacer(options) {
   };
 }
 
+// src/ws/sanitize-insert-text.ts
+var DISALLOWED_CHARACTERS = /[\x00-\x08\x0b-\x1f\x7f-\x9f‪-‮⁦-⁩]/g;
+function sanitizeInsertText(text) {
+  const withLineFeeds = text.replace(/\r\n?/g, "\n");
+  const sanitized = withLineFeeds.replace(DISALLOWED_CHARACTERS, "");
+  return { text: sanitized, strippedCount: withLineFeeds.length - sanitized.length };
+}
+
 // src/ws/router.ts
 var SIGNABLE_ACTION_SET = new Set(SIGNABLE_ACTIONS);
 function isSignableAction(type) {
@@ -1614,10 +1648,14 @@ async function dispatch(conn, message, {
     case "session.insertText": {
       const session = getSessionOrError(sessionManager, conn, message.sessionId);
       if (!session) return;
+      const { text, strippedCount } = sanitizeInsertText(message.text);
+      if (strippedCount > 0) {
+        console.warn(`bondsmithd: stripped ${strippedCount} control characters from inserted text`);
+      }
       try {
         await sendKeysLiteral(
           session.tmuxSessionName,
-          `${BRACKETED_PASTE_START}${message.text}${BRACKETED_PASTE_END}`
+          `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`
         );
       } catch (err) {
         conn.send(error(errorMessageOf(err, "failed to insert text")));
@@ -1709,6 +1747,22 @@ async function dispatch(conn, message, {
       }
       return;
     }
+    case "workspace.getPlan": {
+      const session = getSessionOrError(sessionManager, conn, message.sessionId, message.requestId);
+      if (!session) return;
+      try {
+        const plan = await getSessionPlan(session.tmuxSessionName);
+        conn.send({
+          type: "workspace.plan",
+          sessionId: message.sessionId,
+          requestId: message.requestId,
+          plan
+        });
+      } catch (err) {
+        conn.send(error(errorMessageOf(err, "failed to read the session plan"), message.requestId));
+      }
+      return;
+    }
     case "project.validatePath": {
       try {
         const result = await validateProjectPath2(message.path);
@@ -1821,6 +1875,10 @@ var ConnectionAuthState = class {
   isRevoked() {
     return this.revoked;
   }
+  /** Unsolicited daemon broadcasts (session.created/updated) go only to connections that completed the handshake and still hold authority. */
+  canReceiveBroadcasts() {
+    return this.authenticated !== null && !this.revoked;
+  }
   /** The controller/account this connection authenticated as, or null before a successful handshake. Used by verify-command.ts to reject an envelope signed by a DIFFERENT controller than the one that authenticated this connection. */
   getAuthenticatedIdentity() {
     return this.authenticated;
@@ -1998,7 +2056,7 @@ function startRelayClient(deps) {
   let reconnectTimer;
   function broadcast(message) {
     for (const entry of sessions.values()) {
-      entry.conn.send(message);
+      if (entry.connectionAuth.canReceiveBroadcasts()) entry.conn.send(message);
     }
   }
   const routerDeps = { ...deps, broadcast };
@@ -2796,7 +2854,7 @@ async function listChangedPaths(cwd, baseSha) {
     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);
+  const paths = [...splitNulList(tracked), ...splitNulList(untracked)];
   return [...new Set(paths)];
 }
 async function captureBaseline(cwd, options) {
@@ -2908,7 +2966,7 @@ async function isGitRepo(cwd) {
 }
 function parseNumstat(output) {
   const map = /* @__PURE__ */ new Map();
-  const fields = output.split("\0").filter((f) => f.length > 0);
+  const fields = splitNulList(output);
   let i = 0;
   while (i < fields.length) {
     const line = fields[i];
@@ -2949,7 +3007,7 @@ function isStatusLetter(letter) {
   return letter in STATUS_BY_LETTER;
 }
 function parseNameStatus(output) {
-  const fields = output.split("\0").filter((f) => f.length > 0);
+  const fields = splitNulList(output);
   const changed = [];
   let i = 0;
   while (i < fields.length) {
@@ -2968,16 +3026,57 @@ function parseNameStatus(output) {
   }
   return changed;
 }
+var reportedFailures = /* @__PURE__ */ new Map();
+async function loadDefaultBranchView(cwd, baseSha) {
+  const defaultRef = await findDefaultBranchRef(cwd);
+  if (!defaultRef) {
+    reportedFailures.delete(cwd);
+    return null;
+  }
+  try {
+    const defaultSha = (await runGit(["rev-parse", "--verify", "--quiet", `${defaultRef}^{commit}`], cwd)).trim();
+    const forkSha = (await runGit(["merge-base", baseSha, defaultSha], cwd)).trim();
+    const [differing, deletedSinceFork] = await Promise.all([
+      runGitDiff(["--relative", "--name-only", "-z", defaultSha], cwd),
+      runGitDiff(["--relative", "--name-only", "--diff-filter=D", "-z", forkSha, defaultSha], cwd)
+    ]);
+    reportedFailures.delete(cwd);
+    return {
+      differing: new Set(splitNulList(differing)),
+      deletedSinceFork: new Set(splitNulList(deletedSinceFork))
+    };
+  } catch (error2) {
+    const signature = `${defaultRef}: ${error2 instanceof Error ? error2.message : String(error2)}`;
+    if (reportedFailures.get(cwd) !== signature) {
+      reportedFailures.set(cwd, signature);
+      console.error("Failed to compare with the default branch; listing files unfiltered", {
+        cwd,
+        defaultRef,
+        error: error2
+      });
+    }
+    return null;
+  }
+}
+function dropAlreadyOnDefaultBranch(files, view) {
+  if (!view) return files;
+  return files.filter((file) => {
+    if (file.status === "untracked") return true;
+    if (file.status === "deleted") return !view.deletedSinceFork.has(file.path);
+    return view.differing.has(file.path) || file.previousPath !== void 0 && view.differing.has(file.previousPath);
+  });
+}
 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 resolveBaseFor(cwd, baseline);
-  const [nameStatusRaw, numstatRaw, untrackedRaw] = await Promise.all([
+  const [nameStatusRaw, numstatRaw, untrackedRaw, defaultBranchView] = await Promise.all([
     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)
+    runGit(["ls-files", "--others", "--exclude-standard", "-z"], cwd),
+    loadDefaultBranchView(cwd, base.sha)
   ]);
   const numstat = parseNumstat(numstatRaw);
   const tracked = parseNameStatus(nameStatusRaw).map((changed) => {
@@ -2992,7 +3091,7 @@ async function getWorkspaceStatus(cwd, baseline) {
       binary: counts?.binary ?? false
     };
   });
-  const untracked = untrackedRaw.split("\0").filter((path) => path.length > 0).map((path) => ({
+  const untracked = splitNulList(untrackedRaw).map((path) => ({
     path,
     status: "untracked",
     staged: false,
@@ -3000,7 +3099,7 @@ async function getWorkspaceStatus(cwd, baseline) {
     deletions: null,
     binary: false
   }));
-  const files = [...tracked, ...untracked];
+  const files = dropAlreadyOnDefaultBranch([...tracked, ...untracked], defaultBranchView);
   return {
     isGitRepo: true,
     branch,
@@ -3631,7 +3730,9 @@ function createDaemonWebSocketServer(httpServer, config, daemonFingerprint, pend
   function broadcast(message) {
     const payload = JSON.stringify(message);
     for (const client of wss.clients) {
-      if (client.readyState === client.OPEN) client.send(payload);
+      if (client.readyState === client.OPEN && connectionAuthBySocket.get(client)?.canReceiveBroadcasts()) {
+        client.send(payload);
+      }
     }
   }
   sessionManager.onSessionUpdated((session) => {

package/package.json

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