@bondsmith/bondsmithd 0.1.1-staging.0 → 0.1.2

package/README.md

@@ -37,7 +37,7 @@ Environment variables (all optional):
 ```
 PORT=4577                                    # defaults to 4577
 ALLOWED_ORIGINS=https://app.bondsmith.dev
-BONDSMITH_RELAY_URL=wss://relay.bondsmith.dev # defaults to a local-only address; set this for a real install
+BONDSMITH_RELAY_URL=ws://127.0.0.1:8787       # defaults to production; set this when developing bondsmithd against a local apps/relay
 ```
 
 `BONDSMITH_DEV_TUNNEL_TOKEN` also exists but only applies to the legacy direct-connection path
@@ -54,10 +54,11 @@ BONDSMITH_RELAY_URL=wss://relay.bondsmith.dev # defaults to a local-only address
 
 ## Production connectivity (current status)
 
-`bondsmithd` connects outbound to the Bondsmith relay by default (`BONDSMITH_RELAY_ENABLED=true`),
-which is what a production account actually uses — no dev-tunnel token involved. Point
-`BONDSMITH_RELAY_URL` at `wss://relay.bondsmith.dev` for a real install (see "Environment
-variables" above); it defaults to a local-only address for monorepo development.
+`bondsmithd` connects outbound to the Bondsmith relay by default (`BONDSMITH_RELAY_ENABLED=true`,
+`BONDSMITH_RELAY_URL=wss://relay.bondsmith.dev`), which is what a production account actually
+uses — no dev-tunnel token involved, no config needed for a real install. Override
+`BONDSMITH_RELAY_URL` to a local apps/relay instance (see "Environment variables" above) only when
+developing bondsmithd itself.
 
 The dev-tunnel-token requirement only applies to the legacy direct-connection path
 (`BONDSMITH_RELAY_ENABLED=false`), which still 404s the token-handoff route in production by

package/dist/index.js

@@ -10,6 +10,9 @@ import { fileURLToPath } from "url";
 // ../../packages/local-agent-protocol/src/session.ts
 var SESSION_STATUSES = ["running", "exited"];
 
+// ../../packages/local-agent-protocol/src/messages.ts
+var REPLAYED_COMMAND_MESSAGE = "command already used (replay rejected)";
+
 // ../../packages/local-agent-protocol/src/schemas.ts
 import { z as z2 } from "zod";
 
@@ -494,7 +497,7 @@ var environmentSchema = z8.object({
   // (BD-432) — defaults to production so a real install works with zero
   // config; overridden to the local dev server (e.g. http://localhost:4000)
   // when developing bondsmithd itself against a local web app.
-  BONDSMITH_API_URL: z8.string().url().default("https://staging.bondsmith.dev"),
+  BONDSMITH_API_URL: z8.string().url().default("https://app.bondsmith.dev"),
   // Interface the WebSocket/HTTP server binds to. Defaults to loopback-only
   // (never reachable from outside this machine) — real access control is
   // ALLOWED_ORIGINS + the dev-tunnel token, not the bind address, but
@@ -505,18 +508,19 @@ var environmentSchema = z8.object({
   // install needs to touch.
   BONDSMITH_BIND_HOST: z8.string().min(1).default("127.0.0.1"),
   // BD-450/BD-483/BD-484: connect outbound to the Bondsmith relay instead of
-  // (or alongside) listening inbound. ON by default — local dev is meant to
-  // mirror production's actual topology (browser -> relay -> daemon), not
-  // diverge from it, so plain `pnpm --filter @bondsmith/bondsmithd dev`
-  // connects outbound to a locally-running apps/relay (its own `pnpm dev`
-  // on the default port below) exactly like a real deployment would.
-  // BONDSMITH_RELAY_URL defaults to that same local apps/relay instance for
-  // the same reason. The existing inbound listener is completely
-  // unaffected either way — it keeps running regardless, so direct-
-  // connection debugging (bypassing the relay entirely) is still possible
-  // by setting BONDSMITH_RELAY_ENABLED=false explicitly.
+  // (or alongside) listening inbound. ON by default. The existing inbound
+  // listener is completely unaffected either way — it keeps running
+  // regardless, so direct-connection debugging (bypassing the relay
+  // entirely) is still possible by setting BONDSMITH_RELAY_ENABLED=false
+  // explicitly.
   BONDSMITH_RELAY_ENABLED: z8.string().default("true").transform((value) => value === "true" || value === "1"),
-  BONDSMITH_RELAY_URL: z8.string().url().default("wss://relay-staging.bondsmith.dev")
+  // Defaults to production, mirroring BONDSMITH_API_URL above, so a real
+  // install works with zero config — a bare `bondsmithd` used to silently
+  // connect outbound to loopback (nothing listening there) with no error,
+  // looking healthy while never reaching relay at all. Override to a local
+  // apps/relay instance (its own `pnpm dev` default port) when developing
+  // bondsmithd itself against a local relay.
+  BONDSMITH_RELAY_URL: z8.string().url().default("wss://relay.bondsmith.dev")
 });
 function getDaemonConfig(env = process.env) {
   const parsed = environmentSchema.parse(env);
@@ -760,6 +764,27 @@ var TmuxNoServerRunningError = class extends Error {
     this.name = "TmuxNoServerRunningError";
   }
 };
+var TmuxNotFoundError = class extends Error {
+  constructor() {
+    super(
+      [
+        "bondsmithd requires tmux, and it was not found on PATH.",
+        "",
+        "Install it:",
+        "  macOS (Homebrew):     brew install tmux",
+        "  Debian/Ubuntu:        sudo apt-get install tmux",
+        "  Fedora/RHEL:          sudo dnf install tmux",
+        "  Arch:                 sudo pacman -S tmux",
+        "",
+        "If tmux is already installed, start bondsmithd from a normal interactive shell \u2014",
+        "not a LaunchAgent, Docker container, or other minimal-PATH context. Those often",
+        "don't inherit the PATH tmux was installed into (e.g. Homebrew's /opt/homebrew/bin",
+        "on Apple Silicon)."
+      ].join("\n")
+    );
+    this.name = "TmuxNotFoundError";
+  }
+};
 var SENSITIVE_ENV_KEYS = ["ANTHROPIC_API_KEY", "BONDSMITH_DEV_TUNNEL_TOKEN"];
 function filterSpawnEnv(env) {
   const filtered = { ...env };
@@ -767,8 +792,13 @@ function filterSpawnEnv(env) {
   return filtered;
 }
 async function runTmux(args, options) {
-  const { stdout } = await execFile("tmux", args, { ...options, encoding: "utf8" });
-  return stdout;
+  try {
+    const { stdout } = await execFile("tmux", args, { ...options, encoding: "utf8" });
+    return stdout;
+  } catch (error2) {
+    if (error2?.code === "ENOENT") throw new TmuxNotFoundError();
+    throw error2;
+  }
 }
 async function sendKeysLiteral(tmuxSessionName, text) {
   await runTmux(["send-keys", "-t", tmuxSessionName, "-l", text]);
@@ -991,7 +1021,7 @@ function verifyRejectionMessage(reason) {
     case "expired":
       return "command envelope expired";
     case "replayed":
-      return "command already used (replay rejected)";
+      return REPLAYED_COMMAND_MESSAGE;
     case "wrong_daemon":
       return "command not addressed to this daemon";
     case "wrong_connection":
@@ -1005,6 +1035,7 @@ var BRACKETED_PASTE_START = "\x1B[200~";
 var BRACKETED_PASTE_END = "\x1B[201~";
 function createRouterConnection(connectionAuth, send, markControllerId, ptyAttachments) {
   const outputListeners = /* @__PURE__ */ new Map();
+  const attachLocks = /* @__PURE__ */ new Map();
   const conn = {
     subscriptions: /* @__PURE__ */ new Set(),
     send,
@@ -1013,7 +1044,18 @@ function createRouterConnection(connectionAuth, send, markControllerId, ptyAttac
     },
     getOutputListener: (sessionId) => outputListeners.get(sessionId),
     connectionAuth,
-    markControllerId
+    markControllerId,
+    withAttachLock: (sessionId, fn) => {
+      const previous = attachLocks.get(sessionId) ?? Promise.resolve();
+      const next = previous.catch(() => {
+      }).then(fn);
+      attachLocks.set(
+        sessionId,
+        next.catch(() => {
+        })
+      );
+      return next;
+    }
   };
   function releaseAllSubscriptions() {
     for (const sessionId of conn.subscriptions) {
@@ -1117,36 +1159,38 @@ async function dispatch(conn, message, {
       }
       const session = getSessionOrError(sessionManager, conn, message.sessionId);
       if (!session) return;
-      const previousListener = conn.getOutputListener(message.sessionId);
-      const onData = (data) => {
-        conn.send({ type: "terminal.output", sessionId: message.sessionId, data });
-      };
-      if (previousListener && await ptyAttachments.swapListener(
-        message.sessionId,
-        session.tmuxSessionName,
-        previousListener,
-        onData
-      )) {
+      await conn.withAttachLock(message.sessionId, async () => {
+        const previousListener = conn.getOutputListener(message.sessionId);
+        const onData = (data) => {
+          conn.send({ type: "terminal.output", sessionId: message.sessionId, data });
+        };
+        if (previousListener && await ptyAttachments.swapListener(
+          message.sessionId,
+          session.tmuxSessionName,
+          previousListener,
+          onData
+        )) {
+          conn.subscriptions.add(message.sessionId);
+          conn.registerOutputListener(message.sessionId, onData);
+          conn.send({ type: "session.attached", sessionId: message.sessionId });
+          return;
+        }
+        if (previousListener) {
+          ptyAttachments.release(message.sessionId, previousListener);
+        }
+        const attached = await ptyAttachments.ensureAttached(
+          message.sessionId,
+          session.tmuxSessionName,
+          onData
+        );
+        if (!attached) {
+          conn.send(error("failed to attach to session"));
+          return;
+        }
         conn.subscriptions.add(message.sessionId);
         conn.registerOutputListener(message.sessionId, onData);
         conn.send({ type: "session.attached", sessionId: message.sessionId });
-        return;
-      }
-      if (previousListener) {
-        ptyAttachments.release(message.sessionId, previousListener);
-      }
-      const attached = await ptyAttachments.ensureAttached(
-        message.sessionId,
-        session.tmuxSessionName,
-        onData
-      );
-      if (!attached) {
-        conn.send(error("failed to attach to session"));
-        return;
-      }
-      conn.subscriptions.add(message.sessionId);
-      conn.registerOutputListener(message.sessionId, onData);
-      conn.send({ type: "session.attached", sessionId: message.sessionId });
+      });
       return;
     }
     case "session.input": {
@@ -2329,7 +2373,12 @@ var PtyAttachmentManager = class {
           cwd: process.env.HOME,
           env: filterSpawnEnv(process.env)
         });
-      } catch {
+      } catch (error2) {
+        if (error2?.code === "ENOENT") {
+          console.error(`
+${new TmuxNotFoundError().message}
+`);
+        }
         return false;
       }
       handle = { process: ptyProcess, refCount: 0, dataListeners: /* @__PURE__ */ new Set() };
@@ -2488,6 +2537,12 @@ async function discoverSessions() {
     return Promise.all(sessions.map((session) => enrichSessionWithGitMetadata(session)));
   } catch (error2) {
     if (error2 instanceof TmuxNoServerRunningError) return [];
+    if (error2 instanceof TmuxNotFoundError) {
+      console.error(`
+${error2.message}
+`);
+      process.exit(1);
+    }
     throw error2;
   }
 }
@@ -2551,6 +2606,9 @@ var SessionManager = class {
       const output = await listTmuxSessions("#{session_name}");
       liveSessionNames = new Set(output.split("\n").filter((name) => name.length > 0));
     } catch (error2) {
+      if (error2 instanceof TmuxNotFoundError) console.error(`
+${error2.message}
+`);
       if (!(error2 instanceof TmuxNoServerRunningError)) return;
     }
     await Promise.all(

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bondsmith/bondsmithd",
-	"version": "0.1.1-staging.0",
+	"version": "0.1.2",
 	"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",