@agtd/agent 0.1.1 → 0.1.3

package/dist/agent.js

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

package/dist/{chunk-24ORBJSI.js → chunk-RJLNNX7L.js}

@@ -354,7 +354,26 @@ async function sendHeartbeat(config, payload) {
 }
 
 // src/spawn.ts
+import { existsSync as existsSync3 } from "fs";
+import { execSync as execSync3 } from "child_process";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 var TMUX_SESSION_PREFIX = "aidash";
+function findCodexThreadId(cwd, afterTimeSec) {
+  const dbPath = join2(homedir2(), ".codex", "state_5.sqlite");
+  if (!existsSync3(dbPath)) return null;
+  try {
+    const safeDb = dbPath.replace(/'/g, "'\\''");
+    const safeCwd = cwd.replace(/'/g, "'\\''");
+    const output = execSync3(
+      `sqlite3 '${safeDb}' "SELECT id FROM threads WHERE cwd='${safeCwd}' AND archived=0 AND created_at >= ${afterTimeSec} ORDER BY created_at ASC LIMIT 1;"`,
+      { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+    ).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
 function delay(ms) {
   return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
@@ -363,6 +382,7 @@ async function spawnAgentSession(config, params) {
   const tmuxSessionName = `${TMUX_SESSION_PREFIX}-${sessionId}`;
   const adapter = getAdapter(params.agentType);
   const spawnCmd = adapter.buildSpawnCommand(params.task, params.projectPath);
+  const spawnTimeSec = Math.floor(Date.now() / 1e3);
   createSession(tmuxSessionName, params.projectPath);
   tmuxExec(
     `tmux send-keys -t '${sanitizeShellArg(tmuxSessionName)}' '${sanitizeShellArg(spawnCmd)}' Enter`
@@ -373,6 +393,15 @@ async function spawnAgentSession(config, params) {
       `tmux send-keys -t '${sanitizeShellArg(tmuxSessionName)}' '${sanitizeShellArg(params.task)}' Enter`
     );
   }
+  let codexThreadId = null;
+  if (params.agentType === "codex") {
+    for (let i = 0; i < 4; i++) {
+      codexThreadId = findCodexThreadId(params.projectPath, spawnTimeSec);
+      if (codexThreadId) break;
+      await delay(2e3);
+    }
+    console.log(`[spawn] codexThreadId=${codexThreadId ?? "null"}`);
+  }
   await sendHeartbeat(config, {
     deviceId: config.deviceId,
     sessionId,
@@ -383,7 +412,8 @@ async function spawnAgentSession(config, params) {
     status: "working",
     task: params.task,
     tmuxSession: tmuxSessionName,
-    tmuxWindow: params.projectName
+    tmuxWindow: params.projectName,
+    codexThreadId
   });
   console.log(`Spawned session ${sessionId} in tmux:${tmuxSessionName}`);
   return sessionId;
@@ -436,6 +466,352 @@ function stopTerminalBridge(sessionId) {
   }
 }
 
+// src/transcriptAdapters/index.ts
+var adapters2 = /* @__PURE__ */ new Map();
+function registerAdapter(agentType, adapter) {
+  adapters2.set(agentType, adapter);
+}
+function getAdapter2(agentType) {
+  return adapters2.get(agentType);
+}
+
+// src/transcriptAdapters/claude-code.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+function truncate(s, max) {
+  if (!s) return "";
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function summarizeToolInput(toolName, input) {
+  if (!input) return {};
+  switch (toolName) {
+    case "Read":
+      return { file_path: input.file_path };
+    case "Write":
+      return { file_path: input.file_path, content: truncate(input.content, 100) };
+    case "Edit":
+      return { file_path: input.file_path, old_string: truncate(input.old_string, 80), new_string: truncate(input.new_string, 80) };
+    case "Bash":
+      return { command: truncate(input.command, 200) };
+    case "Grep":
+      return { pattern: input.pattern, path: input.path };
+    case "Glob":
+      return { pattern: input.pattern, path: input.path };
+    case "Agent":
+      return { description: input.description, subagent_type: input.subagent_type };
+    default:
+      return Object.fromEntries(
+        Object.entries(input).slice(0, 3).map(([k, v]) => [k, typeof v === "string" ? truncate(v, 100) : v])
+      );
+  }
+}
+function parseContent(content) {
+  if (!content) return [];
+  if (typeof content === "string") return content.trim() ? [{ type: "text", text: content }] : [];
+  if (!Array.isArray(content)) return [];
+  const result = [];
+  for (const block of content) {
+    if (block.type === "text" && block.text?.trim()) {
+      result.push({ type: "text", text: block.text });
+    } else if (block.type === "thinking" && block.thinking?.trim()) {
+      result.push({ type: "thinking", text: block.thinking });
+    } else if (block.type === "tool_use") {
+      result.push({ type: "tool_use", toolName: block.name ?? "", toolInput: summarizeToolInput(block.name, block.input) });
+    } else if (block.type === "tool_result") {
+      const text = typeof block.content === "string" ? block.content : Array.isArray(block.content) ? block.content.filter((c) => c.type === "text").map((c) => c.text).join("\n") : "";
+      if (text.trim()) result.push({ type: "tool_result", text: truncate(text, 500) });
+    }
+  }
+  return result;
+}
+function parseRecord(record) {
+  if (!record.type || !record.uuid) return null;
+  if (record.type === "user" && record.message) {
+    const content = parseContent(record.message.content);
+    if (!content.some((c) => c.type === "text" || c.type === "thinking")) return null;
+    const textOnly = content.filter((c) => c.type === "text");
+    const firstText = textOnly[0]?.text || "";
+    if (firstText.startsWith("This session is being continued") || firstText.startsWith("<system-reminder>") || firstText.startsWith("Conversation compacted") || firstText.startsWith("Base directory for this skill:") || firstText.startsWith("# ")) return null;
+    return { id: record.uuid, role: "user", timestamp: record.timestamp || "", content: textOnly };
+  }
+  if (record.type === "assistant" && record.message) {
+    const content = parseContent(record.message.content);
+    if (content.length === 0) return null;
+    return {
+      id: record.uuid,
+      role: "assistant",
+      timestamp: record.timestamp || "",
+      content,
+      model: record.message.model,
+      usage: record.message.usage ? { input_tokens: record.message.usage.input_tokens || 0, output_tokens: record.message.usage.output_tokens || 0 } : void 0
+    };
+  }
+  if (record.type === "system" && record.content && record.subtype !== "local_command") {
+    const text = typeof record.content === "string" ? record.content.replace(/<[^>]+>/g, "").trim() : "";
+    if (!text || text.length < 5) return null;
+    return { id: record.uuid, role: "system", timestamp: record.timestamp || "", content: [{ type: "text", text }] };
+  }
+  return null;
+}
+var claudeCodeAdapter2 = {
+  findFile(session, homeDir = homedir3()) {
+    const projectDirName = session.cwd.replace(/\/+$/, "").replace(/\//g, "-");
+    const projPath = join3(homeDir, ".claude", "projects", projectDirName);
+    if (!existsSync4(projPath)) return null;
+    try {
+      const files = readdirSync2(projPath).filter((f) => f.endsWith(".jsonl"));
+      let latest = null;
+      for (const file of files) {
+        const filePath = join3(projPath, file);
+        try {
+          const { mtimeMs } = statSync2(filePath);
+          if (!latest || mtimeMs > latest.mtime) latest = { path: filePath, mtime: mtimeMs };
+        } catch {
+          continue;
+        }
+      }
+      return latest?.path ?? null;
+    } catch {
+      return null;
+    }
+  },
+  parse(filePath, cursor, limit) {
+    try {
+      const content = readFileSync2(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const messages = [];
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          const msg = parseRecord(record);
+          if (msg) messages.push(msg);
+        } catch {
+        }
+      }
+      const total = messages.length;
+      const page = messages.slice(cursor, cursor + limit);
+      const nextCursor = cursor + page.length;
+      return { messages: page, total, hasMore: nextCursor < total, nextCursor };
+    } catch {
+      return { messages: [], total: 0, hasMore: false, nextCursor: 0 };
+    }
+  }
+};
+registerAdapter("claude-code", claudeCodeAdapter2);
+
+// src/transcriptAdapters/codex.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, statSync as statSync3 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+import { execSync as execSync4 } from "child_process";
+function truncate2(s, max) {
+  if (!s) return "";
+  return s.length > max ? s.slice(0, max) + "..." : s;
+}
+function extractCodexText(content) {
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((c) => c.text || "").filter((t) => t.trim()).join("\n");
+}
+function summarizeCodexToolInput(name, args) {
+  if (name === "exec_command" || name === "shell")
+    return { cmd: truncate2(args.cmd, 200) };
+  if (name === "read_file" || name === "write_file")
+    return {
+      path: args.path || args.file_path,
+      content: args.content ? truncate2(args.content, 100) : void 0
+    };
+  return Object.fromEntries(
+    Object.entries(args).slice(0, 3).map(([k, v]) => [k, typeof v === "string" ? truncate2(v, 150) : v])
+  );
+}
+function parseRecord2(record, counter) {
+  if (!record.type || !record.payload) return null;
+  const p = record.payload;
+  const ts = record.timestamp || "";
+  if (record.type !== "response_item") return null;
+  if (p.type === "message" && p.role === "user") {
+    const texts = Array.isArray(p.content) ? p.content.map((c) => typeof c === "string" ? c : c.text || "").filter(
+      (t) => t.trim() && !t.startsWith("#") && !t.startsWith("<permissions")
+    ) : (() => {
+      const t = extractCodexText(p.content);
+      return t && !t.startsWith("#") && !t.startsWith("<permissions") ? [t] : [];
+    })();
+    if (texts.length === 0) return null;
+    if (texts.length === 1)
+      return {
+        id: `codex-${++counter.value}`,
+        role: "user",
+        timestamp: ts,
+        content: [{ type: "text", text: texts[0] }]
+      };
+    return texts.map((text) => ({
+      id: `codex-${++counter.value}`,
+      role: "user",
+      timestamp: ts,
+      content: [{ type: "text", text }]
+    }));
+  }
+  if (p.type === "message" && p.role === "assistant") {
+    const text = extractCodexText(p.content);
+    if (!text) return null;
+    return {
+      id: `codex-${++counter.value}`,
+      role: "assistant",
+      timestamp: ts,
+      content: [{ type: "text", text }],
+      model: "codex"
+    };
+  }
+  if (p.type === "reasoning") {
+    const summaryText = Array.isArray(p.summary) && p.summary.length > 0 ? p.summary.map((s) => s.text || "").join("\n") : null;
+    if (!summaryText) return null;
+    return {
+      id: `codex-${++counter.value}`,
+      role: "assistant",
+      timestamp: ts,
+      content: [{ type: "thinking", text: summaryText }]
+    };
+  }
+  if (p.type === "function_call") {
+    let args = {};
+    try {
+      args = typeof p.arguments === "string" ? JSON.parse(p.arguments) : p.arguments || {};
+    } catch {
+      args = { raw: truncate2(p.arguments, 200) };
+    }
+    return {
+      id: `codex-${++counter.value}`,
+      role: "assistant",
+      timestamp: ts,
+      content: [
+        {
+          type: "tool_use",
+          toolName: p.name || "unknown",
+          toolInput: summarizeCodexToolInput(p.name, args)
+        }
+      ]
+    };
+  }
+  if (p.type === "function_call_output") {
+    const output = typeof p.output === "string" ? p.output : "";
+    if (!output.trim()) return null;
+    return {
+      id: `codex-${++counter.value}`,
+      role: "assistant",
+      timestamp: ts,
+      content: [{ type: "tool_result", text: truncate2(output, 500) }]
+    };
+  }
+  return null;
+}
+function safeReaddir(dir) {
+  try {
+    return readdirSync3(dir);
+  } catch {
+    return [];
+  }
+}
+function findLatestJsonl(dir) {
+  let latest = null;
+  try {
+    for (const year of readdirSync3(dir)) {
+      for (const month of safeReaddir(join4(dir, year))) {
+        for (const day of safeReaddir(join4(dir, year, month))) {
+          for (const file of safeReaddir(join4(dir, year, month, day))) {
+            if (!file.endsWith(".jsonl")) continue;
+            const fp = join4(dir, year, month, day, file);
+            try {
+              const { mtimeMs } = statSync3(fp);
+              if (!latest || mtimeMs > latest.mtime)
+                latest = { path: fp, mtime: mtimeMs };
+            } catch {
+              continue;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return latest?.path ?? null;
+}
+var codexAdapter2 = {
+  findFile(session, homeDir = homedir4()) {
+    const s = session;
+    const dbPath = join4(homeDir, ".codex", "state_5.sqlite");
+    if (existsSync5(dbPath)) {
+      try {
+        const safeDb = dbPath.replace(/'/g, "'\\''");
+        if (s.codexThreadId) {
+          const safeId = s.codexThreadId.replace(/'/g, "'\\''");
+          const idOutput = execSync4(
+            `sqlite3 '${safeDb}' "SELECT rollout_path FROM threads WHERE id='${safeId}' LIMIT 1;"`,
+            { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+          ).trim();
+          if (idOutput && existsSync5(idOutput)) return idOutput;
+        }
+        if (session.cwd && s.tmuxSession) {
+          try {
+            const safeTmux = s.tmuxSession.replace(/'/g, "'\\''");
+            const tmuxCreated = execSync4(
+              `tmux display-message -t '${safeTmux}' -p '#{session_created}'`,
+              { encoding: "utf-8", timeout: 2e3, stdio: "pipe" }
+            ).trim();
+            if (tmuxCreated && /^\d+$/.test(tmuxCreated)) {
+              const safeCwd = session.cwd.replace(/"/g, '\\"');
+              const tsOutput = execSync4(
+                `sqlite3 '${safeDb}' "SELECT rollout_path FROM threads WHERE cwd='${safeCwd}' AND archived=0 AND created_at >= ${tmuxCreated} ORDER BY created_at ASC LIMIT 1;"`,
+                { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+              ).trim();
+              if (tsOutput && existsSync5(tsOutput)) return tsOutput;
+            }
+          } catch {
+          }
+        }
+        if (session.cwd) {
+          const safeCwd = session.cwd.replace(/"/g, '\\"');
+          const cwdOutput = execSync4(
+            `sqlite3 '${safeDb}' "SELECT rollout_path FROM threads WHERE cwd='${safeCwd}' AND archived=0 ORDER BY updated_at DESC LIMIT 1;"`,
+            { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
+          ).trim();
+          if (cwdOutput && existsSync5(cwdOutput)) return cwdOutput;
+        }
+      } catch {
+      }
+    }
+    const sessionsDir = join4(homeDir, ".codex", "sessions");
+    if (!existsSync5(sessionsDir)) return null;
+    return findLatestJsonl(sessionsDir);
+  },
+  parse(filePath, cursor, limit) {
+    try {
+      const content = readFileSync3(filePath, "utf-8");
+      const lines = content.split("\n").filter((l) => l.trim());
+      const counter = { value: 0 };
+      const messages = [];
+      for (const line of lines) {
+        try {
+          const record = JSON.parse(line);
+          const msg = parseRecord2(record, counter);
+          if (Array.isArray(msg)) messages.push(...msg);
+          else if (msg) messages.push(msg);
+        } catch {
+        }
+      }
+      const total = messages.length;
+      const page = messages.slice(cursor, cursor + limit);
+      const nextCursor = cursor + page.length;
+      return { messages: page, total, hasMore: nextCursor < total, nextCursor };
+    } catch {
+      return { messages: [], total: 0, hasMore: false, nextCursor: 0 };
+    }
+  }
+};
+registerAdapter("codex", codexAdapter2);
+
 // src/wsClient.ts
 var reconnectAttempts = 0;
 function connectToBackend(config) {
@@ -498,6 +874,87 @@ function connectToBackend(config) {
           }
           break;
         }
+        case "user-message": {
+          const tmuxAvail = isTmuxAvailable();
+          const sessionExists = tmuxSessionExists(msg.payload.tmuxSession);
+          let paneInfo = "n/a";
+          try {
+            paneInfo = tmuxExec(
+              `tmux list-panes -t '${sanitizeShellArg(msg.payload.tmuxSession)}' -F '#I:#P #{pane_current_command} #{pane_active}'`
+            ).trim();
+          } catch {
+          }
+          console.log(
+            `[user-message] session=${msg.payload.tmuxSession} exists=${sessionExists} available=${tmuxAvail} panes="${paneInfo}" msg="${msg.payload.message?.slice(0, 80)}"`
+          );
+          if (tmuxAvail && sessionExists) {
+            try {
+              let paneBefore = "";
+              try {
+                paneBefore = tmuxExec(
+                  `tmux capture-pane -t '${sanitizeShellArg(msg.payload.tmuxSession)}' -p -S -10`
+                ).split("\n").slice(-5).join(" | ");
+              } catch {
+              }
+              console.log(`[user-message] pane-before: ${paneBefore}`);
+              sendKeys(msg.payload.tmuxSession, msg.payload.message);
+              await new Promise((r) => setTimeout(r, 80));
+              sendKeys(msg.payload.tmuxSession, "\r");
+              console.log(`[user-message] sent OK`);
+              await new Promise((r) => setTimeout(r, 500));
+              let paneAfter = "";
+              try {
+                paneAfter = tmuxExec(
+                  `tmux capture-pane -t '${sanitizeShellArg(msg.payload.tmuxSession)}' -p -S -10`
+                ).split("\n").slice(-5).join(" | ");
+              } catch {
+              }
+              console.log(`[user-message] pane-after: ${paneAfter}`);
+            } catch (e) {
+              console.error(`[user-message] sendKeys failed:`, e);
+            }
+          }
+          break;
+        }
+        case "get-transcript": {
+          const {
+            requestId,
+            sessionId,
+            agentType,
+            cwd,
+            cursor = 0,
+            limit = 50,
+            codexThreadId = null,
+            tmuxSession = null
+          } = msg.payload;
+          const adapter = getAdapter2(agentType);
+          let result = {
+            messages: [],
+            total: 0,
+            hasMore: false,
+            nextCursor: 0
+          };
+          if (adapter) {
+            const fakeSession = {
+              id: sessionId,
+              cwd,
+              agentType,
+              codexThreadId,
+              tmuxSession
+            };
+            const filePath = adapter.findFile(fakeSession);
+            if (filePath) {
+              result = adapter.parse(filePath, cursor, limit);
+            }
+          }
+          ws.send(
+            JSON.stringify({
+              type: "transcript-response",
+              payload: { requestId, ...result }
+            })
+          );
+          break;
+        }
       }
     } catch (e) {
       console.error("Error handling WS message:", e);
@@ -514,29 +971,29 @@ function connectToBackend(config) {
 }
 
 // src/sessionScanner.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 import {
-  statSync as statSync2,
-  readdirSync as readdirSync2,
-  existsSync as existsSync4,
+  statSync as statSync4,
+  readdirSync as readdirSync4,
+  existsSync as existsSync7,
   openSync,
   readSync,
   closeSync
 } from "fs";
-import { join as join2, basename as basename2 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join5, basename as basename2 } from "path";
+import { homedir as homedir5 } from "os";
 
 // src/enrichers/git.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
 function getGitInfo(cwd) {
-  if (!existsSync3(`${cwd}/.git`)) return null;
+  if (!existsSync6(`${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() || "";
+    const branch = execSync5("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
+    const repoName = execSync5("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();
+      remoteUrl = execSync5("git remote get-url origin", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
     } catch {
     }
     return { repoName, branch, remoteUrl };
@@ -549,7 +1006,7 @@ function getGitInfo(cwd) {
 function buildTmuxPidMap() {
   const map = /* @__PURE__ */ new Map();
   try {
-    const output = execSync4(
+    const output = execSync6(
       "tmux list-panes -a -F '#{pane_pid} #{session_name}' 2>/dev/null",
       { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
     ).trim();
@@ -576,7 +1033,7 @@ function findTmuxSessionForPid(pid, tmuxPidMap) {
     if (session) return session;
     try {
       const ppid = parseInt(
-        execSync4(`ps -p ${currentPid} -o ppid=`, {
+        execSync6(`ps -p ${currentPid} -o ppid=`, {
           encoding: "utf-8",
           timeout: 2e3,
           stdio: "pipe"
@@ -596,7 +1053,7 @@ function pathToProjectDir(p) {
 }
 function getProcessCwd(pid) {
   try {
-    const output = execSync4(
+    const output = execSync6(
       `lsof -a -p ${pid} -d cwd -Fn 2>/dev/null | grep '^n'`,
       { encoding: "utf-8", timeout: 3e3, stdio: "pipe" }
     ).trim();
@@ -609,7 +1066,7 @@ function getProcessCwd(pid) {
 function findAgentProcesses() {
   const processes = [];
   try {
-    const psOutput = execSync4("ps aux", {
+    const psOutput = execSync6("ps aux", {
       encoding: "utf-8",
       timeout: 5e3,
       stdio: "pipe"
@@ -655,12 +1112,12 @@ function findAgentProcesses() {
 }
 function findLatestSessionFile(projPath) {
   try {
-    const files = readdirSync2(projPath).filter((f) => f.endsWith(".jsonl"));
+    const files = readdirSync4(projPath).filter((f) => f.endsWith(".jsonl"));
     let latest = null;
     for (const file of files) {
-      const filePath = join2(projPath, file);
+      const filePath = join5(projPath, file);
       try {
-        const mtime = statSync2(filePath).mtimeMs;
+        const mtime = statSync4(filePath).mtimeMs;
         if (!latest || mtime > latest.mtimeMs) {
           latest = { sessionId: basename2(file, ".jsonl"), mtimeMs: mtime };
         }
@@ -675,8 +1132,8 @@ function findLatestSessionFile(projPath) {
 }
 function isAwaitingPermissionFromJsonl(projPath, sessionId) {
   try {
-    const filePath = join2(projPath, `${sessionId}.jsonl`);
-    const size = statSync2(filePath).size;
+    const filePath = join5(projPath, `${sessionId}.jsonl`);
+    const size = statSync4(filePath).size;
     if (size === 0) return false;
     const TAIL_BYTES = 4096;
     const start = Math.max(0, size - TAIL_BYTES);
@@ -715,7 +1172,7 @@ var AWAITING_INPUT_PATTERNS = [
 function isAwaitingInputFromTmux(tmuxSession) {
   if (!tmuxSession) return false;
   try {
-    const output = execSync4(
+    const output = execSync6(
       `tmux capture-pane -t '${tmuxSession.replace(/'/g, "'\\''")}' -p -S -20`,
       {
         encoding: "utf-8",
@@ -730,8 +1187,8 @@ function isAwaitingInputFromTmux(tmuxSession) {
 }
 function discoverClaudeSessions(processes, tmuxPidMap) {
   const sessions = [];
-  const claudeProjectsDir = join2(homedir2(), ".claude", "projects");
-  if (!existsSync4(claudeProjectsDir)) return sessions;
+  const claudeProjectsDir = join5(homedir5(), ".claude", "projects");
+  if (!existsSync7(claudeProjectsDir)) return sessions;
   const now = Date.now();
   const WORKING_THRESHOLD_MS = 5 * 1e3;
   const seen = /* @__PURE__ */ new Map();
@@ -741,14 +1198,14 @@ function discoverClaudeSessions(processes, tmuxPidMap) {
     const cwd = proc.cwd;
     if (!cwd) continue;
     const projDirName = pathToProjectDir(cwd);
-    const projPath = join2(claudeProjectsDir, projDirName);
-    if (!existsSync4(projPath)) continue;
+    const projPath = join5(claudeProjectsDir, projDirName);
+    if (!existsSync7(projPath)) continue;
     let sessionId = proc.sessionId;
     let mtimeMs = null;
     if (sessionId) {
-      const filePath = join2(projPath, `${sessionId}.jsonl`);
+      const filePath = join5(projPath, `${sessionId}.jsonl`);
       try {
-        mtimeMs = statSync2(filePath).mtimeMs;
+        mtimeMs = statSync4(filePath).mtimeMs;
       } catch {
         sessionId = null;
       }
@@ -807,10 +1264,10 @@ function discoverClaudeSessions(processes, tmuxPidMap) {
 }
 function getCodexSessionsFromDb() {
   const map = /* @__PURE__ */ new Map();
-  const dbPath = join2(homedir2(), ".codex", "state_5.sqlite");
-  if (!existsSync4(dbPath)) return map;
+  const dbPath = join5(homedir5(), ".codex", "state_5.sqlite");
+  if (!existsSync7(dbPath)) return map;
   try {
-    const output = execSync4(
+    const output = execSync6(
       `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();

package/dist/cli.js

@@ -3,7 +3,7 @@ import {
   parseConfigFile,
   resolveConfigPath,
   startAgent
-} from "./chunk-24ORBJSI.js";
+} from "./chunk-RJLNNX7L.js";
 
 // src/cli.ts
 import { execSync } from "child_process";

package/package.json

@@ -1,16 +1,21 @@
 {
   "name": "@agtd/agent",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
   "bin": {
     "agtd-agent": "./bin/agtd-agent.js"
   },
   "main": "dist/agent.js",
-  "files": ["bin", "dist", "README.md"],
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
   "scripts": {
     "dev": "tsx watch src/agent.ts",
     "build": "tsc",
     "build:publish": "tsup",
+    "prepublishOnly": "tsup",
     "start": "node dist/agent.js",
     "test": "vitest run",
     "test:watch": "vitest"