@agtd/agent 0.1.0

package/bin/agtd-agent.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/agent.js

@@ -0,0 +1,6 @@
+import {
+  startAgent
+} from "./chunk-24ORBJSI.js";
+export {
+  startAgent
+};

package/dist/chunk-24ORBJSI.js

@@ -0,0 +1,989 @@
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { hostname, platform, homedir } from "os";
+import { resolve } from "path";
+function resolveConfigPath(cliPath) {
+  if (cliPath) return cliPath;
+  const envPath = process.env["AGENT_CONFIG"];
+  if (envPath && existsSync(envPath)) return envPath;
+  const homePath = resolve(homedir(), ".agtd", "agent.config.json");
+  if (existsSync(homePath)) return homePath;
+  const cwdPath = resolve(process.cwd(), "agent.config.json");
+  if (existsSync(cwdPath)) return cwdPath;
+  return null;
+}
+function parseConfigFile(configPath) {
+  const raw = JSON.parse(readFileSync(configPath, "utf-8"));
+  return {
+    deviceId: raw.deviceId ?? hostname(),
+    deviceName: raw.deviceName ?? `${hostname()}-${platform()}`,
+    backendUrl: raw.backendUrl ?? "http://localhost:3001",
+    apiKey: raw.apiKey ?? "",
+    projects: Array.isArray(raw.projects) ? raw.projects : [],
+    projectDirs: Array.isArray(raw.projectDirs) ? raw.projectDirs : []
+  };
+}
+function mergeCliOverrides(config, overrides) {
+  return {
+    ...config,
+    ...overrides.backend && { backendUrl: overrides.backend },
+    ...overrides.apiKey && { apiKey: overrides.apiKey },
+    ...overrides.deviceName && { deviceName: overrides.deviceName }
+  };
+}
+function loadConfig(cliPath) {
+  const configPath = resolveConfigPath(cliPath);
+  if (!configPath) {
+    throw new Error("No config file found");
+  }
+  return parseConfigFile(configPath);
+}
+
+// src/register.ts
+import { hostname as hostname2, platform as platform2 } from "os";
+async function registerDevice(config) {
+  const payload = {
+    id: config.deviceId,
+    name: config.deviceName,
+    host: hostname2(),
+    os: platform2()
+  };
+  const res = await fetch(`${config.backendUrl}/api/register-device`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    throw new Error(`Register device failed: ${res.status} ${res.statusText}`);
+  }
+  console.log(`Device registered: ${config.deviceId}`);
+}
+
+// src/syncProjects.ts
+import { execSync } from "child_process";
+import { readdirSync, statSync, existsSync as existsSync2 } from "fs";
+import { join, basename } from "path";
+function getGitRemoteUrl(projectPath) {
+  try {
+    return execSync("git remote get-url origin", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+function discoverProjectsInDir(dir) {
+  if (!existsSync2(dir)) return [];
+  try {
+    const entries = readdirSync(dir);
+    return entries.filter((entry) => {
+      if (entry.startsWith(".")) return false;
+      if (entry === "node_modules") return false;
+      const full = join(dir, entry);
+      try {
+        return statSync(full).isDirectory();
+      } catch {
+        return false;
+      }
+    }).map((entry) => ({
+      name: `${entry} (${dir})`,
+      path: join(dir, entry)
+    }));
+  } catch {
+    return [];
+  }
+}
+async function syncProjects(config) {
+  const seen = /* @__PURE__ */ new Set();
+  const allProjects = [];
+  for (const p of config.projects) {
+    if (!seen.has(p.path)) {
+      seen.add(p.path);
+      allProjects.push({
+        name: `${basename(p.path)} (${p.path})`,
+        path: p.path,
+        repoUrl: getGitRemoteUrl(p.path)
+      });
+    }
+  }
+  for (const dir of config.projectDirs) {
+    const discovered = discoverProjectsInDir(dir);
+    for (const p of discovered) {
+      if (!seen.has(p.path)) {
+        seen.add(p.path);
+        allProjects.push({
+          name: p.name,
+          path: p.path,
+          repoUrl: getGitRemoteUrl(p.path)
+        });
+      }
+    }
+  }
+  const payload = {
+    deviceId: config.deviceId,
+    projects: allProjects
+  };
+  const res = await fetch(`${config.backendUrl}/api/projects/sync`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "x-device-id": config.deviceId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    throw new Error(`Sync projects failed: ${res.status} ${res.statusText}`);
+  }
+  console.log(`Synced ${allProjects.length} project(s)`);
+}
+
+// src/wsClient.ts
+import WebSocket2 from "ws";
+
+// src/spawn.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/tmux.ts
+import { execSync as execSync2 } from "child_process";
+function sanitizeShellArg(s) {
+  return s.replace(/'/g, "'\\''");
+}
+function isTmuxAvailable() {
+  try {
+    execSync2("tmux list-sessions", {
+      encoding: "utf-8",
+      timeout: 3e3,
+      stdio: "pipe"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildCreateSessionCmd(sessionName, cwd) {
+  return `tmux new-session -d -s '${sanitizeShellArg(sessionName)}' -c '${sanitizeShellArg(cwd)}'`;
+}
+function buildSendKeysCmd(target, keys) {
+  const hex = Array.from(Buffer.from(keys)).map((b) => b.toString(16).padStart(2, "0")).join(" ");
+  return `tmux send-keys -t '${sanitizeShellArg(target)}' -H ${hex}`;
+}
+function buildCapturePaneCmd(target) {
+  return `tmux capture-pane -t '${sanitizeShellArg(target)}' -p -e -S -`;
+}
+function tmuxExec(cmd) {
+  try {
+    return execSync2(cmd, { encoding: "utf-8", timeout: 5e3 });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`tmux command failed: ${msg}`);
+  }
+}
+function tmuxSessionExists(sessionName) {
+  try {
+    execSync2(`tmux has-session -t '${sanitizeShellArg(sessionName)}'`, {
+      timeout: 3e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function capturePaneOutput(target) {
+  return tmuxExec(buildCapturePaneCmd(target));
+}
+function sendKeys(target, input) {
+  tmuxExec(buildSendKeysCmd(target, input));
+}
+function createSession(sessionName, cwd) {
+  if (!tmuxSessionExists(sessionName)) {
+    tmuxExec(buildCreateSessionCmd(sessionName, cwd));
+  }
+}
+
+// src/adapters/claude-code.ts
+function escapeForShell(str) {
+  return str.replace(/'/g, "'\\''");
+}
+var claudeCodeAdapter = {
+  type: "claude-code",
+  buildSpawnCommand(_task, cwd) {
+    const escapedCwd = escapeForShell(cwd);
+    return `cd '${escapedCwd}' && claude`;
+  },
+  hookInstallInstructions() {
+    return [
+      "To install the Claude Code hook for the agent dashboard:",
+      "",
+      "1. Edit (or create) ~/.claude/hooks.json",
+      "2. Add the following hook configuration:",
+      "",
+      "   {",
+      '     "hooks": {',
+      '       "PreToolUse": [',
+      "         {",
+      '           "type": "command",',
+      '           "command": "/path/to/packages/agent/src/hooks/claude-hook.sh PreToolUse"',
+      "         }",
+      "       ],",
+      '       "PostToolUse": [',
+      "         {",
+      '           "type": "command",',
+      '           "command": "/path/to/packages/agent/src/hooks/claude-hook.sh PostToolUse"',
+      "         }",
+      "       ],",
+      '       "Stop": [',
+      "         {",
+      '           "type": "command",',
+      '           "command": "/path/to/packages/agent/src/hooks/claude-hook.sh Stop"',
+      "         }",
+      "       ]",
+      "     }",
+      "   }",
+      "",
+      "3. Set the following environment variables:",
+      "   - AGENT_DASHBOARD_BACKEND (e.g., http://localhost:3001)",
+      "   - AGENT_DASHBOARD_DEVICE_ID",
+      "   - AGENT_DASHBOARD_API_KEY"
+    ].join("\n");
+  }
+};
+
+// src/adapters/codex.ts
+function escapeForShell2(str) {
+  return str.replace(/'/g, "'\\''");
+}
+var codexAdapter = {
+  type: "codex",
+  buildSpawnCommand(task, cwd) {
+    const escapedTask = escapeForShell2(task);
+    const escapedCwd = escapeForShell2(cwd);
+    return `cd '${escapedCwd}' && codex '${escapedTask}'`;
+  },
+  hookInstallInstructions() {
+    return [
+      "To install the Codex hook for the agent dashboard:",
+      "",
+      "1. Use the codex-hook.sh wrapper script instead of calling codex directly:",
+      "",
+      "   ./packages/agent/src/hooks/codex-hook.sh 'your task here'",
+      "",
+      "   The wrapper script will:",
+      "   - Send a working heartbeat before running codex",
+      "   - Start a background keepalive loop (every 10s)",
+      "   - Run codex with the provided task",
+      "   - Send an idle heartbeat on exit",
+      "",
+      "2. Set the following environment variables:",
+      "   - AGENT_DASHBOARD_BACKEND (e.g., http://localhost:3001)",
+      "   - AGENT_DASHBOARD_DEVICE_ID",
+      "   - AGENT_DASHBOARD_API_KEY",
+      "   - AGENT_DASHBOARD_SESSION_ID (unique session identifier)"
+    ].join("\n");
+  }
+};
+
+// src/adapters/generic.ts
+function escapeForShell3(str) {
+  return str.replace(/'/g, "'\\''");
+}
+var genericAdapter = {
+  type: "generic",
+  buildSpawnCommand(task, cwd) {
+    const escapedTask = escapeForShell3(task);
+    const escapedCwd = escapeForShell3(cwd);
+    return `cd '${escapedCwd}' && echo 'Task: ${escapedTask}'`;
+  },
+  hookInstallInstructions() {
+    return [
+      "To send heartbeats from a generic agent to the dashboard:",
+      "",
+      "1. Use the generic-hook.sh script to send manual heartbeat updates:",
+      "",
+      "   ./packages/agent/src/hooks/generic-hook.sh <session_id> <status> [task]",
+      "",
+      "   Examples:",
+      '   ./packages/agent/src/hooks/generic-hook.sh my-session working "Implementing feature X"',
+      "   ./packages/agent/src/hooks/generic-hook.sh my-session idle",
+      "   ./packages/agent/src/hooks/generic-hook.sh my-session awaiting_permission",
+      "",
+      "2. Or send heartbeats directly via curl:",
+      "",
+      "   curl -X POST $AGENT_DASHBOARD_BACKEND/api/agent/heartbeat \\",
+      '     -H "Content-Type: application/json" \\',
+      '     -H "x-api-key: $AGENT_DASHBOARD_API_KEY" \\',
+      `     -d '{"deviceId": "...", "sessionId": "...", "status": "working"}'`,
+      "",
+      "3. Set the following environment variables:",
+      "   - AGENT_DASHBOARD_BACKEND (e.g., http://localhost:3001)",
+      "   - AGENT_DASHBOARD_DEVICE_ID",
+      "   - AGENT_DASHBOARD_API_KEY"
+    ].join("\n");
+  }
+};
+
+// src/adapters/index.ts
+var adapters = {
+  "claude-code": claudeCodeAdapter,
+  "codex": codexAdapter,
+  "generic": genericAdapter
+};
+function getAdapter(agentType) {
+  return adapters[agentType] || genericAdapter;
+}
+
+// src/heartbeat.ts
+async function sendHeartbeat(config, payload) {
+  const res = await fetch(`${config.backendUrl}/api/session-heartbeat`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "x-device-id": config.deviceId
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!res.ok) {
+    throw new Error(`Heartbeat failed: ${res.status} ${res.statusText}`);
+  }
+}
+
+// src/spawn.ts
+var TMUX_SESSION_PREFIX = "aidash";
+function delay(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function spawnAgentSession(config, params) {
+  const sessionId = `sess_${uuidv4().slice(0, 8)}`;
+  const tmuxSessionName = `${TMUX_SESSION_PREFIX}-${sessionId}`;
+  const adapter = getAdapter(params.agentType);
+  const spawnCmd = adapter.buildSpawnCommand(params.task, params.projectPath);
+  createSession(tmuxSessionName, params.projectPath);
+  tmuxExec(
+    `tmux send-keys -t '${sanitizeShellArg(tmuxSessionName)}' '${sanitizeShellArg(spawnCmd)}' Enter`
+  );
+  if (params.task) {
+    await delay(3e3);
+    tmuxExec(
+      `tmux send-keys -t '${sanitizeShellArg(tmuxSessionName)}' '${sanitizeShellArg(params.task)}' Enter`
+    );
+  }
+  await sendHeartbeat(config, {
+    deviceId: config.deviceId,
+    sessionId,
+    agentType: params.agentType,
+    project: params.projectName,
+    cwd: params.projectPath,
+    branch: "",
+    status: "working",
+    task: params.task,
+    tmuxSession: tmuxSessionName,
+    tmuxWindow: params.projectName
+  });
+  console.log(`Spawned session ${sessionId} in tmux:${tmuxSessionName}`);
+  return sessionId;
+}
+
+// src/terminalBridge.ts
+import WebSocket from "ws";
+
+// ../shared/dist/constants.js
+var KEEPALIVE_INTERVAL_MS = 1e4;
+var TERMINAL_POLL_INTERVAL_MS = 500;
+
+// src/terminalBridge.ts
+var activeBridges = /* @__PURE__ */ new Map();
+function startTerminalBridge(sessionId, tmuxTarget, ws) {
+  if (!isTmuxAvailable()) {
+    console.log(`Terminal bridge skipped for ${sessionId}: tmux not available`);
+    return;
+  }
+  stopTerminalBridge(sessionId);
+  let lastOutput = "";
+  const interval = setInterval(() => {
+    try {
+      const raw = capturePaneOutput(tmuxTarget);
+      if (raw !== lastOutput) {
+        lastOutput = raw;
+        const output = raw.replace(/\n/g, "\r\n");
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(
+            JSON.stringify({
+              type: "terminal-output",
+              payload: { sessionId, data: output }
+            })
+          );
+        }
+      }
+    } catch {
+      stopTerminalBridge(sessionId);
+    }
+  }, TERMINAL_POLL_INTERVAL_MS);
+  activeBridges.set(sessionId, interval);
+  console.log(`Terminal bridge started for ${sessionId}`);
+}
+function stopTerminalBridge(sessionId) {
+  const interval = activeBridges.get(sessionId);
+  if (interval) {
+    clearInterval(interval);
+    activeBridges.delete(sessionId);
+    console.log(`Terminal bridge stopped for ${sessionId}`);
+  }
+}
+
+// src/wsClient.ts
+var reconnectAttempts = 0;
+function connectToBackend(config) {
+  const wsUrl = config.backendUrl.replace(/^http/, "ws") + `/ws/agent/${config.deviceId}?apiKey=${encodeURIComponent(config.apiKey)}`;
+  console.log(
+    `Connecting to backend WS: ${config.backendUrl}/ws/agent/${config.deviceId}`
+  );
+  const ws = new WebSocket2(wsUrl);
+  ws.on("open", () => {
+    reconnectAttempts = 0;
+    console.log("Connected to backend WebSocket");
+  });
+  ws.on("message", async (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      switch (msg.type) {
+        case "spawn-session": {
+          const { projectPath, projectName, agentType, task } = msg.payload;
+          const sessionId = await spawnAgentSession(config, {
+            projectPath,
+            projectName,
+            agentType,
+            task
+          });
+          ws.send(
+            JSON.stringify({
+              type: "session-started",
+              payload: { sessionId }
+            })
+          );
+          break;
+        }
+        case "kill-session": {
+          const { sessionId, tmuxSession } = msg.payload;
+          stopTerminalBridge(sessionId);
+          if (tmuxSession && tmuxSessionExists(tmuxSession)) {
+            tmuxExec(`tmux kill-session -t '${sanitizeShellArg(tmuxSession)}'`);
+            console.log(`Killed tmux session: ${tmuxSession}`);
+          }
+          ws.send(
+            JSON.stringify({
+              type: "session-ended",
+              payload: { sessionId }
+            })
+          );
+          break;
+        }
+        case "attach-terminal": {
+          const { sessionId, tmuxSession } = msg.payload;
+          startTerminalBridge(sessionId, tmuxSession, ws);
+          break;
+        }
+        case "detach-terminal": {
+          stopTerminalBridge(msg.payload.sessionId);
+          break;
+        }
+        case "terminal-input": {
+          if (isTmuxAvailable()) {
+            sendKeys(msg.payload.tmuxSession, msg.payload.data);
+          }
+          break;
+        }
+      }
+    } catch (e) {
+      console.error("Error handling WS message:", e);
+    }
+  });
+  ws.on("close", () => {
+    const delaySec = Math.min(2 ** Math.min(reconnectAttempts, 5), 32);
+    reconnectAttempts++;
+    console.log(`Disconnected. Reconnecting in ${delaySec}s...`);
+    setTimeout(() => connectToBackend(config), delaySec * 1e3);
+  });
+  ws.on("error", (e) => console.error("WS error:", e.message));
+  return ws;
+}
+
+// src/sessionScanner.ts
+import { execSync as execSync4 } from "child_process";
+import {
+  statSync as statSync2,
+  readdirSync as readdirSync2,
+  existsSync as existsSync4,
+  openSync,
+  readSync,
+  closeSync
+} from "fs";
+import { join as join2, basename as basename2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/enrichers/git.ts
+import { execSync as execSync3 } from "child_process";
+import { existsSync as existsSync3 } from "fs";
+function getGitInfo(cwd) {
+  if (!existsSync3(`${cwd}/.git`)) return null;
+  try {
+    const branch = execSync3("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
+    const repoName = execSync3("git rev-parse --show-toplevel", { cwd, encoding: "utf-8", timeout: 3e3 }).trim().split("/").pop() || "";
+    let remoteUrl = "";
+    try {
+      remoteUrl = execSync3("git remote get-url origin", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
+    } catch {
+    }
+    return { repoName, branch, remoteUrl };
+  } catch {
+    return null;
+  }
+}
+
+// src/sessionScanner.ts
+function buildTmuxPidMap() {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const output = execSync4(
+      "tmux list-panes -a -F '#{pane_pid} #{session_name}' 2>/dev/null",
+      { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+    ).trim();
+    for (const line of output.split("\n")) {
+      if (!line) continue;
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx === -1) continue;
+      const pid = parseInt(line.substring(0, spaceIdx), 10);
+      const sessionName = line.substring(spaceIdx + 1);
+      if (!isNaN(pid) && sessionName) {
+        map.set(pid, sessionName);
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function findTmuxSessionForPid(pid, tmuxPidMap) {
+  if (tmuxPidMap.size === 0) return "";
+  let currentPid = pid;
+  const maxDepth = 10;
+  for (let i = 0; i < maxDepth; i++) {
+    const session = tmuxPidMap.get(currentPid);
+    if (session) return session;
+    try {
+      const ppid = parseInt(
+        execSync4(`ps -p ${currentPid} -o ppid=`, {
+          encoding: "utf-8",
+          timeout: 2e3,
+          stdio: "pipe"
+        }).trim(),
+        10
+      );
+      if (isNaN(ppid) || ppid <= 1 || ppid === currentPid) break;
+      currentPid = ppid;
+    } catch {
+      break;
+    }
+  }
+  return "";
+}
+function pathToProjectDir(p) {
+  return p.replace(/\//g, "-");
+}
+function getProcessCwd(pid) {
+  try {
+    const output = execSync4(
+      `lsof -a -p ${pid} -d cwd -Fn 2>/dev/null | grep '^n'`,
+      { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+    ).trim();
+    const match = output.match(/^n(.+)$/m);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+function findAgentProcesses() {
+  const processes = [];
+  try {
+    const psOutput = execSync4("ps aux", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: "pipe"
+    });
+    for (const line of psOutput.split("\n")) {
+      const parts = line.trim().split(/\s+/);
+      const pid = parseInt(parts[1], 10);
+      if (isNaN(pid) || pid === process.pid) continue;
+      if ((line.includes("/claude") || line.match(/\sclaude(\s|$)/)) && !line.includes("grep") && !line.includes("codex")) {
+        let sessionId = null;
+        const resumeMatch = line.match(/--resume\s+([a-f0-9-]{36})/);
+        const sessionMatch = line.match(/--session-id\s+([a-f0-9-]{36})/);
+        if (resumeMatch) sessionId = resumeMatch[1];
+        else if (sessionMatch) sessionId = sessionMatch[1];
+        let model = "default";
+        const modelMatch = line.match(/--model\s+(\S+)/);
+        if (modelMatch) model = modelMatch[1];
+        const cwd = getProcessCwd(pid);
+        processes.push({
+          pid,
+          agentType: "claude-code",
+          sessionId,
+          model,
+          cwd
+        });
+      }
+      if (line.match(/\scodex\s*$/) || // bare "codex" at end of line (terminal)
+      line.match(/\scodex\s+(?!app-server)/)) {
+        const cwd = getProcessCwd(pid);
+        const sessionId = `codex-${pid}`;
+        processes.push({
+          pid,
+          agentType: "codex",
+          sessionId,
+          model: "codex",
+          cwd
+        });
+      }
+    }
+  } catch {
+  }
+  return processes;
+}
+function findLatestSessionFile(projPath) {
+  try {
+    const files = readdirSync2(projPath).filter((f) => f.endsWith(".jsonl"));
+    let latest = null;
+    for (const file of files) {
+      const filePath = join2(projPath, file);
+      try {
+        const mtime = statSync2(filePath).mtimeMs;
+        if (!latest || mtime > latest.mtimeMs) {
+          latest = { sessionId: basename2(file, ".jsonl"), mtimeMs: mtime };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return latest;
+  } catch {
+    return null;
+  }
+}
+function isAwaitingPermissionFromJsonl(projPath, sessionId) {
+  try {
+    const filePath = join2(projPath, `${sessionId}.jsonl`);
+    const size = statSync2(filePath).size;
+    if (size === 0) return false;
+    const TAIL_BYTES = 4096;
+    const start = Math.max(0, size - TAIL_BYTES);
+    const buf = Buffer.alloc(Math.min(TAIL_BYTES, size));
+    const fd = openSync(filePath, "r");
+    try {
+      readSync(fd, buf, 0, buf.length, start);
+    } finally {
+      closeSync(fd);
+    }
+    const tail = buf.toString("utf-8");
+    const lines = tail.trimEnd().split("\n");
+    const lastLine = lines[lines.length - 1];
+    if (!lastLine) return false;
+    const record = JSON.parse(lastLine);
+    return record.type === "assistant" && record.message?.stop_reason === "tool_use";
+  } catch {
+    return false;
+  }
+}
+var AWAITING_INPUT_PATTERNS = [
+  // Claude Code: tool use approval
+  /Do you want to proceed\?/,
+  /Allow once/,
+  /Allow always/,
+  // Codex: command approval
+  /Would you like to run the following command\?/,
+  /Yes, proceed/,
+  /Press enter to confirm or esc to cancel/,
+  /don't ask again for/,
+  // Generic: common approval prompts
+  /\(y\/n\)\s*$/,
+  /\[Y\/n\]\s*$/,
+  /\[yes\/no\]\s*$/
+];
+function isAwaitingInputFromTmux(tmuxSession) {
+  if (!tmuxSession) return false;
+  try {
+    const output = execSync4(
+      `tmux capture-pane -t '${tmuxSession.replace(/'/g, "'\\''")}' -p -S -20`,
+      {
+        encoding: "utf-8",
+        timeout: 3e3,
+        stdio: "pipe"
+      }
+    );
+    return AWAITING_INPUT_PATTERNS.some((pattern) => pattern.test(output));
+  } catch {
+    return false;
+  }
+}
+function discoverClaudeSessions(processes, tmuxPidMap) {
+  const sessions = [];
+  const claudeProjectsDir = join2(homedir2(), ".claude", "projects");
+  if (!existsSync4(claudeProjectsDir)) return sessions;
+  const now = Date.now();
+  const WORKING_THRESHOLD_MS = 5 * 1e3;
+  const seen = /* @__PURE__ */ new Map();
+  const seenCwd = /* @__PURE__ */ new Map();
+  for (const proc of processes) {
+    if (proc.agentType !== "claude-code") continue;
+    const cwd = proc.cwd;
+    if (!cwd) continue;
+    const projDirName = pathToProjectDir(cwd);
+    const projPath = join2(claudeProjectsDir, projDirName);
+    if (!existsSync4(projPath)) continue;
+    let sessionId = proc.sessionId;
+    let mtimeMs = null;
+    if (sessionId) {
+      const filePath = join2(projPath, `${sessionId}.jsonl`);
+      try {
+        mtimeMs = statSync2(filePath).mtimeMs;
+      } catch {
+        sessionId = null;
+      }
+    }
+    if (!sessionId) {
+      const latest = findLatestSessionFile(projPath);
+      if (!latest) continue;
+      sessionId = latest.sessionId;
+      mtimeMs = latest.mtimeMs;
+    }
+    if (!mtimeMs) continue;
+    const tmuxSession = findTmuxSessionForPid(proc.pid, tmuxPidMap);
+    const isSpawned = /^aidash-(sess_\w+)$/.test(tmuxSession);
+    const spawnMatch = tmuxSession.match(/^aidash-(sess_\w+)$/);
+    if (spawnMatch) {
+      sessionId = spawnMatch[1];
+    }
+    if (seen.has(sessionId)) {
+      if (tmuxSession) {
+        const idx = seen.get(sessionId);
+        sessions[idx].tmuxSession = tmuxSession;
+      }
+      continue;
+    }
+    if (seenCwd.has(cwd)) {
+      const existingIdx = seenCwd.get(cwd);
+      const existing = sessions[existingIdx];
+      if (isSpawned && !existing.tmuxSession.startsWith("aidash-")) {
+        sessions[existingIdx] = void 0;
+        seen.delete(existing.sessionId);
+      } else {
+        continue;
+      }
+    }
+    seen.set(sessionId, sessions.length);
+    seenCwd.set(cwd, sessions.length);
+    const ageMs = now - mtimeMs;
+    const project = basename2(cwd);
+    let branch = "";
+    const gitInfo = getGitInfo(cwd);
+    if (gitInfo) branch = gitInfo.branch;
+    const awaiting = isAwaitingPermissionFromJsonl(projPath, sessionId) || isAwaitingInputFromTmux(tmuxSession);
+    sessions.push({
+      sessionId,
+      project,
+      cwd,
+      branch,
+      model: proc.model,
+      status: awaiting ? "awaiting_permission" : ageMs < WORKING_THRESHOLD_MS ? "working" : "idle",
+      agentType: "claude-code",
+      pid: proc.pid,
+      tmuxSession
+    });
+  }
+  return sessions.filter(Boolean);
+}
+function getCodexSessionsFromDb() {
+  const map = /* @__PURE__ */ new Map();
+  const dbPath = join2(homedir2(), ".codex", "state_5.sqlite");
+  if (!existsSync4(dbPath)) return map;
+  try {
+    const output = execSync4(
+      `sqlite3 "${dbPath}" "SELECT id, cwd, title, model_provider, updated_at FROM threads ORDER BY updated_at DESC LIMIT 50;"`,
+      { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+    ).trim();
+    if (!output) return map;
+    for (const line of output.split("\n")) {
+      const [id, cwd, title, model, updatedAtStr] = line.split("|");
+      if (!cwd || map.has(cwd)) continue;
+      map.set(cwd, {
+        id,
+        cwd,
+        title,
+        model: model || "codex",
+        updatedAt: parseInt(updatedAtStr, 10) || 0
+      });
+    }
+  } catch {
+  }
+  return map;
+}
+function discoverCodexSessions(processes, tmuxPidMap) {
+  const sessions = [];
+  const seen = /* @__PURE__ */ new Set();
+  const codexProcesses = processes.filter(
+    (p) => p.agentType === "codex" && p.cwd && p.cwd !== "/"
+  );
+  if (codexProcesses.length === 0) return sessions;
+  const codexSessions = getCodexSessionsFromDb();
+  const nowSecs = Math.floor(Date.now() / 1e3);
+  const WORKING_THRESHOLD_SECS = 5;
+  for (const proc of codexProcesses) {
+    const cwd = proc.cwd;
+    const dbSession = codexSessions.get(cwd);
+    const sessionId = dbSession ? dbSession.id : `codex-${proc.pid}`;
+    if (seen.has(sessionId)) continue;
+    seen.add(sessionId);
+    const project = basename2(cwd);
+    let branch = "";
+    const gitInfo = getGitInfo(cwd);
+    if (gitInfo) branch = gitInfo.branch;
+    const ageSecs = dbSession ? nowSecs - dbSession.updatedAt : Infinity;
+    const model = dbSession ? dbSession.model : "codex";
+    const tmuxSession = findTmuxSessionForPid(proc.pid, tmuxPidMap);
+    const spawnMatch = tmuxSession.match(/^aidash-(sess_\w+)$/);
+    if (spawnMatch) {
+      const spawnId = spawnMatch[1];
+      if (!seen.has(spawnId)) {
+        seen.add(spawnId);
+        sessions.push({
+          sessionId: spawnId,
+          project,
+          cwd,
+          branch,
+          model,
+          status: isAwaitingInputFromTmux(tmuxSession) ? "awaiting_permission" : ageSecs < WORKING_THRESHOLD_SECS ? "working" : "idle",
+          agentType: "codex",
+          pid: proc.pid,
+          tmuxSession
+        });
+      }
+      continue;
+    }
+    const awaiting = isAwaitingInputFromTmux(tmuxSession);
+    sessions.push({
+      sessionId,
+      project,
+      cwd,
+      branch,
+      model,
+      status: awaiting ? "awaiting_permission" : ageSecs < WORKING_THRESHOLD_SECS ? "working" : "idle",
+      agentType: "codex",
+      pid: proc.pid,
+      tmuxSession
+    });
+  }
+  return sessions;
+}
+function discoverAllSessions() {
+  const processes = findAgentProcesses();
+  const tmuxPidMap = buildTmuxPidMap();
+  return [
+    ...discoverClaudeSessions(processes, tmuxPidMap),
+    ...discoverCodexSessions(processes, tmuxPidMap)
+  ];
+}
+async function scanAndReportSessions(config) {
+  const sessions = discoverAllSessions();
+  for (const session of sessions) {
+    try {
+      await fetch(`${config.backendUrl}/api/session-heartbeat`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": config.apiKey,
+          "x-device-id": config.deviceId
+        },
+        body: JSON.stringify({
+          deviceId: config.deviceId,
+          sessionId: session.sessionId,
+          agentType: session.agentType,
+          project: session.project,
+          cwd: session.cwd,
+          branch: session.branch,
+          status: session.status,
+          model: session.model,
+          task: "",
+          tmuxSession: session.tmuxSession,
+          tmuxWindow: session.project
+        })
+      });
+    } catch {
+    }
+  }
+  if (sessions.length > 0) {
+    console.log(
+      `Session scanner: reported ${sessions.length} active session(s)`
+    );
+  }
+}
+var SCAN_INTERVAL_MS = 5e3;
+function startSessionScanner(config) {
+  scanAndReportSessions(config).catch(() => {
+  });
+  return setInterval(() => {
+    scanAndReportSessions(config).catch(() => {
+    });
+  }, SCAN_INTERVAL_MS);
+}
+
+// src/agent.ts
+async function waitForBackend(config, maxRetries = 30) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      await registerDevice(config);
+      return;
+    } catch {
+      const delaySec = Math.min(2 ** Math.min(i, 4), 16);
+      console.log(
+        `Backend not ready, retrying in ${delaySec}s... (${i + 1}/${maxRetries})`
+      );
+      await new Promise((r) => setTimeout(r, delaySec * 1e3));
+    }
+  }
+  throw new Error("Backend not reachable after retries");
+}
+async function startAgent(config) {
+  console.log(`Starting agent for device: ${config.deviceId}`);
+  console.log(`Backend: ${config.backendUrl}`);
+  await waitForBackend(config);
+  await syncProjects(config);
+  connectToBackend(config);
+  startSessionScanner(config);
+  setInterval(async () => {
+    try {
+      await registerDevice(config);
+    } catch (e) {
+      console.error("Keepalive failed:", e);
+    }
+  }, KEEPALIVE_INTERVAL_MS);
+  console.log("Agent running. Press Ctrl+C to stop.");
+}
+var isDirectRun = process.argv[1] && import.meta.url.endsWith(process.argv[1].replace(/\\/g, "/"));
+if (isDirectRun) {
+  const configPath = process.argv[2];
+  const config = loadConfig(configPath);
+  startAgent(config).catch((e) => {
+    console.error("Agent failed:", e);
+    process.exit(1);
+  });
+}
+
+export {
+  resolveConfigPath,
+  parseConfigFile,
+  mergeCliOverrides,
+  startAgent
+};

package/dist/cli.js

@@ -0,0 +1,167 @@
+import {
+  mergeCliOverrides,
+  parseConfigFile,
+  resolveConfigPath,
+  startAgent
+} from "./chunk-24ORBJSI.js";
+
+// src/init.ts
+import { createInterface } from "readline/promises";
+import { mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { hostname, platform, homedir } from "os";
+function buildConfigFromAnswers(answers) {
+  return {
+    deviceId: hostname(),
+    deviceName: answers.deviceName || `${hostname()}-${platform()}`,
+    backendUrl: answers.backendUrl,
+    apiKey: answers.apiKey,
+    projects: [],
+    projectDirs: answers.projectDirs ? answers.projectDirs.split(",").map((d) => d.trim()).filter(Boolean) : []
+  };
+}
+async function validateBackend(url) {
+  try {
+    const res = await fetch(`${url}/health`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function runInitWizard() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  console.log("\nNo config found. Let's set up your agent.\n");
+  try {
+    const backendUrl = await rl.question("Backend URL: ");
+    if (!backendUrl) {
+      throw new Error("Backend URL is required");
+    }
+    process.stdout.write("Checking backend... ");
+    const reachable = await validateBackend(backendUrl);
+    if (!reachable) {
+      console.log("unreachable (continuing anyway)");
+    } else {
+      console.log("ok");
+    }
+    const apiKey = await rl.question("API Key: ");
+    if (!apiKey) {
+      throw new Error("API Key is required");
+    }
+    const defaultName = `${hostname()}-${platform()}`;
+    const deviceName = await rl.question(`Device name (${defaultName}): `);
+    const projectDirs = await rl.question(
+      "Project directories (comma-separated, optional): "
+    );
+    const config = buildConfigFromAnswers({
+      backendUrl,
+      apiKey,
+      deviceName,
+      projectDirs
+    });
+    const configDir = resolve(homedir(), ".agtd");
+    const configPath = resolve(configDir, "agent.config.json");
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+    console.log(`
+Config saved to ${configPath}
+`);
+    return config;
+  } finally {
+    rl.close();
+  }
+}
+
+// src/cli.ts
+function parseArgs(argv) {
+  const args = { init: false, help: false };
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    const next = argv[i + 1];
+    switch (arg) {
+      case "--init":
+        args.init = true;
+        break;
+      case "--backend":
+        args.backend = next;
+        i++;
+        break;
+      case "--api-key":
+        args.apiKey = next;
+        i++;
+        break;
+      case "--device-name":
+        args.deviceName = next;
+        i++;
+        break;
+      case "--config":
+        args.configPath = next;
+        i++;
+        break;
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+    }
+  }
+  return args;
+}
+function printHelp() {
+  console.log(`
+Usage: agtd-agent [options]
+
+Options:
+  --init              Run interactive setup wizard
+  --backend <url>     Backend URL (overrides config)
+  --api-key <key>     API key (overrides config)
+  --device-name <n>   Device name (overrides config)
+  --config <path>     Path to config file
+  -h, --help          Show this help message
+
+Config is loaded from (in order):
+  1. --config flag
+  2. AGENT_CONFIG env var
+  3. ~/.agtd/agent.config.json
+  4. ./agent.config.json
+  5. Interactive setup (if none found)
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv);
+  if (args.help) {
+    printHelp();
+    return;
+  }
+  if (args.init) {
+    const config = await runInitWizard();
+    await startAgent(config);
+    return;
+  }
+  const configPath = resolveConfigPath(args.configPath);
+  if (configPath) {
+    const overrides = {
+      backend: args.backend,
+      apiKey: args.apiKey,
+      deviceName: args.deviceName
+    };
+    const config = mergeCliOverrides(parseConfigFile(configPath), overrides);
+    await startAgent(config);
+  } else if (args.backend && args.apiKey) {
+    const config = buildConfigFromAnswers({
+      backendUrl: args.backend,
+      apiKey: args.apiKey,
+      deviceName: args.deviceName ?? "",
+      projectDirs: ""
+    });
+    await startAgent(config);
+  } else {
+    const config = await runInitWizard();
+    await startAgent(config);
+  }
+}
+main().catch((e) => {
+  console.error("Agent failed:", e);
+  process.exit(1);
+});
+export {
+  parseArgs
+};

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@agtd/agent",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "agtd-agent": "./bin/agtd-agent.js"
+  },
+  "main": "dist/agent.js",
+  "files": ["bin", "dist", "README.md"],
+  "scripts": {
+    "dev": "tsx watch src/agent.ts",
+    "build": "tsc",
+    "build:publish": "tsup",
+    "start": "node dist/agent.js",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "uuid": "^10.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@agtd/shared": "workspace:*",
+    "@types/uuid": "^10.0.0",
+    "@types/ws": "^8.5.0",
+    "tsup": "^8.5.1",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.0.0"
+  }
+}