@gorlitzer-labs/apiary 1.13.3

package/dist/room-Z7KDRVYD.js

@@ -0,0 +1,1099 @@
+import {
+  ALL_INTERFACES,
+  INVITES_DIR,
+  LOOPBACK,
+  agentEmoji,
+  lanAddress,
+  listRoomSessions,
+  removeRoomSession,
+  roomEmoji,
+  roomRulesPath,
+  saveRoomSession,
+  tailnetAddress,
+  tmuxAvailable,
+  tmuxKillSession,
+  tmuxSessionExists
+} from "./chunk-CZHO4DBN.js";
+import "./chunk-PEB6HEFT.js";
+import {
+  buildShareUrl,
+  extractToken
+} from "./chunk-AYQJIAR5.js";
+import "./chunk-D7DXZQWT.js";
+import "./chunk-QL66XSDB.js";
+import "./chunk-BZ4VDWC2.js";
+
+// src/cli/room.ts
+import { spawn, execFileSync as execFileSync3 } from "child_process";
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { join as pathJoin2 } from "path";
+import { createInterface } from "readline";
+
+// src/cli/new-repo.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync } from "fs";
+var GIT_TIMEOUT_MS = 15e3;
+function isInsideGitRepo(dir) {
+  try {
+    const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      // execFileSync blocks the event loop, so a git that waits on something
+      // (a credential or editor prompt on a machine configured differently)
+      // hangs the whole process — and in a test run nothing can interrupt it,
+      // because a synchronous hang never trips vitest's own timeout.
+      timeout: GIT_TIMEOUT_MS
+    });
+    return out.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+function isNonEmptyDir(dir) {
+  try {
+    return existsSync(dir) && readdirSync(dir).length > 0;
+  } catch {
+    return false;
+  }
+}
+function createRepoDir(dir, opts) {
+  let created = false;
+  try {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+      created = true;
+    }
+  } catch (err) {
+    return { ok: false, error: `could not create ${dir}: ${err instanceof Error ? err.message : String(err)}` };
+  }
+  if (!opts?.gitInit) return { ok: true, created, gitInitialised: false };
+  if (isInsideGitRepo(dir)) return { ok: true, created, gitInitialised: false };
+  try {
+    execFileSync("git", ["init", "--quiet"], { cwd: dir, stdio: "ignore", timeout: GIT_TIMEOUT_MS });
+    return { ok: true, created, gitInitialised: true };
+  } catch {
+    return { ok: true, created, gitInitialised: false };
+  }
+}
+
+// src/cli/repoPicker.ts
+import {
+  existsSync as existsSync2,
+  readdirSync as readdirSync2,
+  readFileSync,
+  writeFileSync,
+  mkdirSync as mkdirSync2,
+  statSync
+} from "fs";
+import { homedir } from "os";
+import { join as pathJoin, resolve } from "path";
+var APIARY_DIR = pathJoin(homedir(), ".apiary");
+var RECENT_PATH = pathJoin(APIARY_DIR, "recent_repos.json");
+var MAX_RECENT = 10;
+var MAX_VISIBLE = 12;
+var SCAN_ROOTS = ["", "Desktop", "code", "Projects", "dev", "src", "work", "repos"];
+var KEY_CTRL_C = "";
+var KEY_ESC = "\x1B";
+var KEY_ESC_ALT = "\x1B\x1B";
+var KEY_UP = "\x1B[A";
+var KEY_DOWN = "\x1B[B";
+var C = "\x1B[36m";
+var D = "\x1B[2m";
+var B = "\x1B[1m";
+var G = "\x1B[32m";
+var Y = "\x1B[33m";
+var M = "\x1B[35m";
+var R = "\x1B[0m";
+function expandTilde(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return pathJoin(homedir(), p.slice(2));
+  return p;
+}
+function isGitRepo(p) {
+  try {
+    const s = statSync(pathJoin(p, ".git"));
+    return s.isDirectory() || s.isFile();
+  } catch {
+    return false;
+  }
+}
+function shortenPath(p) {
+  const home = homedir();
+  if (p === home) return "~";
+  if (p.startsWith(home + "/")) return "~/" + p.slice(home.length + 1);
+  return p;
+}
+function loadRecent() {
+  try {
+    const data = JSON.parse(readFileSync(RECENT_PATH, "utf-8"));
+    return Array.isArray(data.paths) ? data.paths.filter((p) => typeof p === "string" && existsSync2(p)) : [];
+  } catch {
+    return [];
+  }
+}
+function recordRecentRepo(path) {
+  const resolved = resolve(path);
+  const existing = loadRecent().filter((p) => p !== resolved);
+  const next = [resolved, ...existing].slice(0, MAX_RECENT);
+  try {
+    if (!existsSync2(APIARY_DIR)) mkdirSync2(APIARY_DIR, { recursive: true });
+    writeFileSync(RECENT_PATH, JSON.stringify({ paths: next }, null, 2));
+  } catch {
+  }
+}
+function discoverRepos() {
+  const found = [];
+  const home = homedir();
+  for (const sub of SCAN_ROOTS) {
+    const root = sub ? pathJoin(home, sub) : home;
+    let entries;
+    try {
+      entries = readdirSync2(root);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const full = pathJoin(root, entry);
+      try {
+        if (!statSync(full).isDirectory()) continue;
+        if (isGitRepo(full)) found.push(full);
+      } catch {
+      }
+    }
+  }
+  return found;
+}
+var CUSTOM = /* @__PURE__ */ Symbol("custom");
+var NEW_REPO = /* @__PURE__ */ Symbol("new-repo");
+function arrowPicker(items, header, escHint) {
+  return new Promise((resolve2) => {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    let idx = 0;
+    let printed = 0;
+    const visible = Math.min(items.length, MAX_VISIBLE);
+    const wasRaw = stdin.isRaw ?? false;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const render = () => {
+      if (printed > 0) stdout.write(`\x1B[${printed}A\r`);
+      stdout.write("\x1B[J");
+      stdout.write(header + "\n");
+      const start = Math.max(0, Math.min(idx - Math.floor(visible / 2), items.length - visible));
+      const end = Math.min(start + visible, items.length);
+      for (let i = start; i < end; i++) {
+        const it = items[i];
+        const isCursor = i === idx;
+        const marker = isCursor ? `${Y}\u276F${R}` : " ";
+        const label = isCursor ? `${C}${B}${it.label}${R}` : it.label;
+        const hint = it.hint ? `  ${D}${it.hint}${R}` : "";
+        stdout.write(`    ${marker} ${label}${hint}
+`);
+      }
+      const more = items.length > visible ? `    ${D}(${items.length} options \u2014 \u2191/\u2193 scrolls)${R}
+` : "";
+      stdout.write(more);
+      stdout.write(`    ${D}\u2191/\u2193 navigate \xB7 enter select \xB7 esc ${escHint}${R}
+`);
+      printed = end - start + 1 + (more ? 1 : 0) + 1;
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      if (!wasRaw) stdin.setRawMode(false);
+      stdin.pause();
+    };
+    const onData = (key) => {
+      if (key === KEY_CTRL_C) {
+        cleanup();
+        process.exit(130);
+      }
+      if (key === KEY_ESC || key === KEY_ESC_ALT) {
+        cleanup();
+        stdout.write("\n");
+        resolve2(null);
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        cleanup();
+        stdout.write("\n");
+        resolve2(items[idx]);
+        return;
+      }
+      if (key === KEY_UP || key === "k") {
+        idx = (idx - 1 + items.length) % items.length;
+        render();
+        return;
+      }
+      if (key === KEY_DOWN || key === "j") {
+        idx = (idx + 1) % items.length;
+        render();
+        return;
+      }
+    };
+    stdin.on("data", onData);
+    render();
+  });
+}
+async function askRepoPath(opts) {
+  const cwd = resolve(opts.defaultPath);
+  const recent = loadRecent();
+  const discovered = discoverRepos();
+  const seen = /* @__PURE__ */ new Set();
+  const items = [];
+  const add = (path, hint) => {
+    const r = resolve(path);
+    if (seen.has(r)) return;
+    seen.add(r);
+    items.push({ label: shortenPath(r), value: r, hint });
+  };
+  add(cwd, "current dir");
+  for (const p of recent) add(p, "recent");
+  for (const p of discovered) add(p);
+  items.push({ label: `${M}\u270E${R}  Type a custom path\u2026`, value: CUSTOM });
+  items.push({ label: `${M}\u271A${R}  New project\u2026`, value: NEW_REPO, hint: "creates the folder" });
+  const header = `    \u{1F4C1} ${B}Repo${R} ${D}for ${opts.alias}${R}`;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const typed = await opts.ask(`    Repo path ${D}[${shortenPath(cwd)}]${R}: `);
+    const final2 = typed ? resolve(expandTilde(typed)) : cwd;
+    recordRecentRepo(final2);
+    return final2;
+  }
+  const picked = await arrowPicker(items, header, "to type a path");
+  let final;
+  if (picked && picked.value === NEW_REPO) {
+    final = await askNewRepoPath(opts, cwd);
+  } else if (!picked || picked.value === CUSTOM) {
+    const typed = await opts.ask(`    Custom repo path ${D}[${shortenPath(cwd)}]${R}: `);
+    final = typed ? resolve(expandTilde(typed)) : cwd;
+    await ensureExists(final, opts);
+  } else {
+    final = picked.value;
+  }
+  recordRecentRepo(final);
+  return final;
+}
+async function askNewRepoPath(opts, cwd) {
+  const typed = await opts.ask(`    New project path ${D}(e.g. ~/Desktop/my-thing)${R}: `);
+  const target = typed ? resolve(expandTilde(typed)) : cwd;
+  await ensureExists(target, opts, { assumeNew: true });
+  return target;
+}
+async function ensureExists(dir, opts, hints) {
+  if (existsSync2(dir)) {
+    if (!hints?.assumeNew) return;
+    if (isNonEmptyDir(dir)) console.log(`    ${D}${shortenPath(dir)} already exists \u2014 using it.${R}`);
+    return;
+  }
+  const answer = hints?.assumeNew ? "y" : await opts.ask(`    ${shortenPath(dir)} doesn't exist. Create it? ${D}[Y/n]${R}: `) || "y";
+  if (!/^y(es)?$/i.test(answer.trim())) {
+    console.log(`    ${D}Left alone \u2014 the agent for this repo won't start until it exists.${R}`);
+    return;
+  }
+  const wantsGit = isInsideGitRepo(dir) ? false : /^y(es)?$/i.test((await opts.ask(`    Run git init in it? ${D}[Y/n]${R}: `) || "y").trim());
+  const res = createRepoDir(dir, { gitInit: wantsGit });
+  if (!res.ok) {
+    console.log(`    ${M}\u2717${R} ${res.error}`);
+    return;
+  }
+  const bits = [res.created ? "created" : "exists"];
+  if (res.gitInitialised) bits.push("git initialised");
+  console.log(`    ${G}\u2713${R} ${shortenPath(dir)} ${D}(${bits.join(", ")})${R}`);
+}
+var RUNTIME_HINTS = {
+  claude: "Claude Code",
+  codex: "OpenAI Codex CLI"
+};
+async function askRuntime(opts) {
+  if (opts.available.length === 0) return void 0;
+  if (opts.available.length === 1) return opts.available[0];
+  const runtimeGlyph = { claude: "\u{1F9E0}", codex: "\u2328\uFE0F " };
+  const items = opts.available.map((rt) => ({
+    label: `${runtimeGlyph[rt] ?? "\u2699\uFE0F "} ${rt}`,
+    value: rt,
+    hint: RUNTIME_HINTS[rt]
+  }));
+  const header = `    \u2699\uFE0F  ${B}Runtime${R} ${D}for ${opts.alias}${R}`;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const typed = await opts.ask(`    Runtime ${D}[claude]${R} ${D}(${opts.available.join("/")})${R}: `) || "claude";
+    return opts.available.includes(typed) ? typed : "claude";
+  }
+  const picked = await arrowPicker(items, header, "to skip");
+  return picked ? picked.value : opts.available[0];
+}
+async function askReach(opts) {
+  const items = opts.options.map((o) => ({
+    label: o.label,
+    value: o.value,
+    hint: o.hint
+  }));
+  const header = `    \u{1F310} ${B}Who can reach this room?${R}`;
+  if (!process.stdin.isTTY || !process.stdout.isTTY) return opts.options[0].value;
+  const picked = await arrowPicker(items, header, "for this machine only");
+  if (!picked || typeof picked.value !== "string") return opts.options[0].value;
+  return picked.value;
+}
+
+// src/cli/foundation.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+import { join } from "path";
+import { homedir as homedir2 } from "os";
+function foundationInit(cwd) {
+  const dir = cwd.replace(/^~/, homedir2());
+  if (!existsSync3(dir)) return { ok: false, how: "no-dir" };
+  if (existsSync3(join(dir, "docs", "QUEUE.md"))) return { ok: true, how: "already" };
+  const attempts = [
+    { cmd: "foundation", args: ["init", dir], how: "local" },
+    { cmd: "npx", args: ["--yes", "github:gorlitzer-labs/foundation", "init", dir], how: "npx" }
+  ];
+  for (const a of attempts) {
+    try {
+      execFileSync2(a.cmd, a.args, { stdio: "ignore", timeout: 9e4 });
+      return { ok: true, how: a.how };
+    } catch {
+    }
+  }
+  return { ok: false, how: "unavailable" };
+}
+
+// src/cli/room.ts
+var DAEMON_SHARE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var TIER_TOKENS = {
+  owner: "product_owner",
+  product_owner: "product_owner",
+  admin: "admin",
+  member: "member",
+  guest: "guest"
+};
+var TYPE_TOKENS = {
+  agent: "agent",
+  human: "human"
+};
+var MODE_TOKENS = {
+  standby: "standby-everyone",
+  "standby-everyone": "standby-everyone",
+  "standby-people": "standby-people",
+  "standby-agents": "standby-agents",
+  active: "everyone",
+  everyone: "everyone",
+  people: "people",
+  agents: "agents"
+};
+var MODEL_TOKENS = /* @__PURE__ */ new Set([
+  "opus",
+  "sonnet",
+  "haiku"
+  // also accept full model ids verbatim
+]);
+function isModelToken(tok) {
+  const lc = tok.toLowerCase();
+  if (MODEL_TOKENS.has(lc)) return true;
+  return /^claude-(opus|sonnet|haiku)-\d/.test(lc);
+}
+function parseAliasSpec(input) {
+  const parts = input.split(":").map((p) => p.trim()).filter(Boolean);
+  if (parts.length === 0) return null;
+  const alias = parts[0];
+  let type = "agent";
+  let tier = "member";
+  let role = "agent";
+  let model;
+  let mode;
+  for (const tok of parts.slice(1)) {
+    const lc = tok.toLowerCase();
+    if (TYPE_TOKENS[lc]) {
+      type = TYPE_TOKENS[lc];
+      role = type;
+    } else if (TIER_TOKENS[lc]) {
+      tier = TIER_TOKENS[lc];
+    } else if (MODE_TOKENS[lc]) {
+      mode = MODE_TOKENS[lc];
+    } else if (isModelToken(tok)) {
+      model = lc;
+    } else {
+      role = lc;
+    }
+  }
+  return { alias, type, tier, role, model, mode };
+}
+function applyDefaultModes(participants) {
+  let seenActiveAgent = false;
+  for (const p of participants) {
+    if (p.role !== "agent") continue;
+    if (p.mode !== void 0) {
+      if (!p.mode.startsWith("standby-")) seenActiveAgent = true;
+      continue;
+    }
+    if (!seenActiveAgent) {
+      p.mode = "everyone";
+      seenActiveAgent = true;
+    } else {
+      p.mode = "standby-everyone";
+    }
+  }
+}
+function makePrompt() {
+  return {
+    ask: (q) => new Promise((res) => {
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      rl.question(q, (a) => {
+        rl.close();
+        res(a.trim());
+      });
+    }),
+    close: () => {
+    }
+  };
+}
+async function spawnDaemonServer(opts) {
+  const scriptPath = process.argv[1];
+  const ttl = opts.shareTtlMs ?? DAEMON_SHARE_TTL_MS;
+  const args = ["serve", "--headless", "--share-token-ttl", String(ttl)];
+  if (opts.room) args.push("--room", opts.room);
+  if (opts.port) args.push("--port", String(opts.port));
+  if (opts.share) args.push("--share");
+  if (opts.expose) args.push("--expose");
+  if (opts.bind) args.push("--bind", opts.bind);
+  return new Promise((resolve2) => {
+    const child = spawn(process.execPath, [scriptPath, ...args], {
+      detached: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdoutBuf = "";
+    let stderrBuf = "";
+    let settled = false;
+    const settle = (v) => {
+      if (settled) return;
+      settled = true;
+      resolve2(v);
+    };
+    child.stdout.on("data", (chunk) => {
+      stdoutBuf += chunk.toString();
+      const line = stdoutBuf.split("\n").find((l) => l.trim().startsWith("{"));
+      if (line) {
+        try {
+          const result = JSON.parse(line.trim());
+          child.unref();
+          settle({ ...result, pid: child.pid });
+        } catch {
+        }
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrBuf += chunk.toString();
+    });
+    child.on("error", (err) => settle({ reason: err.message, stderr: stderrBuf }));
+    child.on("exit", (code) => {
+      if (code !== 0) {
+        const portInUse = /EADDRINUSE|already in use/i.test(stderrBuf);
+        settle({
+          reason: portInUse ? `port ${opts.port ?? 7890} already in use` : `daemon exited with code ${code}`,
+          stderr: stderrBuf,
+          portInUse
+        });
+      }
+    });
+    setTimeout(() => settle({ reason: "timed out waiting for daemon startup", stderr: stderrBuf }), 15e3);
+  });
+}
+function isDaemonResult(v) {
+  return "serverUrl" in v;
+}
+function writeInvite(alias, joinUrl) {
+  mkdirSync3(INVITES_DIR, { recursive: true });
+  writeFileSync2(pathJoin2(INVITES_DIR, alias), joinUrl, { mode: 384 });
+}
+function isLocalPath(p) {
+  try {
+    return existsSync4(p.replace(/^~/, homedir3()));
+  } catch {
+    return false;
+  }
+}
+async function httpJoin(serverUrl, shareToken, name = "[system]") {
+  try {
+    const res = await fetch(`${serverUrl}/join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ shareToken, name, type: "agent" })
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    return data.sessionToken ?? null;
+  } catch {
+    return null;
+  }
+}
+async function httpDisconnect(serverUrl, sessionToken) {
+  await fetch(`${serverUrl}/disconnect`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` }
+  }).catch(() => {
+  });
+}
+async function postSystemMessage(serverUrl, adminShareToken, content) {
+  const sessionToken = await httpJoin(serverUrl, adminShareToken, "[system]");
+  if (!sessionToken) return;
+  await fetch(`${serverUrl}/message`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+    body: JSON.stringify({ content })
+  }).catch(() => {
+  });
+  await httpDisconnect(serverUrl, sessionToken);
+}
+async function fetchServerState(serverUrl, adminShareToken, publicUrl) {
+  const sessionToken = await httpJoin(serverUrl, adminShareToken, "[system]");
+  if (!sessionToken) return { connectedNames: /* @__PURE__ */ new Set() };
+  let memberToken;
+  let connectedNames = /* @__PURE__ */ new Set();
+  try {
+    const [shareRes, participantsRes] = await Promise.all([
+      fetch(`${serverUrl}/share`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+        body: JSON.stringify({})
+      }),
+      fetch(`${serverUrl}/participants`, {
+        headers: { Authorization: `Bearer ${sessionToken}` }
+      })
+    ]);
+    if (shareRes.ok) {
+      const data = await shareRes.json();
+      const memberUrl = data.links?.["member"];
+      if (memberUrl) memberToken = extractToken(memberUrl) ?? void 0;
+    }
+    if (participantsRes.ok) {
+      const data = await participantsRes.json();
+      connectedNames = new Set(data.participants.map((p) => p.name.toLowerCase()));
+    }
+  } finally {
+    await httpDisconnect(serverUrl, sessionToken);
+  }
+  return { memberToken, connectedNames };
+}
+function detectRuntimes() {
+  const has = (cmd) => {
+    try {
+      execFileSync3("which", [cmd], { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  return { claude: has("claude"), codex: has("codex") };
+}
+var A = "\x1B[33m";
+var RESET = "\x1B[0m";
+var BEE_BANNER = [
+  `${A}               _                      \\ \\${RESET}`,
+  `${A}  ____ _____  (_)___ ________  __      \\ \\ \\${RESET}`,
+  `${A} / __ \`/ __ \\/ / __ \`/ ___/ / / /      (o o)${RESET}`,
+  `${A}/ /_/ / /_/ / / /_/ / /  / /_/ /       )=BzZz=(${RESET}`,
+  `${A}\\__,_/ .___/_/\\__,_/_/   \\__, /        / / /${RESET}`,
+  `${A}    /_/                 /____/        / / /${RESET}`
+].join("\n");
+function spawnAgentBackground(alias, cwd, runtime, tier = "member", model, mode) {
+  const resolvedCwd = cwd.replace(/^~/, homedir3());
+  if (!existsSync4(resolvedCwd)) return { ok: false, reason: `${shortenPath(cwd)} doesn't exist` };
+  const args = [process.argv[1], runtime, alias, "--background"];
+  if (tier === "admin" || tier === "product_owner") args.push("--admin");
+  if (model) args.push("--model", model);
+  if (mode) args.push("--mode", mode);
+  try {
+    const child = spawn(process.execPath, args, {
+      detached: true,
+      stdio: "ignore",
+      cwd: resolvedCwd
+    });
+    child.unref();
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, reason: err instanceof Error ? err.message : "spawn failed" };
+  }
+}
+async function mintTierTokens(serverUrl, adminShareToken, shareBase, tiers) {
+  const result = {};
+  const sessionToken = await httpJoin(serverUrl, adminShareToken, "[system]");
+  if (!sessionToken) return result;
+  try {
+    for (const tier of tiers) {
+      try {
+        const res = await fetch(`${serverUrl}/share`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${sessionToken}` },
+          body: JSON.stringify({ authority: tier })
+        });
+        if (!res.ok) continue;
+        const data = await res.json();
+        const linkForTier = data.links?.[tier];
+        const token = linkForTier ? extractToken(linkForTier) : data.token;
+        if (token) result[tier] = buildShareUrl(shareBase, token);
+      } catch {
+      }
+    }
+  } finally {
+    await httpDisconnect(serverUrl, sessionToken);
+  }
+  return result;
+}
+function printInvite(alias, joinUrl, sameHost) {
+  const C2 = "\x1B[36m";
+  const D2 = "\x1B[2m";
+  const G2 = "\x1B[32m";
+  const R2 = "\x1B[0m";
+  if (sameHost) {
+    writeInvite(alias, joinUrl);
+    console.log(`  ${G2}\u2713${R2} ${alias}  ${D2}(invite queued \u2014 auto-consumed on next launch)${R2}`);
+  } else {
+    console.log(`  ${alias}:`);
+  }
+  console.log(`    ${C2}apiary join${R2} "${joinUrl}"`);
+}
+async function roomCreate(opts) {
+  const Y2 = "\x1B[33m";
+  const B2 = "\x1B[1m";
+  const D2 = "\x1B[2m";
+  const C2 = "\x1B[36m";
+  const R2 = "\x1B[0m";
+  const { ask, close } = makePrompt();
+  console.log(`
+${BEE_BANNER}
+`);
+  console.log(`  ${Y2}${B2}apiary${R2} \u2014 create room
+`);
+  const roomName = opts.room ?? (await ask(`  Room name ${D2}[random]${R2}: `) || void 0);
+  const hostName = await ask(`  Your name ${D2}[random]${R2}: `) || void 0;
+  const ttlInput = await ask(`  Session duration ${D2}[7d]${R2}: `);
+  const shareTtlMs = parseDuration(ttlInput) ?? DAEMON_SHARE_TTL_MS;
+  const rts = detectRuntimes();
+  const availableRuntimes = [...rts.claude ? ["claude"] : [], ...rts.codex ? ["codex"] : []];
+  if (availableRuntimes.length === 0) {
+    console.log(`
+  ${D2}(neither claude nor codex found in PATH \u2014 agents will need to join manually)${R2}`);
+  } else if (availableRuntimes.length === 1) {
+    console.log(`
+  ${D2}Runtime auto-detected: ${availableRuntimes[0]}${R2}`);
+  }
+  const participants = [];
+  const G2 = "\x1B[32m";
+  const M2 = "\x1B[35m";
+  const divider = `  ${D2}${"\u2500".repeat(56)}${R2}`;
+  console.log(`
+  ${B2}Invite participants${R2}`);
+  console.log(divider);
+  while (true) {
+    const n = participants.length + 1;
+    console.log(`
+  \u{1F41D} ${M2}${B2}Participant ${n}${R2}`);
+    const aliasInput = await ask(
+      `     ${C2}\u2192${R2} Alias ${D2}(blank \u21B5 to finish \xB7 suffix :human, :owner, :admin, :guest, :standby)${R2}: `
+    );
+    if (!aliasInput) {
+      const count = participants.length;
+      const summary = count === 0 ? `${D2}no participants \u2014 starting an empty room${R2}` : `${G2}\u2713${R2} ${B2}${count}${R2} participant${count === 1 ? "" : "s"} ready \u2014 starting room\u2026`;
+      console.log(`  ${summary}`);
+      break;
+    }
+    const spec = parseAliasSpec(aliasInput);
+    if (!spec) continue;
+    const { alias, role, tier, model, mode } = spec;
+    const cwd = await askRepoPath({ alias, defaultPath: process.cwd(), ask });
+    const runtime = role === "agent" ? await askRuntime({ alias, available: availableRuntimes, ask }) : void 0;
+    participants.push({ alias, cwd, role, runtime, tier, model, mode });
+    const bug = role === "agent" ? agentEmoji(alias) : role === "human" ? "\u{1F464}" : "\u270E";
+    const runtimeBadge = runtime ? ` \xB7 ${C2}${runtime}${R2}` : "";
+    const modelBadge = model ? `  ${Y2}[${model}]${R2}` : "";
+    const tierBadge = tier !== "member" ? `  ${Y2}[${tier === "product_owner" ? "owner" : tier}]${R2}` : "";
+    const modeBadge = mode ? `  ${Y2}[${mode}]${R2}` : "";
+    console.log(
+      `  ${G2}\u2705${R2} ${bug} ${B2}${alias}${R2}${tierBadge}${modelBadge}${modeBadge}  ${D2}${role}${R2}${runtimeBadge}  ${D2}${shortenPath(cwd)}${R2}`
+    );
+    console.log(divider);
+  }
+  applyDefaultModes(participants);
+  let bindAddress = opts.bind;
+  if (!bindAddress && !opts.expose) {
+    const ts = tailnetAddress();
+    const lan = lanAddress();
+    const reach = await askReach({
+      ask,
+      options: [
+        { label: "This machine only", value: LOOPBACK, hint: "safest default" },
+        ...ts ? [{
+          label: `Tailnet  ${D2}(${ts})${R2}`,
+          value: ts,
+          // The room is on your VPN only: reachable from your other devices
+          // anywhere, invisible to whatever wifi this machine is on.
+          hint: "your devices anywhere, via Tailscale \u2014 not the local network"
+        }] : [],
+        ...lan ? [{
+          label: `This network  ${D2}(${lan})${R2}`,
+          value: lan,
+          hint: "anyone on the same wifi"
+        }] : [],
+        { label: "All interfaces", value: ALL_INTERFACES, hint: "including untrusted networks \u2014 rarely what you want" }
+      ]
+    });
+    if (reach !== LOOPBACK) bindAddress = reach;
+  }
+  close();
+  if (opts.foundation !== false) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const p of participants) {
+      if (!isLocalPath(p.cwd)) continue;
+      const key = p.cwd.replace(/^~/, homedir3());
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const r = foundationInit(p.cwd);
+      const where = shortenPath(p.cwd);
+      if (r.how === "already") console.log(`  ${D2}Foundation already set up in ${where}${R2}`);
+      else if (r.ok) console.log(`  ${G2}\u2713${R2} Foundation installed in ${D2}${where}${R2} ${D2}(${r.how})${R2}`);
+      else console.log(`  ${D2}Foundation skipped for ${where} \u2014 run: foundation init${R2}`);
+    }
+  }
+  console.log(`
+  Starting server in background...`);
+  const daemonRes = await spawnDaemonServer({
+    room: roomName,
+    port: opts.port,
+    share: opts.share,
+    expose: opts.expose,
+    bind: bindAddress,
+    shareTtlMs
+  });
+  if (!isDaemonResult(daemonRes)) {
+    console.error(`
+  ${Y2}\u2717${R2} Failed to start server: ${B2}${daemonRes.reason}${R2}`);
+    if (daemonRes.portInUse) {
+      console.error(`  ${D2}A previous room daemon is probably still bound. Inspect with:${R2}  ${C2}apiary ps${R2}`);
+      console.error(`  ${D2}Stop it with:${R2}  ${C2}apiary stop --all${R2}  ${D2}(or ${R2}${C2}apiary stop <room>${R2}${D2})${R2}`);
+    } else if (daemonRes.stderr?.trim()) {
+      console.error(`  ${D2}stderr:${R2}
+${daemonRes.stderr.split("\n").map((l) => "    " + l).join("\n")}`);
+    }
+    process.exit(1);
+  }
+  const daemon = daemonRes;
+  saveRoomSession({
+    roomName: daemon.roomName,
+    serverUrl: daemon.serverUrl,
+    publicUrl: daemon.publicUrl,
+    adminToken: daemon.adminToken,
+    memberToken: daemon.memberToken,
+    pid: daemon.pid,
+    lastActive: Date.now(),
+    hostName,
+    participants
+  });
+  const shareBase = daemon.publicUrl !== daemon.serverUrl ? daemon.publicUrl : daemon.serverUrl;
+  const memberJoinUrl = buildShareUrl(shareBase, daemon.memberToken);
+  const tieredJoinUrls = { member: memberJoinUrl };
+  const nonMemberTiers = Array.from(
+    new Set(participants.map((p) => p.tier).filter((t) => t !== "member"))
+  );
+  if (nonMemberTiers.length > 0) {
+    const mintedUrls = await mintTierTokens(daemon.serverUrl, daemon.adminToken, shareBase, nonMemberTiers);
+    Object.assign(tieredJoinUrls, mintedUrls);
+  }
+  const canSpawn = tmuxAvailable();
+  if (participants.length > 0) {
+    console.log(`
+  ${B2}Invite links:${R2}
+`);
+    const hasRuntimeParticipants = participants.some((p) => p.runtime);
+    if (!canSpawn && hasRuntimeParticipants) {
+      console.log(`  ${D2}(tmux not found \u2014 agents will need to join manually via the invite links below)${R2}
+`);
+    }
+    const allLocal = participants.every((p) => isLocalPath(p.cwd));
+    for (const p of participants) {
+      const sameHost = allLocal || isLocalPath(p.cwd);
+      const joinUrl = tieredJoinUrls[p.tier] ?? memberJoinUrl;
+      printInvite(p.alias, joinUrl, sameHost);
+      if (sameHost && canSpawn && p.runtime) {
+        const spawned = spawnAgentBackground(p.alias, p.cwd, p.runtime, p.tier, p.model, p.mode);
+        if (spawned.ok) {
+          const modeNote = p.mode?.startsWith("standby-") ? ` ${D2}\xB7${R2} ${Y2}standby${R2} ${D2}(wakes on @mention, /ping or a whisper)${R2}` : p.mode ? ` ${D2}\xB7 listening to everything${R2}` : "";
+          console.log(`    ${D2}\u2192 spawned ${p.runtime} session (tmux attach -t apiary_${p.alias})${R2}${modeNote}`);
+        } else {
+          console.log(`    ${Y2}\u2717${R2} ${B2}${p.alias}${R2} not started \u2014 ${spawned.reason}.`);
+          console.log(`      ${D2}Create it, then: ${R2}${C2}apiary room resume ${roomName}${R2}`);
+        }
+      }
+    }
+    if (participants.some((p) => p.role === "agent" && p.mode?.startsWith("standby-"))) {
+      console.log(
+        `
+  ${D2}Only the first agent listens to everything \u2014 the rest wake when addressed,${R2}
+  ${D2}so one remark costs one agent turn instead of all of them.${R2}
+  ${D2}Change any of it live with ${R2}${C2}/setmode <name> <mode>${R2}${D2}, or up front with ${R2}${C2}alias:standby${R2}${D2} / ${R2}${C2}alias:active${R2}${D2}.${R2}`
+      );
+    }
+    console.log("");
+  } else {
+    console.log(`
+  ${D2}Member join link:${R2}  ${C2}${memberJoinUrl}${R2}
+`);
+  }
+  console.log(`  ${D2}Rules:${R2}  ${C2}${shortenPath(roomRulesPath(daemon.roomName))}${R2}  ${D2}(edit to customize \u2014 hot-reloads)${R2}`);
+  console.log(`  Press Ctrl+C to leave \u2014 server keeps running.
+`);
+  const { join: join2 } = await import("./join-CQXEF65B.js");
+  const adminJoinUrl = buildShareUrl(daemon.serverUrl, daemon.adminToken);
+  const expectedAgents = participants.filter((p) => p.role === "agent").map((p) => p.alias);
+  await join2({ server: adminJoinUrl, name: hostName, expectedAgents });
+  console.log(`
+  Server still running ${roomEmoji(daemon.roomName)} ${Y2}${daemon.roomName}${R2}`);
+  console.log(`  Rejoin: ${C2}apiary room resume ${daemon.roomName}${R2}
+`);
+}
+async function roomResume(name) {
+  const Y2 = "\x1B[33m";
+  const B2 = "\x1B[1m";
+  const D2 = "\x1B[2m";
+  const C2 = "\x1B[36m";
+  const G2 = "\x1B[32m";
+  const W = "\x1B[33m";
+  const R2 = "\x1B[0m";
+  const sessions = listRoomSessions();
+  const session = sessions.find((s) => s.roomName === name);
+  if (!session) {
+    console.error(`  No saved session for room "${name}".`);
+    console.error(`  Run: ${C2}apiary room list${R2}  to see saved rooms.`);
+    process.exit(1);
+  }
+  let serverUrl = session.serverUrl;
+  let adminToken = session.adminToken;
+  let memberToken = session.memberToken;
+  let publicUrl = session.publicUrl;
+  let pid = session.pid;
+  const alive = isServerAlive(session);
+  let connectedNames = /* @__PURE__ */ new Set();
+  if (alive) {
+    console.log(`
+  ${Y2}${B2}${name}${R2}  ${D2}server running (PID ${pid})${R2}
+`);
+    const state = await fetchServerState(serverUrl, adminToken, publicUrl);
+    if (state.memberToken) memberToken = state.memberToken;
+    connectedNames = state.connectedNames;
+  } else {
+    console.log(`
+  ${Y2}${B2}${name}${R2}  ${D2}server stopped \u2014 restarting...${R2}
+`);
+    const daemonRes = await spawnDaemonServer({ room: name, bind: session.bind });
+    if (!isDaemonResult(daemonRes)) {
+      console.error(`
+  ${W}\u2717${R2} Failed to restart server: ${B2}${daemonRes.reason}${R2}`);
+      if (daemonRes.portInUse) {
+        console.error(`  ${D2}Inspect:${R2}  ${C2}apiary ps${R2}    ${D2}Stop:${R2}  ${C2}apiary stop --all${R2}`);
+      } else if (daemonRes.stderr?.trim()) {
+        console.error(`  ${D2}stderr:${R2}
+${daemonRes.stderr.split("\n").map((l) => "    " + l).join("\n")}`);
+      }
+      process.exit(1);
+    }
+    const daemon = daemonRes;
+    serverUrl = daemon.serverUrl;
+    adminToken = daemon.adminToken;
+    memberToken = daemon.memberToken;
+    publicUrl = daemon.publicUrl;
+    pid = daemon.pid;
+    saveRoomSession({
+      ...session,
+      serverUrl,
+      publicUrl,
+      adminToken,
+      memberToken,
+      pid,
+      lastActive: Date.now()
+    });
+  }
+  const shareBase = publicUrl !== serverUrl ? publicUrl : serverUrl;
+  const memberJoinUrl = buildShareUrl(shareBase, memberToken);
+  if (session.participants && session.participants.length > 0) {
+    const allLocal = session.participants.every((p) => isLocalPath(p.cwd));
+    let hasConnected = false;
+    let hasDisconnected = false;
+    for (const p of session.participants) {
+      const connected = connectedNames.has(p.alias.toLowerCase());
+      if (connected) {
+        if (!hasConnected) console.log(`  ${B2}Connected:${R2}`);
+        hasConnected = true;
+        console.log(`  ${G2}\u25CF${R2} ${p.alias}`);
+      } else {
+        if (!hasDisconnected) {
+          console.log(`
+  ${B2}Rejoin links:${R2}
+`);
+          if (!tmuxAvailable() && session.participants?.some((pp) => pp.runtime)) {
+            console.log(`  ${D2}(tmux not found \u2014 agents will need to join manually via the invite links below)${R2}
+`);
+          }
+        }
+        hasDisconnected = true;
+        console.log(`  ${W}\u25CB${R2} ${p.alias}  ${D2}disconnected${R2}`);
+        const sameHost = allLocal || isLocalPath(p.cwd);
+        printInvite(p.alias, memberJoinUrl, sameHost);
+        if (sameHost && tmuxAvailable() && p.runtime && !tmuxSessionExists(`apiary_${p.alias}`)) {
+          const spawned = spawnAgentBackground(p.alias, p.cwd, p.runtime, p.tier, p.model, p.mode);
+          if (spawned.ok) {
+            console.log(`    ${D2}\u2192 respawned ${p.runtime} session (tmux attach -t apiary_${p.alias})${R2}`);
+          } else {
+            console.log(`    ${W}\u2717${R2} ${B2}${p.alias}${R2} not restarted \u2014 ${spawned.reason}.`);
+          }
+        }
+      }
+    }
+    if (hasConnected && alive) {
+      await postSystemMessage(
+        serverUrl,
+        adminToken,
+        `[SYSTEM] Session resumed by admin. You are still connected.`
+      );
+    }
+    console.log("");
+  }
+  let resumeHostName = session.hostName;
+  if (!resumeHostName) {
+    const { ask, close } = makePrompt();
+    resumeHostName = await ask(`  Your name ${D2}[random]${R2}: `) || void 0;
+    close();
+    if (resumeHostName) {
+      saveRoomSession({ ...session, hostName: resumeHostName, lastActive: Date.now() });
+    }
+  }
+  console.log(`  Press Ctrl+C to leave \u2014 server keeps running.
+`);
+  const { join: join2 } = await import("./join-CQXEF65B.js");
+  const adminJoinUrl = buildShareUrl(serverUrl, adminToken);
+  await join2({ server: adminJoinUrl, name: resumeHostName });
+  console.log(`
+  Server still running (room: ${Y2}${name}${R2})`);
+  console.log(`  Rejoin: ${C2}apiary room resume ${name}${R2}
+`);
+}
+function roomList() {
+  const Y2 = "\x1B[33m";
+  const B2 = "\x1B[1m";
+  const D2 = "\x1B[2m";
+  const C2 = "\x1B[36m";
+  const G2 = "\x1B[32m";
+  const X = "\x1B[31m";
+  const R2 = "\x1B[0m";
+  const sessions = listRoomSessions();
+  if (sessions.length === 0) {
+    console.log("  No saved rooms. Run: apiary room create");
+    return;
+  }
+  console.log("");
+  for (const s of sessions) {
+    const alive = isServerAlive(s);
+    const status = alive ? `${G2}running${R2} ${D2}(PID ${s.pid})${R2}` : `${X}stopped${R2}`;
+    const lastActive = s.lastActive ? `${D2}last active: ${formatRelativeTime(s.lastActive)}${R2}` : "";
+    console.log(`  ${Y2}${B2}${s.roomName}${R2}  ${status}  ${lastActive}`);
+    if (s.participants && s.participants.length > 0) {
+      const names = s.participants.map((p) => `${p.alias} ${D2}[${p.role}]${R2}`).join("  ");
+      console.log(`    ${D2}Participants:${R2}  ${names}`);
+    } else {
+      console.log(`    ${D2}(no participant metadata \u2014 created with older apiary)${R2}`);
+    }
+    console.log(`    ${D2}Resume:${R2}  ${C2}apiary room resume ${s.roomName}${R2}`);
+    if (alive) {
+      const shareBase = s.publicUrl !== s.serverUrl ? s.publicUrl : s.serverUrl;
+      const joinUrl = buildShareUrl(shareBase, s.memberToken);
+      console.log(`    ${D2}Join:${R2}    ${C2}${joinUrl}${R2}`);
+    }
+    console.log("");
+  }
+}
+async function roomStop(name, options = {}) {
+  const Y2 = "\x1B[33m";
+  const B2 = "\x1B[1m";
+  const G2 = "\x1B[32m";
+  const D2 = "\x1B[2m";
+  const R2 = "\x1B[0m";
+  const session = options.session ?? listRoomSessions().find((s) => s.roomName === name);
+  if (!session) {
+    console.error(`  No saved session for room "${name}".`);
+    console.error(`  Run: apiary room list  to see saved rooms.`);
+    process.exit(1);
+  }
+  const alive = isServerAlive(session);
+  if (!alive && options.quietIfDead) {
+    removeRoomSession(name);
+    return;
+  }
+  console.log(`
+  Stopping ${Y2}${B2}${name}${R2}...
+`);
+  if (session.participants && tmuxAvailable()) {
+    for (const p of session.participants) {
+      const tsName = `apiary_${p.alias}`;
+      if (tmuxSessionExists(tsName)) {
+        tmuxKillSession(tsName);
+        console.log(`  ${G2}\u2713${R2} ${p.alias}  ${D2}agent stopped${R2}`);
+      }
+    }
+  }
+  if (alive) {
+    try {
+      process.kill(session.pid, "SIGTERM");
+      console.log(`  ${G2}\u2713${R2} server  ${D2}(PID ${session.pid}) stopped${R2}`);
+    } catch {
+    }
+  }
+  removeRoomSession(name);
+  console.log(`
+  Room "${name}" stopped. Start fresh: apiary room create
+`);
+}
+function isServerAlive(session) {
+  try {
+    process.kill(session.pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseDuration(input) {
+  if (!input) return null;
+  const m = input.trim().match(/^(\d+)\s*(d|h|m)?$/i);
+  if (!m) return null;
+  const n = parseInt(m[1], 10);
+  const unit = (m[2] ?? "d").toLowerCase();
+  if (unit === "d") return n * 24 * 60 * 60 * 1e3;
+  if (unit === "h") return n * 60 * 60 * 1e3;
+  if (unit === "m") return n * 60 * 1e3;
+  return null;
+}
+function formatRelativeTime(ts) {
+  const diff = Date.now() - ts;
+  const mins = Math.floor(diff / 6e4);
+  if (mins < 1) return "just now";
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+export {
+  applyDefaultModes,
+  isDaemonResult,
+  isServerAlive,
+  parseAliasSpec,
+  roomCreate,
+  roomList,
+  roomResume,
+  roomStop,
+  spawnDaemonServer,
+  writeInvite
+};
+//# sourceMappingURL=room-Z7KDRVYD.js.map