@directed/cli 0.1.2

package/dist/cli.js

@@ -0,0 +1,1938 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { realpathSync } from "fs";
+import { pathToFileURL } from "url";
+import { randomBytes as randomBytes2 } from "crypto";
+import { execFileSync } from "child_process";
+import { createRequire } from "module";
+
+// src/config.ts
+if (false) throw new Error("$HUB_URL is required, e.g. HUB_URL=https://hub.directed.ai");
+var DEFAULTS = {
+  acceptMode: "send",
+  tmuxBin: "tmux",
+  hubUrl: "https://hub.directed.ai",
+  toChat: false,
+  chatTargetQuery: null,
+  openOnStart: true,
+  invitees: [],
+  inviteEmails: []
+};
+
+// src/update-check.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+function statePath() {
+  const home = process.env.DIRECTED_HOME ?? homedir();
+  return join(home, ".directed", "state.json");
+}
+function stateLoad() {
+  try {
+    return JSON.parse(readFileSync(statePath(), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function stateSave(state) {
+  try {
+    const path = statePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(state));
+  } catch {
+  }
+}
+function versionIsNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return false;
+}
+async function updateCheckRun(currentVersion, hubUrl, fetchImpl = fetch) {
+  const cached = stateLoad();
+  const now = Date.now();
+  let latest = cached?.latestKnownVersion;
+  if (!cached || now - cached.lastCheckedAt > CHECK_INTERVAL_MS) {
+    try {
+      const res = await fetchImpl(`${hubUrl}/cli/version`, { signal: AbortSignal.timeout(1500) });
+      if (res.ok) {
+        latest = (await res.json()).version;
+        stateSave({ lastCheckedAt: now, latestKnownVersion: latest });
+      }
+    } catch {
+    }
+  }
+  if (latest && versionIsNewer(latest, currentVersion)) {
+    process.stderr.write(`[directed] a new version is available (${currentVersion} -> ${latest}). Run 'directed upgrade' to update.
+`);
+  }
+}
+
+// src/upgrade.ts
+import { spawnSync } from "child_process";
+import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+async function upgradeRun(hubUrl, fetchImpl = fetch) {
+  const scriptUrl = `${hubUrl}/cli/install.sh`;
+  process.stdout.write(`[directed] fetching installer from ${scriptUrl}
+`);
+  const res = await fetchImpl(scriptUrl);
+  if (!res.ok) {
+    console.error(`[directed] could not fetch installer: ${res.status} ${res.statusText}`);
+    return 1;
+  }
+  const script = await res.text();
+  const dir = mkdtempSync(join2(tmpdir(), "directed-upgrade-"));
+  try {
+    const scriptPath = join2(dir, "install.sh");
+    writeFileSync2(scriptPath, script, { mode: 493 });
+    const result = spawnSync("bash", [scriptPath], {
+      stdio: "inherit",
+      env: { ...process.env, DIRECTED_CLI_BASE_URL: hubUrl }
+    });
+    return result.status ?? 1;
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// src/transcript/to-transcript.ts
+function turnToTranscript(turn) {
+  const text = turn.parts.filter((p) => p.kind === "text").map((p) => p.text).join("");
+  return { role: turn.role, text, clientTurnId: turn.id };
+}
+
+// src/transport.ts
+var HubTransport = class {
+  constructor(hub, tokenRefresher, source, conversation, title = "", echoGuard = null, externalRef = null, destinationChatPublicId = null, memberIdentifiers = [], onUserTurn = null) {
+    this.hub = hub;
+    this.tokenRefresher = tokenRefresher;
+    this.source = source;
+    this.conversation = conversation;
+    this.title = title;
+    this.echoGuard = echoGuard;
+    this.externalRef = externalRef;
+    this.destinationChatPublicId = destinationChatPublicId;
+    this.memberIdentifiers = memberIdentifiers;
+    this.onUserTurn = onUserTurn;
+  }
+  hub;
+  tokenRefresher;
+  source;
+  conversation;
+  title;
+  echoGuard;
+  externalRef;
+  destinationChatPublicId;
+  memberIdentifiers;
+  onUserTurn;
+  off = null;
+  sid = null;
+  chatPublicId = null;
+  agentActorPublicId = null;
+  wasReattached = false;
+  skippedInviteeList = [];
+  // On reattach, the id of the newest turn the hub already has. The resumed
+  // transcript replays from the top, and turns at or before this one must not
+  // post: some were never posted at all (mention echoes the original run's
+  // echo guard suppressed), so no server-side dedup row exists to catch them.
+  // Cleared once the replay passes it; null means no filtering.
+  replayCutoffId = null;
+  // Publishes chain through here so turnAppend for turn N resolves before N+1
+  // is sent -- message_seq is allocated in POST-arrival order, so concurrent
+  // posts (the snapshot backlog fires many at once) would scramble it.
+  chain = Promise.resolve();
+  get sessionId() {
+    return this.sid;
+  }
+  get chatId() {
+    return this.chatPublicId;
+  }
+  // The vendor agent's actor id, so a mention listener knows which member an
+  // @-mention must target to reach this CLI.
+  get agentActorId() {
+    return this.agentActorPublicId;
+  }
+  // Whether the hub matched externalRef to an earlier session (a resumed CLI
+  // run) and re-attached this one to that session's existing chat.
+  get reattached() {
+    return this.wasReattached;
+  }
+  // Invitees the hub could not match to an active connection and did not seat.
+  get skippedInvitees() {
+    return this.skippedInviteeList;
+  }
+  async start() {
+    const token = await this.tokenRefresher.current();
+    const session = await this.hub.sessionStart(token, {
+      source: this.source,
+      title: this.title,
+      externalRef: this.externalRef ?? void 0,
+      destinationChatPublicId: this.destinationChatPublicId ?? void 0,
+      memberIdentifiers: this.memberIdentifiers
+    });
+    this.sid = session.terminalSessionPublicId;
+    this.chatPublicId = session.chatPublicId;
+    this.agentActorPublicId = session.agentActorPublicId;
+    this.wasReattached = session.reattached === true;
+    this.skippedInviteeList = session.skippedMemberIdentifiers ?? [];
+    this.replayCutoffId = this.wasReattached ? session.lastClientTurnId || null : null;
+    const enqueue = (turn) => this.enqueue(turn);
+    for (const turn of this.conversation.snapshot()) enqueue(turn);
+    this.off = this.conversation.subscribe(enqueue);
+    return session.chatUrl;
+  }
+  async stop() {
+    this.off?.();
+    this.off = null;
+    await this.chain;
+    if (this.sid === null) return;
+    try {
+      const token = await this.tokenRefresher.current();
+      await this.hub.sessionEnd(token, this.sid);
+    } catch (e) {
+      process.stderr.write(`terminal session end post failed: ${String(e)}
+`);
+    }
+  }
+  enqueue(turn) {
+    if (this.replayCutoffId !== null) {
+      if (turn.id === this.replayCutoffId) this.replayCutoffId = null;
+      return;
+    }
+    const t = turnToTranscript(turn);
+    if (!t.text.trim()) return;
+    if (t.role === "user" && this.echoGuard?.consume(t.text)) return;
+    const sessionId = this.sid;
+    if (sessionId === null) return;
+    if (t.role === "user") this.onUserTurn?.(t.text);
+    this.chain = this.chain.then(async () => {
+      let token;
+      try {
+        token = await this.tokenRefresher.current();
+      } catch (e) {
+        process.stderr.write(`terminal session token refresh failed: ${String(e)}
+`);
+        return;
+      }
+      return this.hub.turnAppend(token, sessionId, t).then(() => {
+      }).catch((e) => {
+        process.stderr.write(`terminal session turn post failed: ${String(e)}
+`);
+      });
+    });
+  }
+};
+
+// src/session.ts
+import { spawn } from "child_process";
+import { rmSync as rmSync2 } from "fs";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { StringDecoder } from "string_decoder";
+
+// src/transcript/tailer.ts
+import { open, readFile, stat } from "fs/promises";
+var POLL_MS = 400;
+var TranscriptTailer = class {
+  constructor(adapter, cwd, sinceMs, processId, onTurn, onLocate = null) {
+    this.adapter = adapter;
+    this.cwd = cwd;
+    this.sinceMs = sinceMs;
+    this.processId = processId;
+    this.onTurn = onTurn;
+    this.onLocate = onLocate;
+  }
+  adapter;
+  cwd;
+  sinceMs;
+  processId;
+  onTurn;
+  onLocate;
+  timer = null;
+  file = null;
+  offset = 0;
+  partial = "";
+  ticking = false;
+  start() {
+    if (this.timer) return;
+    void this.tick();
+    this.timer = setInterval(() => void this.tick(), POLL_MS);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async tick() {
+    if (this.ticking) return;
+    this.ticking = true;
+    try {
+      if (this.file === null) {
+        await this.locate();
+      } else {
+        await this.tail();
+      }
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async locate() {
+    const found = await this.adapter.locate(this.cwd, this.sinceMs, this.processId);
+    if (!found) return;
+    this.file = found;
+    this.onLocate?.(found);
+    await this.readAll(found);
+  }
+  async readAll(file) {
+    const buf = await readFile(file);
+    this.offset = buf.length;
+    this.consume(buf.toString("utf8"));
+  }
+  async tail() {
+    const file = this.file;
+    if (!file) return;
+    const { size } = await stat(file);
+    if (size <= this.offset) return;
+    const length = size - this.offset;
+    const handle = await open(file, "r");
+    try {
+      const buf = Buffer.alloc(length);
+      await handle.read(buf, 0, length, this.offset);
+      this.offset = size;
+      this.consume(buf.toString("utf8"));
+    } finally {
+      await handle.close();
+    }
+  }
+  consume(text) {
+    const combined = this.partial + text;
+    const lines = combined.split("\n");
+    this.partial = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let record;
+      try {
+        record = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      const turn = this.adapter.parse(record);
+      if (turn) this.onTurn(turn);
+    }
+  }
+};
+
+// src/session.ts
+var BANNER = `
+                   \u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+                 \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591
+                \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+               \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+              \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+            \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+ \u2591\u2591       \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+ \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591
+   \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
+     \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591
+     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591
+    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2588\u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2588\u2588\u2591
+   \u2591\u2588\u2588\u2591\u2591 \u2591\u2588\u2588\u2588\u2591\u2591\u2588\u2588\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
+  \u2591\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591 \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591  \u2591\u2588\u2588\u2591
+   \u2591\u2588\u2588\u2591   \u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2591  \u2591\u2588\u2588\u2591\u2591 \u2591\u2591  \u2591\u2591\u2588\u2588\u2591
+    \u2591\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591  \u2591\u2591\u2591\u2591\u2591    \u2591\u2588\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2588\u2588\u2588\u2591
+     \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591             \u2591\u2591\u2588\u2588\u2588\u2588\u2588\u2588\u2591\u2591\u2591
+       \u2591\u2591\u2591\u2591\u2591\u2591\u2591                 \u2591\u2591\u2591\u2591\u2591\u2591
+
+  Directed helps you collaborate with AI.
+`;
+var SPLASH_MS = 3e3;
+function bannerWrap(command, cols, rows) {
+  const lines = BANNER.replace(/^\n+|\n+$/g, "").split("\n");
+  const width = Math.max(...lines.map((l) => l.length));
+  const left = " ".repeat(Math.max(0, Math.floor((cols - width) / 2)));
+  const top = "\n".repeat(Math.max(0, Math.floor((rows - lines.length) / 2)));
+  const centered = top + lines.map((l) => l.length > 0 ? left + l : l).join("\n");
+  return ["sh", "-c", `clear; printf '%s
+' '${centered}'; sleep ${SPLASH_MS / 1e3}; exec "$@"`, "sh", ...command];
+}
+var Session = class {
+  constructor(config, conversation, recorder, tmux, adapter, remote = null, echoGuard = null, onTranscriptLocate = null) {
+    this.config = config;
+    this.conversation = conversation;
+    this.recorder = recorder;
+    this.tmux = tmux;
+    this.adapter = adapter;
+    this.remote = remote;
+    this.echoGuard = echoGuard;
+    this.onTranscriptLocate = onTranscriptLocate;
+  }
+  config;
+  conversation;
+  recorder;
+  tmux;
+  adapter;
+  remote;
+  echoGuard;
+  onTranscriptLocate;
+  async run() {
+    const sinceMs = Date.now();
+    const cols = process.stdout.columns || 80;
+    const rows = process.stdout.rows || 24;
+    await this.tmux.newSession(bannerWrap(this.config.command, cols, rows), cols, rows);
+    const fifo = join3(tmpdir2(), `directed-${process.pid}.fifo`);
+    rmSync2(fifo, { force: true });
+    await exited(spawn("mkfifo", [fifo]));
+    const reader = spawn("cat", [fifo]);
+    const decoder = new StringDecoder("utf8");
+    reader.stdout.on("data", (d) => {
+      this.recorder.output(decoder.write(d));
+    });
+    await this.tmux.pipePane(fifo);
+    let tailer = null;
+    if (this.adapter) {
+      const processId = await this.tmux.panePid();
+      tailer = new TranscriptTailer(
+        this.adapter,
+        process.cwd(),
+        sinceMs,
+        processId,
+        (t) => this.conversation.add(t),
+        this.onTranscriptLocate
+      );
+    }
+    tailer?.start();
+    this.remote?.start((m) => {
+      this.echoGuard?.record(m.text);
+      void this.steer(m.text, m.author).catch(() => {
+      });
+    });
+    const sizeTimer = this.startSizePolling();
+    const code = await new Promise((resolve) => {
+      this.tmux.attach().on("exit", (c) => resolve(c ?? 0));
+    });
+    await this.remote?.stop();
+    if (sizeTimer) clearInterval(sizeTimer);
+    tailer?.stop();
+    reader.kill();
+    await this.tmux.kill();
+    rmSync2(fifo, { force: true });
+    return code;
+  }
+  startSizePolling() {
+    let last = "";
+    return setInterval(async () => {
+      const { cols, rows } = await this.tmux.paneSize().catch(() => ({ cols: 0, rows: 0 }));
+      if (!cols) return;
+      const key = `${cols}x${rows}`;
+      if (key !== last) {
+        last = key;
+        this.recorder.resize(cols, rows);
+      }
+    }, 1e3);
+  }
+  async steer(text, who) {
+    await this.tmux.sendText(text, this.config.acceptMode === "send");
+    this.recorder.marker(`${who}: ${text}`);
+  }
+};
+function exited(child) {
+  return new Promise((resolve, reject) => {
+    child.on("error", reject);
+    child.on("exit", (c) => c === 0 ? resolve() : reject(new Error(`exit ${c}`)));
+  });
+}
+
+// src/tmux.ts
+import { spawn as spawn2 } from "child_process";
+function defaultRunner(bin) {
+  return (args) => new Promise((resolve, reject) => {
+    const p = spawn2(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "", err = "";
+    p.stdout.on("data", (d) => out += d);
+    p.stderr.on("data", (d) => err += d);
+    p.on("error", reject);
+    p.on("exit", (code) => code === 0 ? resolve(out) : reject(new Error(`tmux ${args.join(" ")} failed: ${err.trim()}`)));
+  });
+}
+var Tmux = class {
+  constructor(bin, session, runner) {
+    this.bin = bin;
+    this.session = session;
+    this.runner = runner ?? defaultRunner(bin);
+  }
+  bin;
+  session;
+  runner;
+  inputBufferNumber = 0;
+  // Web and hub steers arrive independently; keep each paste and its submit
+  // key together so simultaneous messages cannot interleave in the pane.
+  inputWrite = Promise.resolve();
+  // Detached sessions default to 80x24 until a client attaches; sizing the
+  // pane up front means everything the child draws before attach (a resumed
+  // agent repaints its whole conversation immediately) wraps at the real
+  // terminal width, matching the recording header.
+  async newSession(command, cols, rows) {
+    await this.runner([
+      "new-session",
+      "-d",
+      "-s",
+      this.session,
+      "-x",
+      String(cols),
+      "-y",
+      String(rows),
+      "--",
+      ...command
+    ]);
+    await this.runner(["set-option", "-t", this.session, "status", "off"]);
+  }
+  async paneSize() {
+    const out = (await this.runner(["display-message", "-p", "-t", this.session, "#{pane_width}x#{pane_height}"])).trim();
+    const [cols, rows] = out.split("x").map(Number);
+    return { cols, rows };
+  }
+  async panePid() {
+    const out = await this.runner(["display-message", "-p", "-t", this.session, "#{pane_pid}"]);
+    const processId = Number(out.trim());
+    if (!Number.isSafeInteger(processId) || processId <= 0) {
+      throw new Error(`tmux returned an invalid pane PID: ${out.trim()}`);
+    }
+    return processId;
+  }
+  pipePane(fifo) {
+    return this.runner(["pipe-pane", "-o", "-t", this.session, `cat >> ${fifo}`]).then(() => {
+    });
+  }
+  async capturePane() {
+    return Buffer.from(await this.runner(["capture-pane", "-p", "-e", "-t", this.session]), "utf8");
+  }
+  sendText(text, submit) {
+    const write = this.inputWrite.then(() => this.textWrite(text, submit));
+    this.inputWrite = write.catch(() => {
+    });
+    return write;
+  }
+  async textWrite(text, submit) {
+    const buffer = `${this.session}-input-${this.inputBufferNumber}`;
+    this.inputBufferNumber += 1;
+    await this.runner(["set-buffer", "-b", buffer, "--", text]);
+    await this.runner(["paste-buffer", "-dpr", "-b", buffer, "-t", this.session]);
+    if (submit) await this.runner(["send-keys", "-t", this.session, "Enter"]);
+  }
+  async hasSession() {
+    return this.runner(["has-session", "-t", this.session]).then(() => true).catch(() => false);
+  }
+  attach() {
+    return spawn2(this.bin, ["attach", "-t", this.session], { stdio: "inherit" });
+  }
+  kill() {
+    return this.runner(["kill-session", "-t", this.session]).then(() => {
+    }).catch(() => {
+    });
+  }
+};
+
+// src/conversation-log.ts
+var ConversationLog = class {
+  turns = [];
+  subs = /* @__PURE__ */ new Set();
+  add(turn) {
+    this.turns.push(turn);
+    for (const s of this.subs) {
+      try {
+        s(turn);
+      } catch {
+        this.subs.delete(s);
+      }
+    }
+  }
+  snapshot() {
+    return [...this.turns];
+  }
+  subscribe(cb) {
+    this.subs.add(cb);
+    return () => this.subs.delete(cb);
+  }
+};
+
+// src/recorder.ts
+var Recorder = class {
+  startMs;
+  width;
+  height;
+  subs = /* @__PURE__ */ new Set();
+  constructor(cols, rows) {
+    this.startMs = Date.now();
+    this.width = cols;
+    this.height = rows;
+  }
+  output(data) {
+    this.append([this.elapsed(), "o", data]);
+  }
+  marker(label) {
+    this.append([this.elapsed(), "m", label]);
+  }
+  header() {
+    return {
+      version: 2,
+      width: this.width,
+      height: this.height,
+      timestamp: Math.floor(this.startMs / 1e3)
+    };
+  }
+  subscribe(cb) {
+    this.subs.add(cb);
+    return () => this.subs.delete(cb);
+  }
+  // Recorded as an "r" event so playback re-creates the pane geometry at the
+  // right point in time -- a replay against stale dims mis-wraps every line
+  // the app draws after the resize.
+  resize(cols, rows) {
+    if (cols === this.width && rows === this.height) return;
+    this.width = cols;
+    this.height = rows;
+    this.append([this.elapsed(), "r", `${cols}x${rows}`]);
+  }
+  elapsed() {
+    return (Date.now() - this.startMs) / 1e3;
+  }
+  append(ev) {
+    for (const sub of this.subs) {
+      try {
+        sub(ev);
+      } catch {
+        this.subs.delete(sub);
+      }
+    }
+  }
+};
+
+// src/hub-recording.ts
+var FLUSH_INTERVAL_MS = 250;
+var FLUSH_BYTES_MAX = 16 * 1024;
+var HubRecordingPublisher = class {
+  constructor(hub, tokenRefresher, sessionId, recorder) {
+    this.hub = hub;
+    this.tokenRefresher = tokenRefresher;
+    this.sessionId = sessionId;
+    this.recorder = recorder;
+  }
+  hub;
+  tokenRefresher;
+  sessionId;
+  recorder;
+  off = null;
+  buffer = [];
+  bufferBytes = 0;
+  timer = null;
+  seq = 0;
+  width = 0;
+  height = 0;
+  startedEpoch = 0;
+  // Publishes chain through here so chunk N posts before N+1 -- flushes can
+  // otherwise race (a byte-triggered flush vs. a slow prior POST) and scramble seq order.
+  chain = Promise.resolve();
+  start() {
+    const header = this.recorder.header();
+    this.width = header.width;
+    this.height = header.height;
+    this.startedEpoch = header.timestamp;
+    this.off = this.recorder.subscribe((ev) => this.append(ev));
+  }
+  async stop() {
+    this.off?.();
+    this.off = null;
+    this.flush();
+    await this.chain;
+  }
+  append(ev) {
+    this.buffer.push(ev);
+    this.bufferBytes += ev[2].length;
+    if (this.bufferBytes >= FLUSH_BYTES_MAX) {
+      this.flush();
+      return;
+    }
+    if (!this.timer) {
+      this.timer = setTimeout(() => this.flush(), FLUSH_INTERVAL_MS);
+    }
+  }
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length === 0) return;
+    const events = this.buffer;
+    const offset = events[0][0];
+    this.buffer = [];
+    this.bufferBytes = 0;
+    const seq = this.seq;
+    this.seq += 1;
+    this.chain = this.chain.then(async () => {
+      let token;
+      try {
+        token = await this.tokenRefresher.current();
+      } catch (e) {
+        process.stderr.write(`terminal session token refresh failed: ${String(e)}
+`);
+        return;
+      }
+      return this.hub.chunkAppend(token, this.sessionId, {
+        seq,
+        offset,
+        events,
+        width: this.width,
+        height: this.height,
+        startedEpoch: this.startedEpoch
+      }).catch((e) => {
+        process.stderr.write(`terminal session chunk post failed: ${String(e)}
+`);
+      });
+    });
+  }
+};
+
+// src/hub-mentions.ts
+function wsCtor() {
+  const g = globalThis;
+  return typeof g.WebSocket === "function" ? g.WebSocket : null;
+}
+var NON_WORD_RUN_RE = /^[^\w]*/;
+function agentMentionStrip(text, hits) {
+  let out = text;
+  for (const r of [...hits].sort((a, b) => b.start - a.start)) {
+    if (r.start >= 0 && r.start <= r.end && r.end <= out.length) {
+      const tail = NON_WORD_RUN_RE.exec(out.slice(r.end));
+      const tailEnd = r.end + (tail ? tail[0].length : 0);
+      out = out.slice(0, r.start) + out.slice(tailEnd);
+    }
+  }
+  return out;
+}
+function mentionPrompt(blocks, agentActorId) {
+  let mentioned = false;
+  const parts = [];
+  for (const b of blocks) {
+    if (b.kind !== "text" || typeof b.text !== "string") continue;
+    const hits = (b.mentions ?? []).filter((m) => m.actor_public_id === agentActorId);
+    if (hits.length > 0) mentioned = true;
+    const stripped = agentMentionStrip(b.text, hits).trim();
+    if (stripped) parts.push(stripped);
+  }
+  if (!mentioned) return null;
+  const text = parts.join("\n").trim();
+  return text.length > 0 ? text : null;
+}
+var RECONNECT_MAX_MS = 8e3;
+var HubMentions = class {
+  constructor(hubUrl, tokenRefresher, chatId, agentActorId, sinceMs) {
+    this.hubUrl = hubUrl;
+    this.tokenRefresher = tokenRefresher;
+    this.chatId = chatId;
+    this.agentActorId = agentActorId;
+    this.sinceMs = sinceMs;
+  }
+  hubUrl;
+  tokenRefresher;
+  chatId;
+  agentActorId;
+  sinceMs;
+  ws = null;
+  stopped = false;
+  handler = null;
+  reconnectTimer = null;
+  attempts = 0;
+  // Upsert protocol: the same message re-broadcasts as it streams or gets a
+  // reaction. Fire an @-mention once by remembering the ids we've injected.
+  seen = /* @__PURE__ */ new Set();
+  start(inject) {
+    this.handler = inject;
+    this.connect();
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.ws?.close(1e3);
+    this.ws = null;
+  }
+  connect() {
+    if (this.stopped) return;
+    const Ctor = wsCtor();
+    if (!Ctor) {
+      process.stderr.write(
+        "[directed] this Node has no WebSocket (needs >=22); @-mentions won't reach the CLI.\n"
+      );
+      return;
+    }
+    this.tokenRefresher.current().then((token) => this.openSocket(Ctor, token)).catch((e) => {
+      process.stderr.write(`[directed] could not fetch a token for the mentions socket: ${String(e)}
+`);
+      this.scheduleReconnect();
+    });
+  }
+  openSocket(Ctor, token) {
+    if (this.stopped) return;
+    const base = this.hubUrl.replace(/^http/, "ws");
+    const ws = new Ctor(`${base}/ws/chats/${this.chatId}/`, ["jwt", token]);
+    this.ws = ws;
+    ws.onopen = () => {
+      this.attempts = 0;
+    };
+    ws.onmessage = (ev) => this.onFrame(ev.data);
+    ws.onerror = () => {
+    };
+    ws.onclose = (ev) => {
+      this.ws = null;
+      if (this.stopped) return;
+      if (ev.code === 4001 || ev.code === 4003 || ev.code === 4004) {
+        process.stderr.write(
+          `[directed] chat socket closed (${ev.code}); @-mentions to the CLI are off.
+`
+        );
+        return;
+      }
+      if (ev.code === 4002) {
+        this.tokenRefresher.refreshNow().then(() => this.scheduleReconnect()).catch((e) => {
+          process.stderr.write(`[directed] could not refresh the mentions socket token: ${String(e)}
+`);
+          this.scheduleReconnect();
+        });
+        return;
+      }
+      this.scheduleReconnect();
+    };
+  }
+  scheduleReconnect() {
+    if (this.stopped || this.reconnectTimer) return;
+    const delay = Math.min(1e3 * 2 ** this.attempts, RECONNECT_MAX_MS);
+    this.attempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  onFrame(raw) {
+    if (typeof raw !== "string") return;
+    let env;
+    try {
+      env = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (env.kind !== "message_upsert") return;
+    const m = env.data;
+    if (!m || typeof m.public_id !== "string" || this.seen.has(m.public_id)) return;
+    if (m.actor?.public_id === this.agentActorId) return;
+    const createdMs = m.created_at ? Date.parse(m.created_at) : NaN;
+    if (Number.isFinite(createdMs) && createdMs <= this.sinceMs) return;
+    const text = mentionPrompt(m.blocks ?? [], this.agentActorId);
+    if (text === null) return;
+    this.seen.add(m.public_id);
+    this.handler?.({
+      text,
+      author: m.actor?.display_name ?? "someone",
+      seed: m.actor?.public_id ?? m.public_id,
+      ts: Number.isFinite(createdMs) ? createdMs : Date.now()
+    });
+  }
+};
+
+// src/echo-guard.ts
+var ECHO_TTL_MS = 3e4;
+function normalize(text) {
+  return text.trim();
+}
+var EchoGuard = class {
+  pending = [];
+  record(text) {
+    const norm = normalize(text);
+    if (!norm) return;
+    this.pending.push({ text: norm, at: Date.now() });
+  }
+  // True (and removes the entry) if `text` matches a still-live injected mention.
+  // Prunes expired entries on the way so they never suppress a real message.
+  consume(text) {
+    const now = Date.now();
+    this.pending = this.pending.filter((p) => now - p.at < ECHO_TTL_MS);
+    const norm = normalize(text);
+    const idx = this.pending.findIndex((p) => p.text === norm);
+    if (idx === -1) return false;
+    this.pending.splice(idx, 1);
+    return true;
+  }
+};
+
+// src/transcript/adapter.ts
+import { basename as basename3 } from "path";
+
+// src/transcript/claude.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { basename, join as join4 } from "path";
+function encodeProjectDir(cwd) {
+  return cwd.replace(/[/.]/g, "-");
+}
+var SESSION_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ClaudeAdapter = class {
+  async locate(cwd, sinceMs, _processId) {
+    const newest = await newestTranscript(projectDir(cwd));
+    if (!newest || newest.mtimeMs < sinceMs) return null;
+    return newest.path;
+  }
+  refFromPath(path) {
+    const name = basename(path);
+    if (!name.endsWith(".jsonl")) return null;
+    return name.slice(0, -".jsonl".length);
+  }
+  // Claude Code appends to the same <sessionId>.jsonl on --resume/--continue,
+  // so the resumed session's id is knowable before launch: from the flag's own
+  // argument, or from the newest transcript on disk for --continue. A bare
+  // --resume opens claude's interactive picker -- the target is unknowable, so
+  // it reads as a fresh session. --fork-session branches into a new id.
+  async resumeRef(command, cwd) {
+    const args = command.slice(1);
+    if (args.includes("--fork-session")) return null;
+    for (let i = 0; i < args.length; i++) {
+      const [flag, inline] = flagSplit(args[i]);
+      if (flag === "--resume" || flag === "-r" || flag === "--session-id") {
+        const candidate = inline ?? args[i + 1];
+        if (candidate !== void 0 && SESSION_ID_RE.test(candidate)) return candidate;
+      } else if (flag === "--continue" || flag === "-c") {
+        const newest = await newestTranscript(projectDir(cwd));
+        return newest ? this.refFromPath(newest.path) : null;
+      }
+    }
+    return null;
+  }
+  parse(record) {
+    const r = record;
+    if (r.type === "user") return this.parseUser(r);
+    if (r.type === "assistant") return this.parseAssistant(r);
+    return null;
+  }
+  parseUser(r) {
+    const content = r.message?.content;
+    if (typeof content !== "string") return null;
+    return { id: r.uuid, role: "user", ts: Date.parse(r.timestamp), parts: [{ kind: "text", text: content }] };
+  }
+  parseAssistant(r) {
+    const content = r.message?.content;
+    if (!Array.isArray(content)) return null;
+    const parts = [];
+    for (const block of content) {
+      if (block.type === "text" && block.text !== void 0) parts.push({ kind: "text", text: block.text });
+      else if (block.type === "thinking" && block.thinking !== void 0) parts.push({ kind: "thinking", text: block.thinking });
+      else if (block.type === "tool_use" && block.name !== void 0) parts.push({ kind: "tool", name: block.name });
+    }
+    if (parts.length === 0) return null;
+    return { id: r.uuid, role: "assistant", ts: Date.parse(r.timestamp), parts };
+  }
+};
+function projectDir(cwd) {
+  return join4(homedir2(), ".claude/projects", encodeProjectDir(cwd));
+}
+function flagSplit(arg) {
+  const at = arg.indexOf("=");
+  if (at === -1) return [arg, void 0];
+  return [arg.slice(0, at), arg.slice(at + 1)];
+}
+async function newestTranscript(dir) {
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return null;
+  }
+  let newest = null;
+  for (const entry of entries) {
+    if (!entry.endsWith(".jsonl")) continue;
+    const path = join4(dir, entry);
+    const info = await stat2(path);
+    if (!newest || info.mtimeMs > newest.mtimeMs) newest = { path, mtimeMs: info.mtimeMs };
+  }
+  return newest;
+}
+
+// src/transcript/codex.ts
+import { execFile } from "child_process";
+import { open as open2, readdir as readdir2, readlink } from "fs/promises";
+import { homedir as homedir3, platform } from "os";
+import { basename as basename2, join as join5 } from "path";
+var SESSION_ID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ROLLOUT_RE = /^rollout-.*-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+var SESSION_META_BYTES = 1024 * 1024;
+var CodexAdapter = class {
+  constructor(processRolloutPaths = rolloutPathsForProcess) {
+    this.processRolloutPaths = processRolloutPaths;
+  }
+  processRolloutPaths;
+  async locate(_cwd, _sinceMs, processId) {
+    const paths = await this.processRolloutPaths(processId);
+    const primaryPaths = [];
+    for (const path of paths) {
+      if (await isPrimaryRollout(path)) primaryPaths.push(path);
+    }
+    return primaryPaths.length === 1 ? primaryPaths[0] : null;
+  }
+  refFromPath(path) {
+    const match = ROLLOUT_RE.exec(basename2(path));
+    return match ? match[1] : null;
+  }
+  // `codex resume` reopens an existing rollout, whose filename keeps the
+  // original session uuid: the flag's own argument names it, and --last means
+  // the newest primary rollout in scope. A bare `codex resume` opens the
+  // interactive picker -- the target is unknowable, so it reads as a fresh session.
+  async resumeRef(command, cwd) {
+    const args = command.slice(1);
+    const subcommand = args.find((a) => !a.startsWith("-"));
+    if (subcommand !== "resume") return null;
+    const rest = args.slice(args.indexOf("resume") + 1);
+    const id = rest.find((a) => SESSION_ID_RE2.test(a));
+    if (id) return id;
+    if (rest.includes("--last")) {
+      const newest = await newestRollout(rest.includes("--all") ? null : cwd);
+      return newest ? this.refFromPath(newest) : null;
+    }
+    return null;
+  }
+  parse(record) {
+    const r = record;
+    if (r.type !== "response_item" || !r.payload) return null;
+    const p = r.payload;
+    const ts = Date.parse(r.timestamp);
+    const id = p.id ?? `codex-${ts}`;
+    if (p.type === "message") {
+      const role = p.role === "assistant" ? "assistant" : p.role === "user" ? "user" : null;
+      if (role === null) return null;
+      const parts = [];
+      for (const b of p.content ?? []) {
+        if ((b.type === "input_text" || b.type === "output_text") && typeof b.text === "string") {
+          parts.push({ kind: "text", text: b.text });
+        }
+      }
+      if (parts.length === 0) return null;
+      return { id, role, ts, parts };
+    }
+    if (p.type === "function_call" && typeof p.name === "string") {
+      return { id, role: "assistant", ts, parts: [{ kind: "tool", name: p.name }] };
+    }
+    return null;
+  }
+};
+async function newestRollout(cwd) {
+  const dir = join5(homedir3(), ".codex", "sessions");
+  let entries;
+  try {
+    entries = await readdir2(dir, { recursive: true });
+  } catch {
+    return null;
+  }
+  const rollouts = entries.filter((f) => {
+    const b = basename2(f);
+    return b.startsWith("rollout-") && b.endsWith(".jsonl");
+  });
+  rollouts.sort();
+  rollouts.reverse();
+  for (const rollout of rollouts) {
+    const path = join5(dir, rollout);
+    if (await isPrimaryRollout(path, cwd)) return path;
+  }
+  return null;
+}
+async function rolloutPathsForProcess(processId) {
+  if (platform() === "darwin") return macosRolloutPaths(processId);
+  if (platform() === "linux") return linuxRolloutPaths(processId);
+  return [];
+}
+async function macosRolloutPaths(processId) {
+  return new Promise((resolve) => {
+    execFile(
+      "/usr/sbin/lsof",
+      ["-a", "-p", String(processId), "-Fn"],
+      { encoding: "utf8", maxBuffer: 4 * 1024 * 1024 },
+      (error, stdout) => {
+        if (error) {
+          resolve([]);
+          return;
+        }
+        const paths = [];
+        for (const line of stdout.split("\n")) {
+          if (!line.startsWith("n")) continue;
+          const path = line.slice(1);
+          if (isRolloutPath(path)) paths.push(path);
+        }
+        resolve([...new Set(paths)]);
+      }
+    );
+  });
+}
+async function linuxRolloutPaths(processId) {
+  const fdDir = `/proc/${processId}/fd`;
+  let entries;
+  try {
+    entries = await readdir2(fdDir);
+  } catch {
+    return [];
+  }
+  const paths = [];
+  for (const entry of entries) {
+    let path;
+    try {
+      path = await readlink(join5(fdDir, entry));
+    } catch {
+      continue;
+    }
+    if (isRolloutPath(path)) paths.push(path);
+  }
+  return [...new Set(paths)];
+}
+function isRolloutPath(path) {
+  return ROLLOUT_RE.test(basename2(path));
+}
+async function isPrimaryRollout(path, cwd = null) {
+  const line = await firstLine(path);
+  if (line === null) return false;
+  let record;
+  try {
+    record = JSON.parse(line);
+  } catch {
+    return false;
+  }
+  if (!isRecord(record) || record.type !== "session_meta" || !isRecord(record.payload)) return false;
+  const pathMatch = ROLLOUT_RE.exec(basename2(path));
+  if (record.payload.source !== "cli" || record.payload.id !== pathMatch?.[1]) return false;
+  return cwd === null || record.payload.cwd === cwd;
+}
+async function firstLine(path) {
+  let handle;
+  try {
+    handle = await open2(path, "r");
+    const buffer = Buffer.alloc(SESSION_META_BYTES);
+    const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+    const lineEnd = buffer.indexOf("\n", 0);
+    if (bytesRead === 0 || lineEnd === -1 || lineEnd >= bytesRead) return null;
+    return buffer.subarray(0, lineEnd).toString("utf8");
+  } catch {
+    return null;
+  } finally {
+    await handle?.close();
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/transcript/adapter.ts
+function adapterFor(command) {
+  const program = command[0];
+  if (program === void 0) return null;
+  const name = basename3(program);
+  if (name === "claude") return new ClaudeAdapter();
+  if (name === "codex") return new CodexAdapter();
+  return null;
+}
+function sourceFor(command) {
+  const program = command[0];
+  if (program === void 0) return null;
+  const name = basename3(program);
+  if (name === "claude") return "claude_code";
+  if (name === "codex") return "codex";
+  return null;
+}
+
+// src/auth/hub.ts
+var HubClient = class {
+  constructor(hubUrl, fetchImpl = fetch) {
+    this.hubUrl = hubUrl;
+    this.fetchImpl = fetchImpl;
+  }
+  hubUrl;
+  fetchImpl;
+  get url() {
+    return this.hubUrl;
+  }
+  startUrl(redirectUri, challenge) {
+    const params = `redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${encodeURIComponent(challenge)}&code_challenge_method=S256`;
+    return `${this.hubUrl}/users/social/auth/mobile/start/?${params}`;
+  }
+  async exchange(code, verifier) {
+    const body = await this.postJson("/api/auth/mobile/exchange/", {
+      code,
+      code_verifier: verifier
+    });
+    return tokenPairFrom(body);
+  }
+  async refresh(refreshToken) {
+    const body = await this.postJson("/api/auth/mobile/refresh/", {
+      refresh_token: refreshToken
+    });
+    return tokenPairFrom(body);
+  }
+  async me(accessToken) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/auth/me/`, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!res.ok) {
+      throw new Error(`GET /api/auth/me/ failed: ${res.status}`);
+    }
+    const body = await res.json();
+    return {
+      publicId: body.public_id,
+      email: body.email,
+      username: body.username,
+      fullName: body.full_name
+    };
+  }
+  async sessionStart(accessToken, input2) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: JSON.stringify({
+        source: input2.source,
+        title: input2.title ?? "",
+        external_ref: input2.externalRef ?? "",
+        destination_chat_public_id: input2.destinationChatPublicId ?? "",
+        member_identifiers: input2.memberIdentifiers ?? []
+      })
+    });
+    if (!res.ok) {
+      const detail = await errorDetail(res);
+      throw new Error(`POST /api/terminal-sessions/ failed: ${res.status}${detail ? ` (${detail})` : ""}`);
+    }
+    const b = await res.json();
+    return {
+      chatPublicId: b.chat_public_id,
+      terminalSessionPublicId: b.terminal_session_public_id,
+      chatUrl: b.chat_url,
+      agentActorPublicId: b.agent_actor_public_id,
+      reattached: b.reattached === true,
+      lastClientTurnId: typeof b.last_client_turn_id === "string" ? b.last_client_turn_id : "",
+      skippedMemberIdentifiers: Array.isArray(b.skipped_member_identifiers) ? b.skipped_member_identifiers : []
+    };
+  }
+  // Mint (or reuse) the chat's shareable join link. Redeeming it seats the
+  // visitor as a chat member, so it works for people outside the host's
+  // connections -- the email-invite path.
+  async chatLinkCreate(accessToken, chatPublicId) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/chats/${chatPublicId}/link/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: "{}"
+    });
+    if (!res.ok) throw new Error(`POST /api/chats/${chatPublicId}/link/ failed: ${res.status}`);
+    const b = await res.json();
+    return b.url;
+  }
+  async chatLookup(accessToken, query) {
+    const params = new URLSearchParams({ q: query, limit: "10" });
+    const res = await this.fetchImpl(`${this.hubUrl}/api/chats/lookup/?${params.toString()}`, {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!res.ok) throw new Error(`GET /api/chats/lookup/ failed: ${res.status}`);
+    const body = await res.json();
+    const rows = [];
+    for (const item of body.items) {
+      rows.push({
+        publicId: item.public_id,
+        title: item.display_title,
+        url: item.chat_url
+      });
+    }
+    return rows;
+  }
+  async sessionEnd(accessToken, sessionId) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/end/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: "{}"
+    });
+    if (!res.ok) throw new Error(`POST .../end/ failed: ${res.status}`);
+  }
+  // Stamp the tool's own session id on a hub session that started without one
+  // (a fresh launch learns it only once the transcript file appears). Pairs a
+  // later resume of the same agent session back to the same chat.
+  async sessionRefSet(accessToken, sessionId, externalRef) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/external-ref/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: JSON.stringify({ external_ref: externalRef })
+    });
+    if (!res.ok) throw new Error(`POST .../external-ref/ failed: ${res.status}`);
+  }
+  async turnAppend(accessToken, sessionId, turn) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/turns/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: JSON.stringify({ role: turn.role, text: turn.text, client_turn_id: turn.clientTurnId })
+    });
+    if (!res.ok) throw new Error(`POST .../turns/ failed: ${res.status}`);
+    const b = await res.json();
+    return { messagePublicId: b.message_public_id };
+  }
+  async chunkAppend(accessToken, sessionId, chunk) {
+    const res = await this.fetchImpl(`${this.hubUrl}/api/terminal-sessions/${sessionId}/chunks/`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${accessToken}` },
+      body: JSON.stringify({
+        seq: chunk.seq,
+        offset: chunk.offset,
+        events: chunk.events,
+        width: chunk.width,
+        height: chunk.height,
+        started_epoch: chunk.startedEpoch
+      })
+    });
+    if (!res.ok) throw new Error(`POST .../chunks/ failed: ${res.status}`);
+  }
+  async postJson(path, payload) {
+    const res = await this.fetchImpl(`${this.hubUrl}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      throw new Error(`POST ${path} failed: ${res.status}`);
+    }
+    return await res.json();
+  }
+};
+async function errorDetail(res) {
+  try {
+    const body = await res.json();
+    return typeof body.detail === "string" ? body.detail : "";
+  } catch {
+    return "";
+  }
+}
+function tokenPairFrom(body) {
+  return {
+    access: body.access_token,
+    refresh: body.refresh_token,
+    expiresAt: Date.now() + body.expires_in * 1e3
+  };
+}
+
+// src/auth/store.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname2, join as join6 } from "path";
+function authPath() {
+  const home = process.env.DIRECTED_HOME ?? homedir4();
+  return join6(home, ".directed", "auth.json");
+}
+function authLoad(hubUrl) {
+  try {
+    const raw = readFileSync2(authPath(), "utf8");
+    const stored = JSON.parse(raw);
+    if (stored.hubUrl !== hubUrl) return null;
+    return stored;
+  } catch {
+    return null;
+  }
+}
+function authSave(a) {
+  const path = authPath();
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(a, null, 2), { mode: 384 });
+}
+function authClear() {
+  const path = authPath();
+  if (existsSync(path)) {
+    rmSync3(path);
+  }
+}
+
+// src/auth/login.ts
+import http from "http";
+
+// src/auth/pkce.ts
+import { createHash, randomBytes } from "crypto";
+function pkce() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+
+// src/auth/login.ts
+var LOGIN_TIMEOUT_MS = 3e5;
+var SUCCESS_BODY = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="color-scheme" content="light dark" />
+    <title>Signed in - Directed AI</title>
+    <style>
+      :root {
+        color-scheme: light dark;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-family: system-ui, sans-serif;
+        -webkit-font-smoothing: antialiased;
+        -moz-osx-font-smoothing: grayscale;
+        background: #fff;
+        color: #1a1a1a;
+      }
+      main {
+        text-align: center;
+        padding: 0 24px;
+      }
+      img {
+        display: block;
+        margin: 0 auto 12px;
+      }
+      h1 {
+        font-size: 24px;
+        font-weight: 600;
+        letter-spacing: -0.02em;
+        margin: 0 0 8px;
+      }
+      p {
+        margin: 0;
+        color: #6b6b6b;
+      }
+      @media (prefers-color-scheme: dark) {
+        body {
+          background: #1a1a1a;
+          color: #f5f5f5;
+        }
+        p {
+          color: #a0a0a0;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <main>
+      <img
+        src="https://res.cloudinary.com/dnriuttuy/image/upload/v1761205887/dino-black-with-white-outline_nk3vhs.svg"
+        alt="Dino"
+        width="40"
+        height="40"
+      />
+      <h1>You are signed in</h1>
+      <p>You can close this tab and return to your terminal.</p>
+    </main>
+  </body>
+</html>`;
+function codeFromRequestUrl(url) {
+  const parsed = new URL(url ?? "/", "http://127.0.0.1");
+  return parsed.searchParams.get("code");
+}
+function loginFlow(hub, open3) {
+  const { verifier, challenge } = pkce();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const server = http.createServer((req, res) => {
+      const code = codeFromRequestUrl(req.url);
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/plain" });
+        res.end("Missing code");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(SUCCESS_BODY);
+      onCode(code);
+    });
+    const timer = setTimeout(() => {
+      settle(() => reject(new Error("Login timed out after 300s")));
+    }, LOGIN_TIMEOUT_MS);
+    function settle(run) {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      server.close();
+      run();
+    }
+    async function onCode(code) {
+      try {
+        const tok = await hub.exchange(code, verifier);
+        const identity = await hub.me(tok.access);
+        const stored = {
+          access: tok.access,
+          refresh: tok.refresh,
+          expiresAt: tok.expiresAt,
+          identity,
+          hubUrl: hub.url
+        };
+        authSave(stored);
+        settle(() => resolve(stored));
+      } catch (err) {
+        settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+      }
+    }
+    server.on("error", (err) => {
+      settle(() => reject(err));
+    });
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        settle(() => reject(new Error("Failed to determine loopback server port")));
+        return;
+      }
+      const redirectUri = `http://127.0.0.1:${address.port}/cb`;
+      open3(hub.startUrl(redirectUri, challenge));
+    });
+  });
+}
+
+// src/auth/ensure.ts
+var EXPIRY_SKEW_MS = 6e4;
+async function ensureAuth(hub, opts) {
+  const stored = authLoad(hub.url);
+  if (stored && stored.expiresAt - EXPIRY_SKEW_MS > Date.now()) {
+    return stored.identity;
+  }
+  if (stored) {
+    try {
+      const tok = await hub.refresh(stored.refresh);
+      const identity = await hub.me(tok.access);
+      authSave({
+        access: tok.access,
+        refresh: tok.refresh,
+        expiresAt: tok.expiresAt,
+        identity,
+        hubUrl: hub.url
+      });
+      return identity;
+    } catch {
+    }
+  }
+  if (opts.autoLogin) {
+    const fresh = await loginFlow(hub, opts.open);
+    return fresh.identity;
+  }
+  throw new Error("Not signed in. Run `directed login` first.");
+}
+
+// src/auth/browser.ts
+import { spawn as spawn3 } from "child_process";
+var OPENERS = {
+  darwin: (url) => ["open", [url]],
+  linux: (url) => ["xdg-open", [url]],
+  win32: (url) => ["cmd", ["/c", "start", "", url]]
+};
+function openBrowser(url) {
+  const opener = OPENERS[process.platform];
+  if (!opener) {
+    return;
+  }
+  const [command, args] = opener(url);
+  try {
+    const child = spawn3(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+
+// src/auth/token-refresher.ts
+var EXPIRY_SKEW_MS2 = 6e4;
+var TokenRefresher = class {
+  constructor(hub, stored) {
+    this.hub = hub;
+    this.stored = stored;
+  }
+  hub;
+  stored;
+  refreshing = null;
+  async current() {
+    if (this.stored.expiresAt - EXPIRY_SKEW_MS2 > Date.now()) {
+      return this.stored.access;
+    }
+    return this.refreshNow();
+  }
+  // Unconditionally refreshes (deduped against a concurrent call), for when
+  // the server has already said the token is bad -- a 401, or a chat-socket
+  // close code 4002 -- regardless of what our local clock thinks.
+  async refreshNow() {
+    if (!this.refreshing) {
+      this.refreshing = this.refresh();
+    }
+    try {
+      return await this.refreshing;
+    } finally {
+      this.refreshing = null;
+    }
+  }
+  async refresh() {
+    const tok = await this.hub.refresh(this.stored.refresh);
+    this.stored = { ...this.stored, access: tok.access, refresh: tok.refresh, expiresAt: tok.expiresAt };
+    authSave(this.stored);
+    return this.stored.access;
+  }
+};
+
+// src/chat-target.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+var DEFAULT_TERMINAL = { input, output };
+function chatTargetChoice(answer, count) {
+  const value = Number(answer.trim());
+  if (!Number.isInteger(value) || value < 1 || value > count) return null;
+  return value;
+}
+function chatTargetPublicId(value) {
+  const trimmed = value.trim();
+  try {
+    const url = new URL(trimmed);
+    const match = url.pathname.match(/\/chat\/([^/]+)\/?$/);
+    return match ? decodeURIComponent(match[1]) : trimmed;
+  } catch {
+    return trimmed;
+  }
+}
+function chatTargetExact(query, chatList) {
+  const publicId = chatTargetPublicId(query);
+  return chatList.some((chat) => chat.publicId === publicId) ? publicId : null;
+}
+function chatTargetMenu(chatList) {
+  const lines = ["", "Recent Directed chats:"];
+  for (const [index, chat] of chatList.entries()) {
+    lines.push(`${index + 1}. ${chat.title}`);
+    lines.push(`   ${chat.url}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+async function chatTargetPick(hub, accessToken, query, terminal = DEFAULT_TERMINAL) {
+  let prompt = null;
+  try {
+    const search = query.trim();
+    if (search) {
+      const chats2 = await hub.chatLookup(accessToken, search);
+      const exactPublicId = chatTargetExact(search, chats2);
+      if (exactPublicId) return exactPublicId;
+      throw new Error("--into=<value> must resolve to an exact Directed chat URL or public id");
+    }
+    if (!terminal.input.isTTY || !terminal.output.isTTY) {
+      throw new Error("--into needs an interactive terminal; use --into=<Directed chat URL or exact public id>");
+    }
+    const chats = await hub.chatLookup(accessToken, "");
+    if (chats.length === 0) {
+      throw new Error("No recent chats available; run without --into to start a new chat");
+    }
+    prompt = createInterface({ input: terminal.input, output: terminal.output });
+    terminal.output.write(chatTargetMenu(chats));
+    const answer = await prompt.question(`Choose a chat [1-${chats.length}]: `);
+    const choice = chatTargetChoice(answer, chats.length);
+    if (choice === null) throw new Error("Choose a listed chat number");
+    return chats[choice - 1].publicId;
+  } finally {
+    prompt?.close();
+  }
+}
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var CLI_VERSION = require2("../package.json").version;
+function helpText() {
+  return `directed - run an interactive coding agent in a Directed chat
+
+Usage:
+  directed [options] <command> [args...]
+  directed login
+  directed logout
+  directed upgrade
+
+Options:
+  --accept-mode <send|stage> Submit chat steers immediately or stage them
+  --chat                     Stream the session to a Directed chat
+  --no-chat                  Do not stream the session to a Directed chat
+  --into[=<URL or public id>] Choose a recent chat or give an exact target
+  --with <people>            Add @usernames or emails to the session chat
+  --invite <emails>          Open an email draft with the chat join link
+  --open                     Open the session chat in a browser
+  --no-open                  Do not open the session chat in a browser
+  --name <label>             Set the session label
+  --tmux-bin <path>          Use a specific tmux executable
+  -h, --help                 Show this help
+
+Everything after <command> is passed to that command unchanged.
+
+Examples:
+  directed codex
+  directed --with @jane claude
+  directed codex --help`;
+}
+function isHelpRequest(argv) {
+  return argv[0] === "--help" || argv[0] === "-h";
+}
+function asMode(v) {
+  if (v !== "send" && v !== "stage") throw new Error(`--accept-mode must be 'send' or 'stage', got '${v}'`);
+  return v;
+}
+function commandSplit(argv) {
+  let acceptMode = DEFAULTS.acceptMode;
+  let sessionName = "", tmuxBin = DEFAULTS.tmuxBin, openOnStart = DEFAULTS.openOnStart, invitees = DEFAULTS.invitees, inviteEmails = DEFAULTS.inviteEmails;
+  let toChatFlag;
+  let chatTargetQuery = null;
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "--accept-mode") {
+      acceptMode = asMode(argv[i + 1]);
+      i += 2;
+    } else if (a === "--name") {
+      sessionName = argv[i + 1];
+      i += 2;
+    } else if (a === "--tmux-bin") {
+      tmuxBin = argv[i + 1];
+      i += 2;
+    } else if (a === "--chat") {
+      toChatFlag = true;
+      i += 1;
+    } else if (a === "--no-chat") {
+      toChatFlag = false;
+      i += 1;
+    } else if (a === "--into") {
+      chatTargetQuery = "";
+      i += 1;
+    } else if (a.startsWith("--into=")) {
+      chatTargetQuery = a.slice("--into=".length);
+      i += 1;
+    } else if (a === "--open") {
+      openOnStart = true;
+      i += 1;
+    } else if (a === "--no-open") {
+      openOnStart = false;
+      i += 1;
+    } else if (a === "--with") {
+      invitees = (argv[i + 1] ?? "").split(",").map((e) => e.trim()).filter(Boolean);
+      i += 2;
+    } else if (a === "--invite") {
+      inviteEmails = (argv[i + 1] ?? "").split(",").map((e) => e.trim()).filter(Boolean);
+      for (const email of inviteEmails) {
+        if (!email.includes("@") || email.startsWith("@")) {
+          throw new Error(`--invite takes emails only, got '${email}' (use --with for @usernames)`);
+        }
+      }
+      i += 2;
+    } else if (a.startsWith("-")) {
+      throw new Error(`unknown directed option '${a}'; run 'directed --help'`);
+    } else {
+      break;
+    }
+  }
+  const command = argv.slice(i);
+  if (command.length === 0) throw new Error("usage: directed [flags] <command> [args...]");
+  const toChat = toChatFlag ?? sourceFor(command) !== null;
+  const chatTitle = sessionName;
+  if (!sessionName) sessionName = command.join(" ");
+  return {
+    command,
+    acceptMode,
+    sessionName,
+    chatTitle,
+    tmuxBin,
+    hubUrl: DEFAULTS.hubUrl,
+    toChat,
+    chatTargetQuery,
+    openOnStart,
+    invitees,
+    inviteEmails
+  };
+}
+function inviteMailto(emails, joinUrl, hostName) {
+  const subject = `${hostName} invited you to a live Directed session`;
+  const body = [
+    "Hi,",
+    "",
+    "I'm running a live coding session and want you in the chat -- follow along and jump in here:",
+    "",
+    joinUrl,
+    "",
+    "See you there,",
+    hostName
+  ].join("\n");
+  return `mailto:${emails.join(",")}?subject=${encodeURIComponent(subject)}&body=${encodeURIComponent(body)}`;
+}
+async function inviteDraftOpen(hub, hubChat, emails, hostName) {
+  try {
+    const token = await hubChat.tokenRefresher.current();
+    const joinUrl = await hub.chatLinkCreate(token, hubChat.chatId);
+    process.stdout.write(`[directed] join link: ${joinUrl}
+[directed] opening mail draft to: ${emails.join(", ")}
+`);
+    openBrowser(inviteMailto(emails, joinUrl, hostName));
+  } catch (err) {
+    process.stderr.write(`[directed] could not prepare the email invite (${err.message}); invite them from the chat instead.
+`);
+  }
+}
+async function hubChatStart(hub, config, conversation, echoGuard, externalRef, destinationChatPublicId, recorder) {
+  const source = sourceFor(config.command);
+  if (!source) {
+    process.stderr.write("[directed] chat streaming only works for claude and codex sessions; this tool has no transcript, skipping the chat.\n");
+    return null;
+  }
+  const stored = authLoad(config.hubUrl);
+  if (!stored) {
+    process.stderr.write("[directed] no signed-in session; run 'directed login' to stream this session to a chat. Continuing without one.\n");
+    return null;
+  }
+  const tokenRefresher = new TokenRefresher(hub, stored);
+  const who = stored.identity.fullName || stored.identity.username;
+  const chat = new HubTransport(
+    hub,
+    tokenRefresher,
+    source,
+    conversation,
+    config.chatTitle,
+    echoGuard,
+    externalRef,
+    destinationChatPublicId,
+    config.invitees,
+    (text) => recorder.marker(`${who}: ${text}`)
+  );
+  try {
+    const url = await chat.start();
+    const sessionId = chat.sessionId;
+    const chatId = chat.chatId;
+    const agentActorId = chat.agentActorId;
+    if (sessionId === null || chatId === null || agentActorId === null) {
+      throw new Error("terminal session ids missing after start");
+    }
+    const verb = chat.reattached ? "re-attached this session to its chat" : "streaming this session to a chat";
+    process.stdout.write(`[directed] ${verb}: ${url}
+`);
+    if (chat.skippedInvitees.length > 0) {
+      process.stderr.write(`[directed] not added (not your active connections): ${chat.skippedInvitees.join(", ")}
+`);
+    }
+    if (config.openOnStart) setTimeout(() => openBrowser(url), SPLASH_MS);
+    return { transport: chat, sessionId, chatId, agentActorId, tokenRefresher };
+  } catch (err) {
+    process.stderr.write(`[directed] could not open the chat (${err.message}); continuing locally.
+`);
+    return null;
+  }
+}
+async function main(argv = process.argv.slice(2)) {
+  if (isHelpRequest(argv)) {
+    process.stdout.write(`${helpText()}
+`);
+    return 0;
+  }
+  if (argv[0] === "upgrade") {
+    return upgradeRun(DEFAULTS.hubUrl);
+  }
+  await updateCheckRun(CLI_VERSION, DEFAULTS.hubUrl);
+  if (argv[0] === "login") {
+    const hub2 = new HubClient(DEFAULTS.hubUrl);
+    const auth = await loginFlow(hub2, openBrowser);
+    process.stdout.write(`[directed] signed in as ${auth.identity.email}
+`);
+    return 0;
+  }
+  if (argv[0] === "logout") {
+    authClear();
+    process.stdout.write(`[directed] signed out
+`);
+    return 0;
+  }
+  const config = commandSplit(argv);
+  const hub = new HubClient(config.hubUrl);
+  let identity;
+  try {
+    identity = await ensureAuth(hub, { autoLogin: true, open: openBrowser });
+  } catch (err) {
+    console.error(`[directed] ${err.message}`);
+    return 1;
+  }
+  process.stdout.write(`[directed] signed in as ${identity.email}
+`);
+  let destinationChatPublicId = null;
+  if (config.toChat && config.chatTargetQuery !== null) {
+    const stored = authLoad(config.hubUrl);
+    if (!stored) {
+      console.error("[directed] signed-in token missing after authentication");
+      return 1;
+    }
+    try {
+      const token = await new TokenRefresher(hub, stored).current();
+      destinationChatPublicId = await chatTargetPick(hub, token, config.chatTargetQuery);
+    } catch (err) {
+      console.error(`[directed] could not choose a chat target: ${err.message}`);
+      return 1;
+    }
+  }
+  try {
+    execFileSync(config.tmuxBin, ["-V"], { stdio: "ignore" });
+  } catch {
+    console.error(`directed needs tmux on PATH (or pass --tmux-bin <path>). Install it, e.g. 'brew install tmux'.`);
+    return 1;
+  }
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+  const conversation = new ConversationLog();
+  const recorder = new Recorder(cols, rows);
+  const adapter = adapterFor(config.command);
+  const tmux = new Tmux(config.tmuxBin, `directed-${randomBytes2(4).toString("hex")}`);
+  const echoGuard = config.toChat ? new EchoGuard() : null;
+  const resumeRef = config.toChat && adapter ? await adapter.resumeRef(config.command, process.cwd()) : null;
+  const hubChat = config.toChat ? await hubChatStart(hub, config, conversation, echoGuard, resumeRef, destinationChatPublicId, recorder) : null;
+  if (config.inviteEmails.length > 0) {
+    if (hubChat) {
+      await inviteDraftOpen(hub, hubChat, config.inviteEmails, identity.fullName || identity.username);
+    } else {
+      process.stderr.write("[directed] --invite needs a hub chat; no invite sent.\n");
+    }
+  }
+  const mentions = hubChat ? new HubMentions(config.hubUrl, hubChat.tokenRefresher, hubChat.chatId, hubChat.agentActorId, Date.now()) : null;
+  const refStamp = hubChat && adapter && !resumeRef ? (file) => {
+    const ref = adapter.refFromPath(file);
+    if (!ref) return;
+    hubChat.tokenRefresher.current().then((token) => hub.sessionRefSet(token, hubChat.sessionId, ref)).catch((e) => {
+      process.stderr.write(`terminal session ref post failed: ${String(e)}
+`);
+    });
+  } : null;
+  const session = new Session(config, conversation, recorder, tmux, adapter, mentions, echoGuard, refStamp);
+  const recording = hubChat ? new HubRecordingPublisher(hub, hubChat.tokenRefresher, hubChat.sessionId, recorder) : null;
+  recording?.start();
+  const code = await session.run();
+  if (recording) await recording.stop();
+  if (hubChat) await hubChat.transport.stop();
+  return code;
+}
+var argv1 = process.argv[1] ? realpathSync(process.argv[1]) : "";
+if (import.meta.url === pathToFileURL(argv1).href) {
+  main().then((code) => process.exit(code)).catch((err) => {
+    console.error(err?.message ?? err);
+    process.exit(1);
+  });
+}
+export {
+  commandSplit,
+  helpText,
+  inviteMailto,
+  isHelpRequest,
+  main
+};