@band-app/server 0.54.4 → 0.56.0

package/dist/terminal-daemon.mjs

@@ -8929,11 +8929,268 @@ function createLogger(name) {
 }
 
 // ../../packages/host-local/src/terminals/daemon/daemon-server.ts
-import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
-import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync as readFileSync3, renameSync as renameSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { randomBytes as randomBytes3 } from "node:crypto";
+import { chmodSync as chmodSync2, lstatSync as lstatSync2 } from "node:fs";
 import { createServer } from "node:net";
 import { dirname as dirname4, join as join7 } from "node:path";
 
+// ../../packages/host-local/src/daemon-kit/endpoint.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  linkSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  renameSync as renameSync2,
+  statSync as statSync2,
+  unlinkSync
+} from "node:fs";
+import { connect } from "node:net";
+import { dirname as dirname2, join } from "node:path";
+var PROBE_TIMEOUT_MS = 500;
+var PUBLISH_ATTEMPTS = 3;
+function isProvenDead(outcome) {
+  return outcome === "missing" || outcome === "refused";
+}
+function probeEndpoint(socketPath) {
+  let occupied = false;
+  try {
+    lstatSync(socketPath);
+    occupied = true;
+  } catch (err) {
+    return Promise.resolve(errorCode(err) === "ENOENT" ? "missing" : "unknown");
+  }
+  return new Promise((resolve) => {
+    const socket = connect({ path: socketPath });
+    let settled = false;
+    const settle = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(outcome);
+    };
+    const timer = setTimeout(() => settle("unknown"), PROBE_TIMEOUT_MS);
+    socket.once("connect", () => settle("connected"));
+    socket.once("error", (err) => {
+      const code = errorCode(err);
+      if (code === "ECONNREFUSED" || code === "ENOTSOCK") settle("refused");
+      else if (code === "ENOENT") settle(occupied ? "refused" : "missing");
+      else settle("unknown");
+    });
+  });
+}
+function privateBindPath(socketPath) {
+  return join(dirname2(socketPath), `.p${randomBytes(5).toString("hex")}`);
+}
+async function publishEndpoint(boundPath, canonicalPath, supersede) {
+  const identity = entryIdentity(boundPath, statSync2);
+  if (!identity) throw new Error(`Cannot stat the bound daemon socket at ${boundPath}`);
+  for (let attempt = 0; attempt < PUBLISH_ATTEMPTS; attempt++) {
+    try {
+      linkSync(boundPath, canonicalPath);
+    } catch (err) {
+      if (errorCode(err) !== "EEXIST") throw err;
+      if (supersede && retireIncumbent(canonicalPath, supersede)) {
+        renameSync2(boundPath, canonicalPath);
+        return confirmPublished(canonicalPath, identity, true);
+      }
+      const replaced = await replaceProvenDead(boundPath, canonicalPath);
+      if (replaced === "stale") continue;
+      if (replaced !== "renamed") return replaced;
+      return confirmPublished(canonicalPath, identity, false);
+    }
+    try {
+      unlinkSync(boundPath);
+    } catch {
+    }
+    return confirmPublished(canonicalPath, identity, false);
+  }
+  return { status: "inconclusive" };
+}
+async function replaceProvenDead(boundPath, canonicalPath) {
+  const proven = entryIdentity(canonicalPath, lstatSync);
+  const first = await probeEndpoint(canonicalPath);
+  if (first === "connected") return { status: "occupied" };
+  if (!isProvenDead(first)) return { status: "inconclusive" };
+  const now = entryIdentity(canonicalPath, lstatSync);
+  if (!proven || !now || proven.dev !== now.dev || proven.ino !== now.ino) return "stale";
+  const second = await probeEndpoint(canonicalPath);
+  if (second === "connected") return { status: "occupied" };
+  if (!isProvenDead(second)) return { status: "inconclusive" };
+  renameSync2(boundPath, canonicalPath);
+  return "renamed";
+}
+function retireIncumbent(canonicalPath, supersede) {
+  if (!sameEntry(entryIdentity(canonicalPath, lstatSync), supersede.incumbent)) return false;
+  try {
+    linkSync(canonicalPath, supersede.retiredPath);
+  } catch {
+    return false;
+  }
+  if (sameEntry(entryIdentity(supersede.retiredPath, lstatSync), supersede.incumbent)) return true;
+  try {
+    unlinkSync(supersede.retiredPath);
+  } catch {
+  }
+  return false;
+}
+function sameEntry(a, b) {
+  return a !== null && a.dev === b.dev && a.ino === b.ino;
+}
+function confirmPublished(canonicalPath, identity, superseded) {
+  let published;
+  try {
+    const stats = statSync2(canonicalPath, { bigint: true });
+    published = { dev: stats.dev, ino: stats.ino };
+  } catch (err) {
+    return errorCode(err) === "ENOENT" ? { status: "lost" } : { status: "inconclusive" };
+  }
+  return published.dev === identity.dev && published.ino === identity.ino ? { status: "published", identity: published, superseded } : { status: "lost" };
+}
+function endpointOwnership(canonicalPath, owned) {
+  try {
+    const stats = statSync2(canonicalPath, { bigint: true });
+    return stats.dev === owned.dev && stats.ino === owned.ino ? "owned" : "lost";
+  } catch (err) {
+    return errorCode(err) === "ENOENT" ? "lost" : "indeterminate";
+  }
+}
+function ensurePrivateDir(dir) {
+  mkdirSync2(dir, { recursive: true, mode: 448 });
+  const stats = lstatSync(dir);
+  const uid = process.getuid?.();
+  if (!stats.isDirectory()) throw new Error(`${dir} is not a directory`);
+  if (uid !== void 0 && stats.uid !== uid) throw new Error(`${dir} is owned by another user`);
+  if ((stats.mode & 63) !== 0) chmodSync(dir, 448);
+}
+function entryIdentity(path, stat) {
+  try {
+    const stats = stat(path, { bigint: true });
+    return { dev: stats.dev, ino: stats.ino };
+  } catch {
+    return null;
+  }
+}
+function errorCode(err) {
+  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
+}
+
+// ../../packages/host-local/src/daemon-kit/private-files.ts
+import { randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
+import { readFileSync, renameSync as renameSync3, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+function writePrivateFile(path, content) {
+  const tmp = `${path}.${randomBytes2(4).toString("hex")}.tmp`;
+  writeFileSync(tmp, content, { mode: 384 });
+  renameSync3(tmp, path);
+}
+function copyPrivateFile(from, to) {
+  let content;
+  try {
+    content = readFileSync(from, "utf8");
+  } catch {
+    return;
+  }
+  writePrivateFile(to, content);
+}
+function removeRetiredFiles(retired) {
+  for (const path of [retired.socket, retired.token, retired.pid]) {
+    try {
+      unlinkSync2(path);
+    } catch {
+    }
+  }
+}
+function tokenMatches(expected, candidate) {
+  const a = Buffer.from(expected);
+  const b = Buffer.from(candidate);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+
+// ../../packages/host-local/src/daemon-kit/protocol.ts
+import { createHash } from "node:crypto";
+import { basename, dirname as dirname3, join as join2 } from "node:path";
+var EXIT_ENDPOINT_OCCUPIED = 20;
+var EXIT_ENDPOINT_UNAVAILABLE = 21;
+var MAX_SOCKET_PATH_BYTES = 103;
+function daemonPathsFor(spec) {
+  const { runDir, name, shortPrefix, version } = spec;
+  const inRunDir = join2(runDir, `${name}-v${version}.sock`);
+  const socket = Buffer.byteLength(inRunDir) <= MAX_SOCKET_PATH_BYTES ? inRunDir : join2(
+    shortSocketDir(),
+    `${shortPrefix}-${createHash("sha256").update(runDir).digest("hex").slice(0, 16)}-v${version}.sock`
+  );
+  return {
+    runDir,
+    socket,
+    token: join2(runDir, `${name}-v${version}.token`),
+    pid: join2(runDir, `${name}-v${version}.pid`),
+    log: join2(runDir, `${name}.log`)
+  };
+}
+function retiredDaemonPaths(paths, tag) {
+  return {
+    ...paths,
+    socket: join2(dirname3(paths.socket), `.r${tag}`),
+    token: paths.token.replace(/\.token$/, `.retired-${tag}.token`),
+    pid: paths.pid.replace(/\.pid$/, `.retired-${tag}.pid`)
+  };
+}
+function shortSocketDir() {
+  return join2("/tmp", `band-${process.getuid?.() ?? "user"}`);
+}
+function parseHello(frame) {
+  if (typeof frame !== "object" || frame === null) return null;
+  const hello = frame;
+  if (hello.t !== "hello" || typeof hello.protocol !== "number" || typeof hello.token !== "string" || hello.role !== "control" && hello.role !== "stream" || typeof hello.clientId !== "string" || typeof hello.buildId !== "string") {
+    return null;
+  }
+  return hello;
+}
+function writeFrame(socket, message) {
+  socket.write(`${JSON.stringify(message)}
+`);
+}
+function readFrames(socket, onFrame, maxLineBytes = 64 * 1024 * 1024) {
+  let chunks = [];
+  let pendingBytes = 0;
+  socket.setEncoding("utf8");
+  socket.on("data", (chunk) => {
+    if (!chunk.includes("\n")) {
+      chunks.push(chunk);
+      pendingBytes += chunk.length;
+      if (pendingBytes > maxLineBytes) socket.destroy(new Error("Frame too large"));
+      return;
+    }
+    chunks.push(chunk);
+    let buffer = chunks.length === 1 ? chunk : chunks.join("");
+    chunks = [];
+    pendingBytes = 0;
+    let newline = buffer.indexOf("\n");
+    while (newline !== -1) {
+      const line = buffer.slice(0, newline);
+      buffer = buffer.slice(newline + 1);
+      if (line.length > 0) {
+        let frame;
+        try {
+          frame = JSON.parse(line);
+        } catch {
+          socket.destroy(new Error("Malformed frame"));
+          return;
+        }
+        onFrame(frame);
+        if (socket.destroyed) return;
+      }
+      newline = buffer.indexOf("\n");
+    }
+    if (buffer.length > 0) {
+      chunks.push(buffer);
+      pendingBytes = buffer.length;
+      if (pendingBytes > maxLineBytes) socket.destroy(new Error("Frame too large"));
+    }
+  });
+}
+
 // ../../packages/host-local/src/terminals/node-pty-loader.ts
 var cachedImport;
 function preloadNodePty() {
@@ -8943,9 +9200,9 @@ function preloadNodePty() {
 
 // ../../packages/host-local/src/terminals/terminal-pool.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync3, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join3, sep } from "node:path";
+import { join as join5, sep } from "node:path";
 
 // ../../packages/host-local/src/process/path.ts
 import { execFile } from "node:child_process";
@@ -9008,9 +9265,9 @@ async function shellPath() {
 }
 
 // ../../packages/host-local/src/terminals/claude-resume.ts
-import { readdirSync, statSync as statSync2 } from "node:fs";
+import { readdirSync, statSync as statSync3 } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join3 } from "node:path";
 
 // ../../packages/shared/src/claude-session.ts
 function claudeProjectSlug(cwd) {
@@ -9027,7 +9284,7 @@ function isResumableClaudeCommand(command) {
   return CLAUDE_COMMAND_PATTERN.test(trimmed) && !CLAUDE_RESUME_FLAG_PATTERN.test(trimmed);
 }
 function claudeProjectDir(cwd) {
-  return join(homedir(), ".claude", "projects", claudeProjectSlug(cwd));
+  return join3(homedir(), ".claude", "projects", claudeProjectSlug(cwd));
 }
 function findLatestClaudeSessionId(cwd) {
   const dir = claudeProjectDir(cwd);
@@ -9041,7 +9298,7 @@ function findLatestClaudeSessionId(cwd) {
   for (const name of names) {
     let mtimeMs;
     try {
-      mtimeMs = statSync2(join(dir, name)).mtimeMs;
+      mtimeMs = statSync3(join3(dir, name)).mtimeMs;
     } catch {
       continue;
     }
@@ -9071,9 +9328,9 @@ function hintForPtySpawnError(err) {
 }
 
 // ../../packages/host-local/src/terminals/terminal-history.ts
-import { readdirSync as readdirSync2, readFileSync, rmSync as rmSync2 } from "node:fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "node:fs";
 import { mkdir, rename, writeFile } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { join as join4 } from "node:path";
 var log = createLogger("terminal-history");
 var CHECKPOINT_MAX_BYTES = 5 * 1024 * 1024;
 var TerminalHistoryManager = class {
@@ -9081,14 +9338,14 @@ var TerminalHistoryManager = class {
     this.historyDir = historyDir;
   }
   sessionDir(terminalId) {
-    return join2(this.historyDir, encodeURIComponent(terminalId));
+    return join4(this.historyDir, encodeURIComponent(terminalId));
   }
   readMeta(terminalId) {
-    return readJson(join2(this.sessionDir(terminalId), "meta.json"));
+    return readJson(join4(this.sessionDir(terminalId), "meta.json"));
   }
   readCheckpoint(terminalId) {
     return readJson(
-      join2(this.sessionDir(terminalId), "checkpoint.json")
+      join4(this.sessionDir(terminalId), "checkpoint.json")
     );
   }
   /**
@@ -9134,8 +9391,8 @@ var TerminalHistoryManager = class {
       return;
     }
     for (const name of names) {
-      const dir = join2(this.historyDir, name);
-      const meta = readJson(join2(dir, "meta.json"));
+      const dir = join4(this.historyDir, name);
+      const meta = readJson(join4(dir, "meta.json"));
       if (meta?.worktreeId !== worktreeId) continue;
       try {
         rmSync2(dir, { recursive: true, force: true });
@@ -9147,7 +9404,7 @@ var TerminalHistoryManager = class {
 };
 function readJson(path) {
   try {
-    return JSON.parse(readFileSync(path, "utf8"));
+    return JSON.parse(readFileSync2(path, "utf8"));
   } catch {
     return null;
   }
@@ -9155,7 +9412,7 @@ function readJson(path) {
 async function writeJson(dir, name, value, serialized) {
   try {
     await mkdir(dir, { recursive: true, mode: 448 });
-    const path = join2(dir, name);
+    const path = join4(dir, name);
     const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
     await writeFile(tmp, serialized ?? JSON.stringify(value), { mode: 384 });
     await rename(tmp, path);
@@ -9303,7 +9560,7 @@ var TerminalPool = class {
     env.BAND_WORKTREE_ID = worktreeId;
     let cwd = worktreeRoot;
     if (options?.cwd) {
-      cwd = resolveSafeCwd(join3(worktreeRoot, options.cwd), worktreeRoot, "cwd", options.cwd) ?? cwd;
+      cwd = resolveSafeCwd(join5(worktreeRoot, options.cwd), worktreeRoot, "cwd", options.cwd) ?? cwd;
     } else if (checkpoint?.cwd) {
       cwd = resolveSafeCwd(
         checkpoint.cwd,
@@ -9434,7 +9691,7 @@ var TerminalPool = class {
       }
       if (session.autoRunFile) {
         try {
-          unlinkSync(session.autoRunFile);
+          unlinkSync3(session.autoRunFile);
         } catch {
         }
       }
@@ -9568,8 +9825,8 @@ var TerminalPool = class {
     const pty = session.pty;
     let cmdFile;
     try {
-      cmdFile = join3(tmpdir(), `band-autorun-${randomUUID()}.sh`);
-      writeFileSync(cmdFile, `${command}
+      cmdFile = join5(tmpdir(), `band-autorun-${randomUUID()}.sh`);
+      writeFileSync2(cmdFile, `${command}
 `, { encoding: "utf-8", mode: 384, flag: "wx" });
       session.autoRunFile = cmdFile;
     } catch (err) {
@@ -9972,247 +10229,40 @@ function resolveSafeCwd(candidate, worktreeRoot, label, original) {
   return candidate;
 }
 
-// ../../packages/host-local/src/terminals/daemon/endpoint.ts
-import { randomBytes } from "node:crypto";
-import {
-  chmodSync,
-  linkSync,
-  lstatSync,
-  mkdirSync as mkdirSync2,
-  renameSync as renameSync2,
-  statSync as statSync3,
-  unlinkSync as unlinkSync2
-} from "node:fs";
-import { connect } from "node:net";
-import { dirname as dirname2, join as join4 } from "node:path";
-var PROBE_TIMEOUT_MS = 500;
-var PUBLISH_ATTEMPTS = 3;
-function isProvenDead(outcome) {
-  return outcome === "missing" || outcome === "refused";
-}
-function probeEndpoint(socketPath) {
-  let occupied = false;
-  try {
-    lstatSync(socketPath);
-    occupied = true;
-  } catch (err) {
-    return Promise.resolve(errorCode(err) === "ENOENT" ? "missing" : "unknown");
-  }
-  return new Promise((resolve) => {
-    const socket = connect({ path: socketPath });
-    let settled = false;
-    const settle = (outcome) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      socket.destroy();
-      resolve(outcome);
-    };
-    const timer = setTimeout(() => settle("unknown"), PROBE_TIMEOUT_MS);
-    socket.once("connect", () => settle("connected"));
-    socket.once("error", (err) => {
-      const code = errorCode(err);
-      if (code === "ECONNREFUSED" || code === "ENOTSOCK") settle("refused");
-      else if (code === "ENOENT") settle(occupied ? "refused" : "missing");
-      else settle("unknown");
-    });
-  });
-}
-function privateBindPath(socketPath) {
-  return join4(dirname2(socketPath), `.p${randomBytes(5).toString("hex")}`);
-}
-async function publishEndpoint(boundPath, canonicalPath, supersede) {
-  const identity = entryIdentity(boundPath, statSync3);
-  if (!identity) throw new Error(`Cannot stat the bound daemon socket at ${boundPath}`);
-  for (let attempt = 0; attempt < PUBLISH_ATTEMPTS; attempt++) {
-    try {
-      linkSync(boundPath, canonicalPath);
-    } catch (err) {
-      if (errorCode(err) !== "EEXIST") throw err;
-      if (supersede && retireIncumbent(canonicalPath, supersede)) {
-        renameSync2(boundPath, canonicalPath);
-        return confirmPublished(canonicalPath, identity, true);
-      }
-      const replaced = await replaceProvenDead(boundPath, canonicalPath);
-      if (replaced === "stale") continue;
-      if (replaced !== "renamed") return replaced;
-      return confirmPublished(canonicalPath, identity, false);
-    }
-    try {
-      unlinkSync2(boundPath);
-    } catch {
-    }
-    return confirmPublished(canonicalPath, identity, false);
-  }
-  return { status: "inconclusive" };
-}
-async function replaceProvenDead(boundPath, canonicalPath) {
-  const proven = entryIdentity(canonicalPath, lstatSync);
-  const first = await probeEndpoint(canonicalPath);
-  if (first === "connected") return { status: "occupied" };
-  if (!isProvenDead(first)) return { status: "inconclusive" };
-  const now = entryIdentity(canonicalPath, lstatSync);
-  if (!proven || !now || proven.dev !== now.dev || proven.ino !== now.ino) return "stale";
-  const second = await probeEndpoint(canonicalPath);
-  if (second === "connected") return { status: "occupied" };
-  if (!isProvenDead(second)) return { status: "inconclusive" };
-  renameSync2(boundPath, canonicalPath);
-  return "renamed";
-}
-function retireIncumbent(canonicalPath, supersede) {
-  if (!sameEntry(entryIdentity(canonicalPath, lstatSync), supersede.incumbent)) return false;
-  try {
-    linkSync(canonicalPath, supersede.retiredPath);
-  } catch {
-    return false;
-  }
-  if (sameEntry(entryIdentity(supersede.retiredPath, lstatSync), supersede.incumbent)) return true;
-  try {
-    unlinkSync2(supersede.retiredPath);
-  } catch {
-  }
-  return false;
-}
-function sameEntry(a, b) {
-  return a !== null && a.dev === b.dev && a.ino === b.ino;
-}
-function confirmPublished(canonicalPath, identity, superseded) {
-  let published;
-  try {
-    const stats = statSync3(canonicalPath, { bigint: true });
-    published = { dev: stats.dev, ino: stats.ino };
-  } catch (err) {
-    return errorCode(err) === "ENOENT" ? { status: "lost" } : { status: "inconclusive" };
-  }
-  return published.dev === identity.dev && published.ino === identity.ino ? { status: "published", identity: published, superseded } : { status: "lost" };
-}
-function endpointOwnership(canonicalPath, owned) {
-  try {
-    const stats = statSync3(canonicalPath, { bigint: true });
-    return stats.dev === owned.dev && stats.ino === owned.ino ? "owned" : "lost";
-  } catch (err) {
-    return errorCode(err) === "ENOENT" ? "lost" : "indeterminate";
-  }
-}
-function ensurePrivateDir(dir) {
-  mkdirSync2(dir, { recursive: true, mode: 448 });
-  const stats = lstatSync(dir);
-  const uid = process.getuid?.();
-  if (!stats.isDirectory()) throw new Error(`${dir} is not a directory`);
-  if (uid !== void 0 && stats.uid !== uid) throw new Error(`${dir} is owned by another user`);
-  if ((stats.mode & 63) !== 0) chmodSync(dir, 448);
-}
-function entryIdentity(path, stat) {
-  try {
-    const stats = stat(path, { bigint: true });
-    return { dev: stats.dev, ino: stats.ino };
-  } catch {
-    return null;
-  }
-}
-function errorCode(err) {
-  return typeof err === "object" && err !== null && "code" in err ? String(err.code) : void 0;
-}
-
-// ../../packages/host-local/src/terminals/daemon/exit-records.ts
+// ../../packages/host-local/src/daemon-kit/exit-records.ts
 import {
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync2,
-  renameSync as renameSync3,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync2
+  readFileSync as readFileSync3,
+  renameSync as renameSync4,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 var EXITS_DIR = "exits";
 function exitsDir(runDir) {
-  return join5(runDir, EXITS_DIR);
+  return join6(runDir, EXITS_DIR);
 }
-function writeExitRecord(runDir, event) {
+function writeExitRecord(runDir, key, record) {
   const dir = exitsDir(runDir);
   mkdirSync3(dir, { recursive: true, mode: 448 });
-  const file2 = join5(dir, `${encodeURIComponent(event.terminalId)}.json`);
+  const file2 = join6(dir, `${encodeURIComponent(key)}.json`);
   const tmp = `${file2}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(event), { mode: 384 });
-  renameSync3(tmp, file2);
+  writeFileSync3(tmp, JSON.stringify(record), { mode: 384 });
+  renameSync4(tmp, file2);
+}
+
+// ../../packages/host-local/src/terminals/daemon/exit-records.ts
+function writeExitRecord2(runDir, event) {
+  writeExitRecord(runDir, event.terminalId, event);
 }
 
 // ../../packages/host-local/src/terminals/daemon/protocol.ts
-import { createHash } from "node:crypto";
-import { basename, dirname as dirname3, join as join6 } from "node:path";
 var PROTOCOL_VERSION = 3;
-var EXIT_ENDPOINT_OCCUPIED = 20;
-var EXIT_ENDPOINT_UNAVAILABLE = 21;
 var EXIT_NODE_PTY_UNAVAILABLE = 22;
 var ENDPOINT_LOST_ERROR = "Terminal daemon no longer owns its endpoint";
-var MAX_SOCKET_PATH_BYTES = 103;
 function daemonPaths(runDir, version = PROTOCOL_VERSION) {
-  const inRunDir = join6(runDir, `terminal-daemon-v${version}.sock`);
-  const socket = Buffer.byteLength(inRunDir) <= MAX_SOCKET_PATH_BYTES ? inRunDir : join6(
-    shortSocketDir(),
-    `td-${createHash("sha256").update(runDir).digest("hex").slice(0, 16)}-v${version}.sock`
-  );
-  return {
-    runDir,
-    socket,
-    token: join6(runDir, `terminal-daemon-v${version}.token`),
-    pid: join6(runDir, `terminal-daemon-v${version}.pid`),
-    log: join6(runDir, "terminal-daemon.log")
-  };
-}
-function retiredDaemonPaths(paths, tag) {
-  return {
-    ...paths,
-    socket: join6(dirname3(paths.socket), `.r${tag}`),
-    token: paths.token.replace(/\.token$/, `.retired-${tag}.token`),
-    pid: paths.pid.replace(/\.pid$/, `.retired-${tag}.pid`)
-  };
-}
-function shortSocketDir() {
-  return join6("/tmp", `band-${process.getuid?.() ?? "user"}`);
-}
-function writeFrame(socket, message) {
-  socket.write(`${JSON.stringify(message)}
-`);
-}
-function readFrames(socket, onFrame, maxLineBytes = 64 * 1024 * 1024) {
-  let chunks = [];
-  let pendingBytes = 0;
-  socket.setEncoding("utf8");
-  socket.on("data", (chunk) => {
-    if (!chunk.includes("\n")) {
-      chunks.push(chunk);
-      pendingBytes += chunk.length;
-      if (pendingBytes > maxLineBytes) socket.destroy(new Error("Frame too large"));
-      return;
-    }
-    chunks.push(chunk);
-    let buffer = chunks.length === 1 ? chunk : chunks.join("");
-    chunks = [];
-    pendingBytes = 0;
-    let newline = buffer.indexOf("\n");
-    while (newline !== -1) {
-      const line = buffer.slice(0, newline);
-      buffer = buffer.slice(newline + 1);
-      if (line.length > 0) {
-        let frame;
-        try {
-          frame = JSON.parse(line);
-        } catch {
-          socket.destroy(new Error("Malformed frame"));
-          return;
-        }
-        onFrame(frame);
-        if (socket.destroyed) return;
-      }
-      newline = buffer.indexOf("\n");
-    }
-    if (buffer.length > 0) {
-      chunks.push(buffer);
-      pendingBytes = buffer.length;
-      if (pendingBytes > maxLineBytes) socket.destroy(new Error("Frame too large"));
-    }
-  });
+  return daemonPathsFor({ runDir, name: "terminal-daemon", shortPrefix: "td", version });
 }
 
 // ../../packages/host-local/src/terminals/daemon/daemon-server.ts
@@ -10234,7 +10284,7 @@ async function runDaemon(options) {
   }
   ensurePrivateDir(paths.runDir);
   ensurePrivateDir(dirname4(paths.socket));
-  const token = randomBytes2(32).toString("hex");
+  const token = randomBytes3(32).toString("hex");
   const pool = new TerminalPool({ historyDir: join7(dirname4(paths.runDir), "terminal-history") });
   const clients = /* @__PURE__ */ new Map();
   let shuttingDown = false;
@@ -10252,7 +10302,7 @@ async function runDaemon(options) {
     });
   });
   chmodSync2(bindPath, 384);
-  let retired = supersede ? retiredDaemonPaths(paths, randomBytes2(4).toString("hex")) : null;
+  let retired = supersede ? retiredDaemonPaths(paths, randomBytes3(4).toString("hex")) : null;
   if (retired) {
     copyPrivateFile(paths.token, retired.token);
     copyPrivateFile(paths.pid, retired.pid);
@@ -10290,7 +10340,7 @@ async function runDaemon(options) {
   pool.onExit((event) => {
     if (options.recordExits && !event.killed && clients.size === 0) {
       try {
-        writeExitRecord(paths.runDir, event);
+        writeExitRecord2(paths.runDir, event);
       } catch (err) {
         log3.warn({ err, terminalId: event.terminalId }, "could not record a terminal exit");
       }
@@ -10390,7 +10440,7 @@ async function runDaemon(options) {
       if (!role && !mismatched) {
         clearTimeout(helloTimer);
         const hello = parseHello(frame);
-        if (!hello || !tokenMatches(hello.token)) {
+        if (!hello || !tokenMatches2(hello.token)) {
           writeFrame(socket, { t: "rejected", reason: "bad hello" });
           socket.end();
           return;
@@ -10613,10 +10663,8 @@ async function runDaemon(options) {
       cleanupOnExit: entry.cleanupOnExit
     };
   }
-  function tokenMatches(candidate) {
-    const expected = Buffer.from(token);
-    const actual = Buffer.from(candidate);
-    return actual.length === expected.length && timingSafeEqual(actual, expected);
+  function tokenMatches2(candidate) {
+    return tokenMatches(token, candidate);
   }
 }
 function hasValidIds(message) {
@@ -10631,36 +10679,6 @@ function hasValidIds(message) {
   }
   return true;
 }
-function parseHello(frame) {
-  if (typeof frame !== "object" || frame === null) return null;
-  const hello = frame;
-  if (hello.t !== "hello" || typeof hello.protocol !== "number" || typeof hello.token !== "string" || hello.role !== "control" && hello.role !== "stream" || typeof hello.clientId !== "string" || typeof hello.buildId !== "string") {
-    return null;
-  }
-  return hello;
-}
-function writePrivateFile(path, content) {
-  const tmp = `${path}.${randomBytes2(4).toString("hex")}.tmp`;
-  writeFileSync3(tmp, content, { mode: 384 });
-  renameSync4(tmp, path);
-}
-function copyPrivateFile(from, to) {
-  let content;
-  try {
-    content = readFileSync3(from, "utf8");
-  } catch {
-    return;
-  }
-  writePrivateFile(to, content);
-}
-function removeRetiredFiles(retired) {
-  for (const path of [retired.socket, retired.token, retired.pid]) {
-    try {
-      unlinkSync4(path);
-    } catch {
-    }
-  }
-}
 function exists(path) {
   try {
     lstatSync2(path);