agentlink-daemon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 agentlink contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,18 @@
+# agentlink-daemon
+
+The AgentLink **daemon** — run it on the machine your coding agents live on. It dials out to your [agentlink-hub](https://www.npmjs.com/package/agentlink-hub), probes which agent CLIs are installed (Claude Code / Codex CLI / JoyCode), and executes the tasks you send from the web page.
+
+```bash
+npx agentlink-daemon --hub wss://your-host:8080
+#   → prints: open https://your-host:8080/?token=<uuid>
+```
+
+Options:
+
+- `--hub <ws(s)://host[:port]>` — the hub to connect to.
+- `--dir <path>` — a workdir root (repeatable; defaults to the current directory). Runs may use any directory inside a root; the web picker browses them as a tree. Tip: `cd ~/Projects && npx agentlink-daemon --hub …` makes every project selectable.
+- `--token <token>` — pin the token instead of generating a fresh one per start.
+
+The connection is **outbound** — no port forwarding, no VPN, works behind NAT. The printed token is a remote-code-execution credential for this machine: use `wss://` (TLS) for anything public, and restart the daemon to revoke a leaked token.
+
+Full documentation: [github.com/baichen99/agentlink](https://github.com/baichen99/agentlink) · MIT

package/dist/main.js

@@ -0,0 +1,429 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { readFileSync, readdirSync as readdirSync2, realpathSync, statSync } from "node:fs";
+import { hostname } from "node:os";
+import { join as join2, resolve, sep } from "node:path";
+import { WebSocket } from "ws";
+
+// src/agents.ts
+import { existsSync, readdirSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join, delimiter } 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");
+  for (const root of [join(home, ".nvm", "versions", "node")]) {
+    try {
+      for (const entry of readdirSync(root, { withFileTypes: true })) {
+        if (entry.isDirectory()) dirs.push(join(root, entry.name, "bin"));
+      }
+    } catch {
+    }
+  }
+  return dirs;
+}
+var PATH_DIRS = [.../* @__PURE__ */ new Set([...(process.env.PATH ?? "").split(delimiter), ...extraDirs(homedir())])];
+function resolveBin(name) {
+  const ext = platform() === "win32" ? ".exe" : "";
+  for (const dir of PATH_DIRS) {
+    const full = join(dir, name + ext);
+    if (existsSync(full)) return full;
+  }
+  return null;
+}
+function spawnEnv() {
+  return { ...process.env, PATH: PATH_DIRS.join(delimiter) };
+}
+function parseJsonLine(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function resultText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) return content.map((c) => c?.type === "text" ? c.text : JSON.stringify(c)).join("\n");
+  return JSON.stringify(content);
+}
+function createClaudeParser(emit) {
+  const streamed = /* @__PURE__ */ new Set();
+  let messageId = null;
+  let lastSessionId = null;
+  return (line) => {
+    const obj = parseJsonLine(line);
+    if (!obj) return;
+    if (obj.type === "system" && typeof obj.session_id === "string") {
+      if (obj.session_id !== lastSessionId) {
+        lastSessionId = obj.session_id;
+        emit({ type: "session", id: obj.session_id });
+      }
+      return;
+    }
+    if (obj.type === "stream_event") {
+      const ev = obj.event;
+      if (ev?.type === "message_start") messageId = ev.message?.id ?? null;
+      if (ev?.type === "content_block_delta" && ev.delta?.type === "text_delta") {
+        if (messageId) streamed.add(messageId);
+        emit({ type: "text", text: ev.delta.text });
+      }
+      return;
+    }
+    if (obj.type === "assistant" && obj.message?.content) {
+      const already = obj.message.id && streamed.has(obj.message.id);
+      for (const block of obj.message.content) {
+        if (block.type === "tool_use") {
+          emit({ type: "tool_use", id: block.id, name: block.name, input: block.input ?? null });
+        } else if (!already && block.type === "text" && block.text) {
+          emit({ type: "text", text: block.text });
+        }
+      }
+      return;
+    }
+    if (obj.type === "user" && obj.message?.content) {
+      for (const block of obj.message.content) {
+        if (block.type === "tool_result") {
+          emit({
+            type: "tool_result",
+            toolUseId: block.tool_use_id,
+            content: resultText(block.content),
+            isError: Boolean(block.is_error)
+          });
+        }
+      }
+    }
+  };
+}
+function createCodexParser(emit) {
+  const seen = /* @__PURE__ */ new Set();
+  return (line) => {
+    const obj = parseJsonLine(line);
+    if (!obj) return;
+    const item = obj.item;
+    if (obj.type === "thread.started" && typeof obj.thread_id === "string") {
+      emit({ type: "session", id: obj.thread_id });
+      return;
+    }
+    if (item?.type === "command_execution" && typeof item.id === "string") {
+      if (!seen.has(item.id)) {
+        seen.add(item.id);
+        emit({ type: "tool_use", id: item.id, name: "Bash", input: { command: item.command ?? "" } });
+      }
+      if (obj.type === "item.completed") {
+        emit({
+          type: "tool_result",
+          toolUseId: item.id,
+          content: resultText(item.aggregated_output ?? ""),
+          isError: item.exit_code ? item.exit_code !== 0 : item.status === "failed"
+        });
+      }
+      return;
+    }
+    if (obj.type === "item.completed" && item?.type === "agent_message" && item.text) {
+      emit({ type: "text", text: item.text });
+      return;
+    }
+    const errMessage = obj.message ?? obj.error?.message ?? item?.message;
+    if ((obj.type === "error" || obj.type === "turn.failed" || item?.type === "error") && typeof errMessage === "string") {
+      emit({ type: "error", message: errMessage });
+    }
+  };
+}
+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"],
+      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
+  }
+];
+function detectAgents() {
+  return REGISTRY.flatMap((def) => {
+    const bin = resolveBin(def.id);
+    return bin ? [{ ...def, bin }] : [];
+  });
+}
+function getAgent(id) {
+  return detectAgents().find((a) => a.id === id) ?? null;
+}
+
+// src/main.ts
+var PROTOCOL_VERSION = 1;
+function usage() {
+  console.error(`usage: agentlink-daemon [--hub <ws(s)://host[:port]>] [--token <token>] [--dir <path>]...`);
+  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();
+  }
+  if (dirs.length === 0) dirs.push(process.cwd());
+  return { token: token ?? randomUUID(), hub, dirs };
+}
+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) {
+  let real;
+  try {
+    real = realpathSync(resolve(p));
+  } catch {
+    return null;
+  }
+  return REAL_DIRS.some((root) => real === root || real.startsWith(root + sep)) ? real : null;
+}
+function ownVersion() {
+  try {
+    return JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function webLink(hub, 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 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 } : {} };
+    })
+  );
+}
+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 }) {
+  const fail = (error) => {
+    console.log(`[daemon] requestId=${requestId} rejected: ${error}`);
+    send(ws2, { type: "done", requestId, code: null, error });
+  };
+  const adapter = getAgent(agentId);
+  if (!adapter) return fail(`agent "${agentId}" not found`);
+  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`);
+    }
+    runCwd = real;
+  }
+  const invocation = adapter.buildInvocation(prompt, sessionId);
+  console.log(`[daemon] requestId=${requestId} spawning ${adapter.bin} ${invocation.args.join(" ")} (cwd=${runCwd})`);
+  const child = spawn(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) => {
+    send(ws2, { type: "event", requestId, event: evt });
+  });
+  let buffer = "";
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk.toString("utf-8");
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) parseLine(line);
+  });
+  let stderrTail = "";
+  child.stderr.on("data", (chunk) => {
+    stderrTail = (stderrTail + chunk.toString("utf-8")).slice(-4e3);
+  });
+  child.on("close", (code) => {
+    if (buffer) parseLine(buffer);
+    running.delete(requestId);
+    const done = {
+      type: "done",
+      requestId,
+      code
+    };
+    if (code !== 0 && stderrTail.trim()) done.error = stderrTail.trim();
+    console.log(`[daemon] requestId=${requestId} closed code=${code}${done.error ? ` error=${done.error}` : ""}`);
+    send(ws2, done);
+  });
+  child.on("error", (err) => {
+    running.delete(requestId);
+    console.log(`[daemon] requestId=${requestId} spawn error: ${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 } : {} });
+  };
+  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)`);
+  }
+  try {
+    const dirs = readdirSync2(real, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join2(real, e.name)).sort();
+    reply(dirs);
+  } catch (err) {
+    reply([], `cannot list "${path}": ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+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)"}`);
+var url = `${HUB}/daemon?token=${encodeURIComponent(TOKEN)}&v=${PROTOCOL_VERSION}`;
+console.log(`[daemon] connecting to ${url} ...`);
+var ws = new WebSocket(url);
+var registered = false;
+var helloTimer = setTimeout(() => {
+  console.error(`[daemon] no hello from hub within 5s \u2014 the hub at ${HUB} is unreachable or too old for this daemon. Check --hub, or upgrade the hub (npx agentlink-hub@latest).`);
+  process.exit(1);
+}, 5e3);
+ws.on("message", (raw) => {
+  let msg;
+  try {
+    msg = JSON.parse(raw.toString());
+  } catch {
+    console.log(`[daemon] ignoring malformed message: ${raw}`);
+    return;
+  }
+  if (!registered) {
+    if (msg.type === "error" && msg.error === "unsupported_version") {
+      clearTimeout(helloTimer);
+      const supported = Array.isArray(msg.supported) ? msg.supported.join(", ") : "?";
+      console.error(`[daemon] the hub rejected this connection: it only speaks protocol version(s) ${supported}, this daemon offers v${PROTOCOL_VERSION}. Upgrade the older side (npx agentlink-daemon@latest / npx agentlink-hub@latest).`);
+      process.exit(1);
+    }
+    if (msg.type === "hello") {
+      clearTimeout(helloTimer);
+      registered = true;
+      console.log(`[daemon] hub says hello (protocol v${msg.v}, hub ${msg.hubVersion ?? "?"})`);
+      send(ws, { type: "register", hostname: hostname(), daemonVersion: ownVersion(), dirs: DIRS, agents });
+      console.log(`[daemon] registered. Waiting for work pushed from the hub...`);
+      console.log(``);
+      console.log(`  Open this link to control this machine from anywhere:`);
+      console.log(``);
+      console.log(`    ${webLink(HUB, TOKEN)}`);
+      console.log(``);
+    }
+    return;
+  }
+  if (msg.type === "run" && typeof msg.requestId === "string") {
+    handleRun(ws, msg);
+  } else if (msg.type === "listdir" && typeof msg.requestId === "string") {
+    handleListdir(ws, msg);
+  } else {
+    console.log(`[daemon] ignoring message with unknown shape: ${raw}`);
+  }
+});
+ws.on("error", (err) => {
+  console.error(`[daemon] socket error: ${err.message}`);
+});
+ws.on("close", (code, reason) => {
+  clearTimeout(helloTimer);
+  for (const [requestId, child] of running) {
+    console.log(`[daemon] killing in-flight requestId=${requestId} (hub connection closed)`);
+    child.kill();
+  }
+  running.clear();
+  const detail = code ? ` (code ${code}${reason?.length ? `, ${reason}` : ""})` : "";
+  console.error(`[daemon] connection to hub closed${detail} \u2014 v1 has no auto-reconnect, please start the daemon again.`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "agentlink-daemon",
+  "version": "0.1.0",
+  "description": "Control your coding agents from anywhere — the AgentLink daemon.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baichen99/agentlink.git",
+    "directory": "packages/daemon"
+  },
+  "homepage": "https://github.com/baichen99/agentlink#readme",
+  "bugs": "https://github.com/baichen99/agentlink/issues",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "joycode",
+    "coding-agent",
+    "remote-control",
+    "cli",
+    "self-hosted"
+  ],
+  "type": "module",
+  "bin": {
+    "agentlink": "dist/main.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "esbuild src/main.ts --bundle --platform=node --format=esm --external:ws --outfile=dist/main.js",
+    "typecheck": "tsc",
+    "test": "npm run build && node test/self-test.js",
+    "test:real": "npm run build && node test/real-run.js"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/ws": "^8.5.0",
+    "esbuild": "^0.25.0",
+    "typescript": "^5.8.0"
+  }
+}