agentlink-daemon 0.1.0 → 0.2.0

package/dist/main.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 
 // src/main.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFileSync, readdirSync as readdirSync2, realpathSync, statSync } from "node:fs";
+import { readFileSync as readFileSync4, readdirSync as readdirSync3, realpathSync, statSync } from "node:fs";
 import { hostname } from "node:os";
-import { join as join2, resolve, sep } from "node:path";
+import { join as join5, resolve } from "node:path";
+import { parseArgs as nodeParseArgs } from "node:util";
 import { WebSocket } from "ws";
 
-// src/agents.ts
+// src/env.ts
+import { spawn } from "node:child_process";
 import { existsSync, readdirSync } from "node:fs";
 import { homedir, platform } from "node:os";
-import { join, delimiter } from "node:path";
+import { delimiter, join } from "node:path";
 function extraDirs(home) {
   const dirs = [join(home, ".local", "bin"), join(home, ".npm-global", "bin")];
   if (platform() !== "win32") dirs.push("/opt/homebrew/bin", "/usr/local/bin");
@@ -37,6 +39,44 @@ function resolveBin(name) {
 function spawnEnv() {
   return { ...process.env, PATH: PATH_DIRS.join(delimiter) };
 }
+function captureCommand(bin, args, timeoutMs) {
+  return new Promise((done) => {
+    let out = "";
+    let settled = false;
+    const settle = (value) => {
+      if (!settled) {
+        settled = true;
+        done(value);
+      }
+    };
+    let child;
+    try {
+      child = spawn(bin, args, { env: spawnEnv(), stdio: ["ignore", "pipe", "ignore"] });
+    } catch {
+      return settle(null);
+    }
+    const timer = setTimeout(() => {
+      child.kill();
+      settle(null);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => out += chunk.toString("utf-8"));
+    child.on("error", () => {
+      clearTimeout(timer);
+      settle(null);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      settle(code === 0 ? out : null);
+    });
+  });
+}
+
+// src/adapters/claude.ts
+import { readFileSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/adapters/util.ts
 function parseJsonLine(line) {
   try {
     return JSON.parse(line);
@@ -49,6 +89,12 @@ function resultText(content) {
   if (Array.isArray(content)) return content.map((c) => c?.type === "text" ? c.text : JSON.stringify(c)).join("\n");
   return JSON.stringify(content);
 }
+function sanitizeModelName(raw) {
+  const clean = raw.replace(/\x1b\[[0-9;]*[A-Za-z]/g, "").replace(/\[[0-9;]*m\]?/g, "").replace(/[\x00-\x1f\x7f]/g, "").trim();
+  return clean.length > 0 ? clean : null;
+}
+
+// src/adapters/claude.ts
 function createClaudeParser(emit) {
   const streamed = /* @__PURE__ */ new Set();
   let messageId = null;
@@ -97,6 +143,60 @@ function createClaudeParser(emit) {
     }
   };
 }
+function probeClaudeModels() {
+  const names = [];
+  const add = (v) => {
+    if (typeof v !== "string") return;
+    const name = sanitizeModelName(v);
+    if (name && !names.includes(name)) names.push(name);
+  };
+  try {
+    const s = JSON.parse(readFileSync(join2(homedir2(), ".claude", "settings.json"), "utf-8"));
+    add(s?.model);
+  } catch {
+  }
+  try {
+    const c = JSON.parse(readFileSync(join2(homedir2(), ".claude.json"), "utf-8"));
+    add(c?.model);
+    if (c?.lastModelUsage && typeof c.lastModelUsage === "object") {
+      for (const k of Object.keys(c.lastModelUsage)) add(k);
+    }
+  } catch {
+  }
+  return names;
+}
+var claude = {
+  id: "claude",
+  label: "Claude Code",
+  // Suggested aliases; claude also accepts full model ids via --model.
+  // probeClaudeModels adds whatever this install is actually configured
+  // with (settings.json / ~/.claude.json), merged ahead of these.
+  models: ["opus", "sonnet", "haiku"],
+  probeModels: async () => probeClaudeModels(),
+  // --resume <id> works with -p (print) mode too, and was verified live:
+  // a fresh process, given only --resume and a new prompt, correctly
+  // recalled facts from an earlier, separate process's conversation.
+  buildInvocation: (prompt, resumeId, model) => ({
+    args: [
+      "-p",
+      "--output-format",
+      "stream-json",
+      "--verbose",
+      "--include-partial-messages",
+      "--permission-mode",
+      "bypassPermissions",
+      ...model ? ["--model", model] : [],
+      ...resumeId ? ["--resume", resumeId] : []
+    ],
+    stdin: prompt
+  }),
+  createParser: createClaudeParser
+};
+
+// src/adapters/codex.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
 function createCodexParser(emit) {
   const seen = /* @__PURE__ */ new Set();
   return (line) => {
@@ -132,61 +232,87 @@ function createCodexParser(emit) {
     }
   };
 }
-var REGISTRY = [
-  {
-    id: "claude",
-    label: "Claude Code",
-    // --resume <id> works with -p (print) mode too, and was verified live:
-    // a fresh process, given only --resume and a new prompt, correctly
-    // recalled facts from an earlier, separate process's conversation.
-    buildInvocation: (prompt, resumeId) => ({
-      args: [
-        "-p",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--include-partial-messages",
-        "--permission-mode",
-        "bypassPermissions",
-        ...resumeId ? ["--resume", resumeId] : []
-      ],
-      stdin: prompt
-    }),
-    createParser: createClaudeParser
-  },
-  {
-    id: "codex",
-    label: "Codex CLI",
-    // UNVERIFIED resume (see ai-spawn HANDOFF.md): `codex exec resume <id>`
-    // is a different subcommand from `codex exec`, and its flag set doesn't
-    // include `--sandbox` — the closest equivalent for "don't block on an
-    // approval prompt" is `--dangerously-bypass-approvals-and-sandbox`,
-    // which is a stronger bypass than the workspace-write sandbox used on
-    // a fresh run. That's consistent with claude's own bypassPermissions
-    // above (this system already trusts the agent fully once it's running),
-    // but never exercised end-to-end because of an account rate limit
-    // during development — verify before relying on it.
-    buildInvocation: (prompt, resumeId) => ({
-      args: resumeId ? ["exec", "resume", resumeId, "-", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox"] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write"],
+function probeCodexModels() {
+  try {
+    const text = readFileSync2(join3(homedir3(), ".codex", "config.toml"), "utf-8");
+    const names = [];
+    const re = /^\s*model(?:_id)?\s*=\s*"([^"]+)"/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const name = sanitizeModelName(m[1]);
+      if (name && !names.includes(name)) names.push(name);
+    }
+    return names;
+  } catch {
+    return [];
+  }
+}
+var codex = {
+  id: "codex",
+  label: "Codex CLI",
+  // Suggested; codex accepts any model its config knows via -m.
+  // probeCodexModels adds whatever ~/.codex/config.toml declares (incl.
+  // custom/proxy models), merged ahead of these aliases.
+  models: ["gpt-5-codex", "gpt-5", "o3"],
+  probeModels: async () => probeCodexModels(),
+  // UNVERIFIED resume (see ai-spawn HANDOFF.md): `codex exec resume <id>`
+  // is a different subcommand from `codex exec`, and its flag set doesn't
+  // include `--sandbox` — the closest equivalent for "don't block on an
+  // approval prompt" is `--dangerously-bypass-approvals-and-sandbox`,
+  // which is a stronger bypass than the workspace-write sandbox used on
+  // a fresh run. That's consistent with claude's own bypassPermissions
+  // above (this system already trusts the agent fully once it's running),
+  // but never exercised end-to-end because of an account rate limit
+  // during development — verify before relying on it.
+  buildInvocation: (prompt, resumeId, model) => {
+    const m = model ? ["-m", model] : [];
+    return {
+      args: resumeId ? ["exec", "resume", resumeId, "-", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", ...m] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m],
       stdin: prompt
-    }),
-    createParser: createCodexParser
+    };
   },
-  {
-    id: "joycode",
-    label: "JoyCode",
-    // Verified live (DESIGN.md §4.3): the prompt goes on argv, and on
-    // resume the flags MUST come before the `resume` subcommand —
-    // `joycode exec --json <flags> resume <thread_id> "<prompt>"`.
-    // Putting flags after `resume` is a usage error (unlike codex's
-    // `exec resume <id> -` word order). stdin feeding is unverified, so
-    // fresh runs also pass the prompt via argv for consistency.
-    buildInvocation: (prompt, resumeId) => ({
-      args: resumeId ? ["exec", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", "resume", resumeId, prompt] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", prompt]
-    }),
-    createParser: createCodexParser
+  createParser: createCodexParser
+};
+
+// src/adapters/joycode.ts
+async function probeJoycodeModels(bin) {
+  const out = await captureCommand(bin, ["models"], 5e3);
+  if (out === null) return [];
+  const names = [];
+  const re = /-m\s+"([^"]+)"/g;
+  let m;
+  while ((m = re.exec(out)) !== null) {
+    const name = m[1];
+    if (name.includes("<") || name.includes(">")) continue;
+    if (!names.includes(name)) names.push(name);
   }
-];
+  return names;
+}
+var joycode = {
+  id: "joycode",
+  label: "JoyCode",
+  // Fallback only — `probeModels` below replaces this at startup with the
+  // real list scraped from `joycode models` (the names carry non-guessable
+  // suffixes like `-hq` and spaces, so a static list would drift).
+  models: [],
+  probeModels: probeJoycodeModels,
+  // Verified live (DESIGN.md §4.3): the prompt goes on argv, and on
+  // resume the flags MUST come before the `resume` subcommand —
+  // `joycode exec --json <flags> resume <thread_id> "<prompt>"`.
+  // Putting flags after `resume` is a usage error (unlike codex's
+  // `exec resume <id> -` word order). stdin feeding is unverified, so
+  // fresh runs also pass the prompt via argv for consistency.
+  buildInvocation: (prompt, resumeId, model) => {
+    const m = model ? ["-m", model] : [];
+    return {
+      args: resumeId ? ["exec", "--json", "--skip-git-repo-check", "--dangerously-bypass-approvals-and-sandbox", ...m, "resume", resumeId, prompt] : ["exec", "--json", "--skip-git-repo-check", "--sandbox", "workspace-write", ...m, prompt]
+    };
+  },
+  createParser: createCodexParser
+};
+
+// src/adapters/index.ts
+var REGISTRY = [claude, codex, joycode];
 function detectAgents() {
   return REGISTRY.flatMap((def) => {
     const bin = resolveBin(def.id);
@@ -197,89 +323,372 @@ function getAgent(id) {
   return detectAgents().find((a) => a.id === id) ?? null;
 }
 
+// src/store.ts
+import {
+  appendFileSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync3,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
+var STATE_DIR = process.env.AGENTLINK_STATE_DIR || join4(homedir4(), ".agentlink");
+var RUNS_DIR = join4(STATE_DIR, "runs");
+var CONVS_FILE = join4(STATE_DIR, "conversations.json");
+var MAX_RUN_BYTES = 512 * 1024;
+var MAX_RUNS_PER_CONVERSATION = 100;
+function isValidConversationId(id) {
+  return typeof id === "string" && /^[A-Za-z0-9_-]{1,64}$/.test(id);
+}
+function ensureDirs() {
+  mkdirSync(RUNS_DIR, { recursive: true });
+}
+function loadConversations() {
+  try {
+    const parsed = JSON.parse(readFileSync3(CONVS_FILE, "utf-8"));
+    return Array.isArray(parsed) ? parsed.filter((c) => isValidConversationId(c?.id)) : [];
+  } catch {
+    return [];
+  }
+}
+function saveConversations(convs) {
+  ensureDirs();
+  const tmp = CONVS_FILE + ".tmp";
+  writeFileSync(tmp, JSON.stringify(convs, null, 1));
+  renameSync(tmp, CONVS_FILE);
+}
+function listConversations() {
+  return loadConversations().sort((a, b) => b.lastActiveAt - a.lastActiveAt);
+}
+function putConversation(patch) {
+  if (!isValidConversationId(patch?.id)) return { error: "conversation.id is missing or malformed" };
+  const strOrUndef = (v) => typeof v === "string" ? v : void 0;
+  const numOrUndef = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  const convs = loadConversations();
+  const existing = convs.find((c) => c.id === patch.id);
+  const merged = {
+    id: patch.id,
+    agent: strOrUndef(patch.agent) ?? existing?.agent ?? "",
+    dir: strOrUndef(patch.dir) ?? existing?.dir ?? "",
+    title: strOrUndef(patch.title) ?? existing?.title ?? "",
+    createdAt: numOrUndef(patch.createdAt) ?? existing?.createdAt ?? 0,
+    lastActiveAt: numOrUndef(patch.lastActiveAt) ?? existing?.lastActiveAt ?? 0
+  };
+  const model = patch.model === "" ? void 0 : strOrUndef(patch.model) ?? existing?.model;
+  if (model !== void 0) merged.model = model;
+  const sessionId = patch.sessionId === "" ? void 0 : strOrUndef(patch.sessionId) ?? existing?.sessionId;
+  if (sessionId !== void 0) merged.sessionId = sessionId;
+  if (!merged.agent || !merged.dir || !merged.title || !merged.createdAt || !merged.lastActiveAt) {
+    return { error: "creating a conversation requires agent, dir, title, createdAt and lastActiveAt" };
+  }
+  const next = existing ? convs.map((c) => c.id === merged.id ? merged : c) : [...convs, merged];
+  saveConversations(next);
+  return { conversation: merged };
+}
+function deleteConversation(id) {
+  if (!isValidConversationId(id)) return;
+  saveConversations(loadConversations().filter((c) => c.id !== id));
+  rmSync(join4(RUNS_DIR, id), { recursive: true, force: true });
+}
+function touchConversation(id, patch) {
+  const convs = loadConversations();
+  const conv = convs.find((c) => c.id === id);
+  if (!conv) return;
+  if (patch.lastActiveAt) conv.lastActiveAt = patch.lastActiveAt;
+  if (patch.sessionId) conv.sessionId = patch.sessionId;
+  saveConversations(convs);
+}
+var openRuns = /* @__PURE__ */ new Set();
+function recordRun(conversationId, meta) {
+  if (!isValidConversationId(conversationId)) return null;
+  const dir = join4(RUNS_DIR, conversationId);
+  const startedAt = Date.now();
+  const file = join4(dir, `${startedAt}-${meta.runId}.jsonl`);
+  try {
+    mkdirSync(dir, { recursive: true });
+    const files = readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).sort();
+    for (const old of files.slice(0, Math.max(0, files.length - (MAX_RUNS_PER_CONVERSATION - 1)))) {
+      rmSync(join4(dir, old), { force: true });
+    }
+    appendFileSync(file, JSON.stringify({ kind: "meta", startedAt, ...meta }) + "\n");
+  } catch {
+    return null;
+  }
+  openRuns.add(meta.runId);
+  touchConversation(conversationId, { lastActiveAt: startedAt });
+  let bytes = 0;
+  let truncated = false;
+  const append = (line) => {
+    try {
+      appendFileSync(file, JSON.stringify(line) + "\n");
+    } catch {
+    }
+  };
+  return {
+    event(e) {
+      if (e.type === "session") touchConversation(conversationId, { sessionId: e.id });
+      if (truncated) return;
+      const line = JSON.stringify({ kind: "event", event: e }) + "\n";
+      bytes += line.length;
+      if (bytes > MAX_RUN_BYTES) {
+        truncated = true;
+        append({ kind: "truncated" });
+        return;
+      }
+      try {
+        appendFileSync(file, line);
+      } catch {
+      }
+    },
+    done(code, error) {
+      openRuns.delete(meta.runId);
+      append({ kind: "done", code, ...error !== void 0 ? { error } : {} });
+      touchConversation(conversationId, { lastActiveAt: Date.now() });
+    }
+  };
+}
+function history(conversationId) {
+  if (!isValidConversationId(conversationId)) return [];
+  const dir = join4(RUNS_DIR, conversationId);
+  if (!existsSync2(dir)) return [];
+  const runs = [];
+  for (const name of readdirSync2(dir).filter((f) => f.endsWith(".jsonl")).sort()) {
+    let run = null;
+    let text;
+    try {
+      text = readFileSync3(join4(dir, name), "utf-8");
+    } catch {
+      continue;
+    }
+    for (const raw of text.split("\n")) {
+      if (!raw.trim()) continue;
+      let line;
+      try {
+        line = JSON.parse(raw);
+      } catch {
+        continue;
+      }
+      if (line.kind === "meta") {
+        run = {
+          runId: line.runId,
+          agent: line.agent,
+          prompt: line.prompt,
+          ...line.cwd !== void 0 ? { cwd: line.cwd } : {},
+          ...line.model !== void 0 ? { model: line.model } : {},
+          startedAt: line.startedAt,
+          status: "disconnected",
+          // upgraded below by done / openRuns
+          truncated: false,
+          events: []
+        };
+      } else if (run && line.kind === "event") {
+        if (line.event.type === "session") run.sessionId = line.event.id;
+        run.events.push(line.event);
+      } else if (run && line.kind === "truncated") {
+        run.truncated = true;
+      } else if (run && line.kind === "done") {
+        run.status = "done";
+        run.code = line.code;
+        if (line.error !== void 0) run.error = line.error;
+      }
+    }
+    if (!run) continue;
+    if (run.status !== "done" && openRuns.has(run.runId)) run.status = "running";
+    if (run.status === "disconnected") run.error = "daemon disconnected";
+    runs.push(run);
+  }
+  return runs;
+}
+
+// src/tunnel.ts
+import { spawn as spawn2 } from "node:child_process";
+import { connect } from "node:net";
+import { platform as platform2 } from "node:os";
+function portInUse(port) {
+  return new Promise((done) => {
+    const sock = connect({ port, host: "127.0.0.1" });
+    sock.once("connect", () => {
+      sock.destroy();
+      done(true);
+    });
+    sock.once("error", () => done(false));
+    sock.setTimeout(1500, () => {
+      sock.destroy();
+      done(false);
+    });
+  });
+}
+function waitForOutput(child, re, timeoutMs, what) {
+  return new Promise((resolve2, reject) => {
+    let out = "";
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      child.stdout?.removeListener("data", onData);
+      child.stderr?.removeListener("data", onData);
+      child.stdout?.resume();
+      child.stderr?.resume();
+      fn();
+    };
+    const timer = setTimeout(
+      () => settle(() => reject(new Error(`${what} did not become ready within ${timeoutMs / 1e3}s:
+${out.slice(-2e3)}`))),
+      timeoutMs
+    );
+    const onData = (chunk) => {
+      out += chunk.toString("utf-8");
+      const m = out.match(re);
+      if (m) settle(() => resolve2(m[0]));
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => settle(() => reject(new Error(`${what} failed to start: ${err.message}`))));
+    child.on("close", (code) => settle(() => reject(new Error(`${what} exited (code ${code}) before becoming ready:
+${out.slice(-2e3)}`))));
+  });
+}
+async function startTunnel(hubPort) {
+  const children = [];
+  const stop = () => {
+    for (const c of children) c.kill();
+  };
+  const watchChild = (child, what) => {
+    child.on("close", (code) => {
+      console.error(`[daemon] ${what} exited (code ${code}) \u2014 shutting down (--tunnel mode has no partial recovery).`);
+      stop();
+      process.exit(1);
+    });
+  };
+  if (await portInUse(hubPort)) {
+    console.log(`[daemon] port ${hubPort} is already in use \u2014 assuming an agentlink-hub is listening there.`);
+  } else {
+    console.log(`[daemon] starting local hub on port ${hubPort} (npx agentlink-hub)...`);
+    const hub = spawn2("npx", ["-y", "agentlink-hub", "--port", String(hubPort)], {
+      env: { ...spawnEnv(), PORT: String(hubPort) },
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: platform2() === "win32"
+      // npx is npx.cmd on Windows
+    });
+    children.push(hub);
+    await waitForOutput(hub, /listening on/, 12e4, "agentlink-hub");
+    watchChild(hub, "local hub");
+  }
+  const cloudflared = resolveBin("cloudflared");
+  if (!cloudflared) {
+    console.error(`[daemon] --tunnel needs the cloudflared binary, which was not found on PATH.`);
+    console.error(`[daemon] install it first:  macOS: brew install cloudflared`);
+    console.error(`[daemon]                    other: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/`);
+    stop();
+    process.exit(1);
+  }
+  console.log(`[daemon] opening Cloudflare quick tunnel to http://localhost:${hubPort} ...`);
+  const cf = spawn2(cloudflared, ["tunnel", "--url", `http://localhost:${hubPort}`], {
+    env: spawnEnv(),
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  children.push(cf);
+  const publicBase = await waitForOutput(cf, /https:\/\/[a-z0-9-]+\.trycloudflare\.com/, 6e4, "cloudflared");
+  watchChild(cf, "cloudflared tunnel");
+  return { publicBase, stop };
+}
+
 // src/main.ts
 var PROTOCOL_VERSION = 1;
-function usage() {
+function usage(error) {
+  if (error) console.error(`[daemon] ${error}`);
   console.error(`usage: agentlink-daemon [--hub <ws(s)://host[:port]>] [--token <token>] [--dir <path>]...`);
+  console.error(`       agentlink-daemon --tunnel [--port <local hub port>] [--token <token>] [--dir <path>]...`);
+  console.error(`       (--tunnel = start a local hub + a free Cloudflare quick tunnel, all in one command)`);
   process.exit(1);
 }
 function parseArgs(argv) {
-  let token;
-  let hub = "ws://localhost:8080";
-  const dirs = [];
-  for (let i = 0; i < argv.length; i++) {
-    const next = () => argv[++i] ?? usage();
-    if (argv[i] === "--token") token = next();
-    else if (argv[i] === "--hub") hub = next();
-    else if (argv[i] === "--dir") dirs.push(resolve(next()));
-    else usage();
+  let values;
+  try {
+    ({ values } = nodeParseArgs({
+      args: argv,
+      options: {
+        hub: { type: "string" },
+        token: { type: "string" },
+        dir: { type: "string", multiple: true },
+        tunnel: { type: "boolean" },
+        port: { type: "string" }
+      },
+      strict: true,
+      allowPositionals: false
+    }));
+  } catch (err) {
+    usage(err instanceof Error ? err.message : String(err));
   }
+  if (values.tunnel && values.hub) usage("--tunnel starts its own local hub; it cannot be combined with --hub");
+  if (values.port && !values.tunnel) usage("--port only applies to --tunnel mode (it is the LOCAL hub's port)");
+  const port = values.port === void 0 ? 8080 : Number(values.port);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) usage(`invalid --port "${values.port}" (expected 1-65535)`);
+  const dirs = (values.dir ?? []).map((d) => resolve(d));
   if (dirs.length === 0) dirs.push(process.cwd());
-  return { token: token ?? randomUUID(), hub, dirs };
+  return {
+    token: values.token ?? randomUUID(),
+    hub: values.hub ?? (values.tunnel ? `ws://localhost:${port}` : "ws://localhost:8080"),
+    dirs,
+    tunnel: values.tunnel ?? false,
+    port
+  };
 }
-var { token: TOKEN, hub: HUB, dirs: DIRS } = parseArgs(process.argv.slice(2));
-var REAL_DIRS = DIRS.map((d) => {
-  try {
-    return realpathSync(d);
-  } catch {
-    return d;
-  }
-});
-function resolveInsideRoots(p) {
+var { token: TOKEN, hub: HUB, dirs: DIRS, tunnel: TUNNEL, port: TUNNEL_PORT } = parseArgs(process.argv.slice(2));
+function resolveDir(p) {
   let real;
   try {
     real = realpathSync(resolve(p));
-  } catch {
-    return null;
+  } catch (err) {
+    return {
+      error: err.code === "EACCES" ? `permission denied for "${p}"` : `"${p}" does not exist`
+    };
   }
-  return REAL_DIRS.some((root) => real === root || real.startsWith(root + sep)) ? real : null;
+  try {
+    if (!statSync(real).isDirectory()) return { error: `"${p}" is not a directory` };
+  } catch (err) {
+    return {
+      error: err.code === "EACCES" ? `permission denied for "${p}"` : `cannot access "${p}"`
+    };
+  }
+  return { real };
 }
 function ownVersion() {
   try {
-    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
+    return JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf-8")).version;
   } catch {
     return "0.0.0";
   }
 }
 function webLink(hub, token) {
+  if (PUBLIC_BASE) return `${PUBLIC_BASE}/?token=${encodeURIComponent(token)}`;
   const u = new URL(hub);
   u.protocol = u.protocol === "wss:" ? "https:" : "http:";
   u.pathname = "/";
   u.search = `?token=${encodeURIComponent(token)}`;
   return u.toString();
 }
-function probeVersion(bin) {
-  return new Promise((done) => {
-    let out = "";
-    let child;
-    try {
-      child = spawn(bin, ["--version"], { env: spawnEnv() });
-    } catch {
-      return done(void 0);
-    }
-    const timer = setTimeout(() => {
-      child.kill();
-      done(void 0);
-    }, 3e3);
-    child.stdout?.on("data", (chunk) => out += chunk.toString("utf-8"));
-    child.on("error", () => {
-      clearTimeout(timer);
-      done(void 0);
-    });
-    child.on("close", (code) => {
-      clearTimeout(timer);
-      const first = out.trim().split("\n")[0]?.trim();
-      done(code === 0 && first ? first : void 0);
-    });
-  });
+async function probeVersion(bin) {
+  const out = await captureCommand(bin, ["--version"], 3e3);
+  const first = out?.trim().split("\n")[0]?.trim();
+  return first || void 0;
 }
 async function probeAgents() {
   return Promise.all(
     REGISTRY.map(async (def) => {
       const bin = getAgent(def.id)?.bin;
-      if (!bin) return { id: def.id, label: def.label, detected: false };
-      const version = await probeVersion(bin);
-      return { id: def.id, label: def.label, detected: true, bin, ...version ? { version } : {} };
+      if (!bin) return { id: def.id, label: def.label, detected: false, models: def.models };
+      const [version, probed] = await Promise.all([
+        probeVersion(bin),
+        def.probeModels ? def.probeModels(bin) : Promise.resolve([])
+      ]);
+      const models = [.../* @__PURE__ */ new Set([...probed, ...def.models])];
+      return { id: def.id, label: def.label, detected: true, bin, models, ...version ? { version } : {} };
     })
   );
 }
@@ -287,7 +696,7 @@ var running = /* @__PURE__ */ new Map();
 function send(ws2, obj) {
   if (ws2.readyState === WebSocket.OPEN) ws2.send(JSON.stringify(obj));
 }
-function handleRun(ws2, { requestId, agent: agentId, prompt, sessionId, cwd }) {
+function handleRun(ws2, { requestId, agent: agentId, prompt, sessionId, cwd, model, conversationId }) {
   const fail = (error) => {
     console.log(`[daemon] requestId=${requestId} rejected: ${error}`);
     send(ws2, { type: "done", requestId, code: null, error });
@@ -297,26 +706,27 @@ function handleRun(ws2, { requestId, agent: agentId, prompt, sessionId, cwd }) {
   if (typeof prompt !== "string") return fail(`malformed run message: prompt is not a string`);
   let runCwd = DIRS[0];
   if (cwd !== void 0) {
-    const real = resolveInsideRoots(cwd);
-    if (real === null) {
-      return fail(`cwd "${cwd}" is not inside this daemon's registered dirs (or does not exist)`);
-    }
-    try {
-      if (!statSync(real).isDirectory()) return fail(`cwd "${cwd}" is not a directory`);
-    } catch {
-      return fail(`cwd "${cwd}" is not a directory`);
-    }
+    const { real, error } = resolveDir(cwd);
+    if (!real) return fail(`cwd rejected: ${error}`);
     runCwd = real;
   }
-  const invocation = adapter.buildInvocation(prompt, sessionId);
+  const invocation = adapter.buildInvocation(prompt, sessionId, typeof model === "string" && model ? model : void 0);
   console.log(`[daemon] requestId=${requestId} spawning ${adapter.bin} ${invocation.args.join(" ")} (cwd=${runCwd})`);
-  const child = spawn(adapter.bin, invocation.args, { cwd: runCwd, env: spawnEnv() });
+  const recorder = recordRun(conversationId, {
+    runId: requestId,
+    agent: agentId,
+    prompt,
+    ...cwd !== void 0 ? { cwd } : {},
+    ...typeof model === "string" && model ? { model } : {}
+  });
+  const child = spawn3(adapter.bin, invocation.args, { cwd: runCwd, env: spawnEnv() });
   running.set(requestId, child);
   child.stdin.on("error", () => {
   });
   if (invocation.stdin !== void 0) child.stdin.write(invocation.stdin);
   child.stdin.end();
   const parseLine = adapter.createParser((evt) => {
+    recorder?.event(evt);
     send(ws2, { type: "event", requestId, event: evt });
   });
   let buffer = "";
@@ -340,31 +750,62 @@ function handleRun(ws2, { requestId, agent: agentId, prompt, sessionId, cwd }) {
     };
     if (code !== 0 && stderrTail.trim()) done.error = stderrTail.trim();
     console.log(`[daemon] requestId=${requestId} closed code=${code}${done.error ? ` error=${done.error}` : ""}`);
+    recorder?.done(code, done.error);
     send(ws2, done);
   });
   child.on("error", (err) => {
     running.delete(requestId);
     console.log(`[daemon] requestId=${requestId} spawn error: ${err.message}`);
+    recorder?.done(null, err.message);
     send(ws2, { type: "done", requestId, code: null, error: err.message });
   });
 }
 function handleListdir(ws2, { requestId, path }) {
-  const reply = (dirs, error) => {
-    if (error) console.log(`[daemon] listdir requestId=${requestId} rejected: ${error}`);
-    send(ws2, { type: "listdir_result", requestId, path, dirs, ...error !== void 0 ? { error } : {} });
+  const reply = (dirs, error2) => {
+    if (error2) console.log(`[daemon] listdir requestId=${requestId} rejected: ${error2}`);
+    send(ws2, { type: "listdir_result", requestId, path, dirs, ...error2 !== void 0 ? { error: error2 } : {} });
   };
   if (typeof path !== "string") return reply([], "malformed listdir: path is not a string");
-  const real = resolveInsideRoots(path);
-  if (real === null) {
-    return reply([], `path "${path}" is not inside this daemon's registered dirs (or does not exist)`);
-  }
+  const { real, error } = resolveDir(path);
+  if (!real) return reply([], error);
   try {
-    const dirs = readdirSync2(real, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join2(real, e.name)).sort();
+    const dirs = readdirSync3(real, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join5(real, e.name)).sort();
     reply(dirs);
   } catch (err) {
-    reply([], `cannot list "${path}": ${err instanceof Error ? err.message : String(err)}`);
+    reply(
+      [],
+      err.code === "EACCES" ? `permission denied reading "${path}"` : `cannot list "${path}": ${err instanceof Error ? err.message : String(err)}`
+    );
   }
 }
+function handleConvList(ws2, requestId) {
+  send(ws2, { type: "conv_list_result", requestId, conversations: listConversations() });
+}
+function handleConvPut(ws2, requestId, conversation) {
+  if (typeof conversation !== "object" || conversation === null) {
+    return send(ws2, { type: "conv_put_result", requestId, error: "malformed conv_put: conversation is not an object" });
+  }
+  const { conversation: merged, error } = putConversation(conversation);
+  send(ws2, { type: "conv_put_result", requestId, ...merged ? { conversation: merged } : {}, ...error ? { error } : {} });
+}
+function handleConvDelete(ws2, requestId, id) {
+  if (typeof id === "string") deleteConversation(id);
+  send(ws2, { type: "conv_delete_result", requestId });
+}
+function handleHistory(ws2, requestId, conversationId) {
+  send(ws2, { type: "history_result", requestId, runs: history(conversationId) });
+}
+var PUBLIC_BASE = null;
+var stopTunnel = null;
+if (TUNNEL) {
+  const t = await startTunnel(TUNNEL_PORT);
+  PUBLIC_BASE = t.publicBase;
+  stopTunnel = t.stop;
+  console.log(`[daemon] tunnel ready: ${PUBLIC_BASE}`);
+}
+process.on("exit", () => stopTunnel?.());
+process.on("SIGINT", () => process.exit(130));
+process.on("SIGTERM", () => process.exit(143));
 var agents = await probeAgents();
 var detected = agents.filter((a) => a.detected);
 console.log(`[daemon] detected agents: ${detected.length ? detected.map((a) => a.id).join(", ") : "(none)"}`);
@@ -409,6 +850,14 @@ ws.on("message", (raw) => {
     handleRun(ws, msg);
   } else if (msg.type === "listdir" && typeof msg.requestId === "string") {
     handleListdir(ws, msg);
+  } else if (msg.type === "conv_list" && typeof msg.requestId === "string") {
+    handleConvList(ws, msg.requestId);
+  } else if (msg.type === "conv_put" && typeof msg.requestId === "string") {
+    handleConvPut(ws, msg.requestId, msg.conversation);
+  } else if (msg.type === "conv_delete" && typeof msg.requestId === "string") {
+    handleConvDelete(ws, msg.requestId, msg.id);
+  } else if (msg.type === "history" && typeof msg.requestId === "string") {
+    handleHistory(ws, msg.requestId, msg.conversationId);
   } else {
     console.log(`[daemon] ignoring message with unknown shape: ${raw}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlink-daemon",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Control your coding agents from anywhere — the AgentLink daemon.",
   "license": "MIT",
   "repository": {