@groupchatai/claude-runner 0.4.8 → 0.4.10

package/dist/index.js

@@ -79,7 +79,7 @@ var GroupChatAgentClient = class {
     return this.request("POST", `/runs/${runId}/comment`, { body });
   }
 };
-function buildClaudePrompt(detail) {
+function buildClaudePrompt(detail, repoResolved) {
   const parts = [];
   parts.push(`# Task: ${detail.task.title}`);
   if (detail.task.description) {
@@ -87,6 +87,19 @@ function buildClaudePrompt(detail) {
 ## Description
 ${detail.task.description}`);
   }
+  if (detail.repoUrl && !repoResolved) {
+    parts.push(
+      [
+        "\n## Repository",
+        detail.repoUrl,
+        "Check if the current working directory is already this repo (compare `git remote get-url origin`).",
+        "If not, check if it exists locally in common locations like ~/Developer, ~/Projects, ~/src, or ~.",
+        "If you find it locally, `cd` into it before starting work.",
+        "If you cannot find it locally, ask the user if they would like you to clone it and where.",
+        "Do NOT clone without the user's confirmation."
+      ].join("\n")
+    );
+  }
   if (detail.prompt && detail.prompt !== detail.task.title) {
     parts.push(`
 ## Instructions
@@ -114,6 +127,14 @@ ${comment.body}`
       );
     }
   }
+  if (detail.lastFollowUpMessage) {
+    parts.push(
+      `
+## Latest Follow-up Request
+The user has sent a follow-up message. Address this:
+${detail.lastFollowUpMessage}`
+    );
+  }
   const existingPrUrl = detail.pullRequestUrl ?? detail.task.pullRequestUrl;
   if (existingPrUrl) {
     parts.push(`
@@ -600,6 +621,14 @@ function runShellCommand(cmd, args, cwd) {
   });
 }
 var sessionCache = /* @__PURE__ */ new Map();
+var activeProcesses = /* @__PURE__ */ new Map();
+var stoppedRunIds = /* @__PURE__ */ new Set();
+function stopActiveProcess(runId) {
+  const child = activeProcesses.get(runId);
+  if (!child || child.killed) return;
+  stoppedRunIds.add(runId);
+  child.kill("SIGINT");
+}
 var runCounter = 0;
 var claudeRunnerSignalTeardownDone = false;
 function tryBeginClaudeRunnerSignalTeardown() {
@@ -904,18 +933,35 @@ function truncateClaudeDebugString(text) {
     truncated: true
   };
 }
-async function processRun(client, run, config, worktreeDir, detail) {
+async function processRun(client, run, config, worktreeDir, detail, runBaseDir, repoFound) {
   const runNum = ++runCounter;
   const runTag = `  ${C.pid}[${runNum}]${C.reset}`;
   const log = (msg) => console.log(`${runTag} ${msg}`);
   const logGreen = (msg) => console.log(`${runTag} ${C.green}${msg}${C.reset}`);
   const ownerName = run.owner?.name ?? detail.owner?.name ?? "unknown";
   log(`\u{1F4CB} "${run.taskTitle}" \u2014 delegated by ${ownerName}`);
+  if (config.verbose) {
+    log(`\u{1F4CE} Run ID: ${run.id} | Task ID: ${run.taskId}`);
+    log(
+      `\u{1F4CE} Detail status: ${detail.status} | Has lastFollowUpMessage: ${!!detail.lastFollowUpMessage} | Has lastSessionId: ${!!detail.lastSessionId}`
+    );
+    log(
+      `\u{1F4CE} In-memory session cache hit: ${sessionCache.has(run.taskId)} | Activity items: ${detail.activity.length}`
+    );
+    if (detail.lastFollowUpMessage) {
+      log(
+        `\u{1F4CE} lastFollowUpMessage: "${detail.lastFollowUpMessage.slice(0, 150)}${detail.lastFollowUpMessage.length > 150 ? "\u2026" : ""}"`
+      );
+    }
+    if (detail.lastSessionId) {
+      log(`\u{1F4CE} Server lastSessionId: ${detail.lastSessionId.slice(0, 12)}\u2026`);
+    }
+  }
   if (detail.status !== "PENDING") {
     log(`\u23ED  Run is no longer PENDING (now ${detail.status}), skipping.`);
     return;
   }
-  const prompt = buildClaudePrompt(detail);
+  const prompt = buildClaudePrompt(detail, !!repoFound);
   if (config.dryRun) {
     log("\u{1F3DC}  DRY RUN \u2014 would execute Claude Code with prompt:");
     console.log("---");
@@ -937,7 +983,7 @@ async function processRun(client, run, config, worktreeDir, detail) {
     throw err;
   }
   log("\u25B6  Run started");
-  const effectiveCwd = worktreeDir ?? config.workDir;
+  const effectiveCwd = worktreeDir ?? runBaseDir ?? config.workDir;
   let lastClaude = {
     stderr: "",
     stdout: "",
@@ -954,16 +1000,43 @@ async function processRun(client, run, config, worktreeDir, detail) {
       });
       await new Promise((resolve) => git.on("close", () => resolve()));
     }
-    const cachedSessionId = sessionCache.get(run.taskId);
+    const cachedSessionId = sessionCache.get(run.taskId) ?? detail.lastSessionId;
     const isFollowUp = cachedSessionId !== void 0;
-    const effectivePrompt = isFollowUp ? detail.prompt : prompt;
+    let effectivePrompt;
+    if (isFollowUp && detail.lastFollowUpMessage) {
+      effectivePrompt = detail.lastFollowUpMessage;
+    } else if (isFollowUp) {
+      effectivePrompt = prompt;
+    } else {
+      effectivePrompt = prompt;
+    }
     const resumeSession = isFollowUp ? cachedSessionId : void 0;
     if (config.verbose) {
       if (isFollowUp) {
-        log(`\u{1F504} Resuming session ${cachedSessionId.slice(0, 12)}\u2026`);
+        const sessionSource = sessionCache.has(run.taskId) ? "in-memory cache" : "server (lastSessionId)";
+        log(`\u{1F504} Resuming session ${cachedSessionId.slice(0, 12)}\u2026 (source: ${sessionSource})`);
+        if (detail.lastFollowUpMessage) {
+          log(
+            `\u{1F4AC} Follow-up message: "${detail.lastFollowUpMessage.slice(0, 200)}${detail.lastFollowUpMessage.length > 200 ? "\u2026" : ""}"`
+          );
+        } else {
+          log(`\u26A0  No lastFollowUpMessage found \u2014 using full prompt for resumed session`);
+        }
+      } else {
+        log(`\u{1F195} Initial run (no session to resume)`);
       }
-      log(`\u{1F4DD} Prompt (${effectivePrompt.length} chars)`);
+      log(
+        `\u{1F4DD} Prompt (${effectivePrompt.length} chars)${isFollowUp ? " [follow-up]" : " [initial]"}`
+      );
+      const previewLen = 500;
+      log(
+        `\u{1F4DD} Prompt preview:
+${effectivePrompt.slice(0, previewLen)}${effectivePrompt.length > previewLen ? "\n... (truncated)" : ""}`
+      );
       if (effectiveModel) log(`\u{1F9E0} Model: ${effectiveModel}`);
+      log(
+        `\u{1F4CA} Activity items: ${detail.activity.length}, Comments: ${detail.activity.filter((a) => a.type === "comment").length}`
+      );
     }
     const { process: child, output } = spawnClaudeCode(
       effectivePrompt,
@@ -973,8 +1046,19 @@ async function processRun(client, run, config, worktreeDir, detail) {
       effectiveCwd
     );
     log(`\u{1F916} Claude Code spawned (pid ${child.pid})${isFollowUp ? " (follow-up)" : ""}`);
+    activeProcesses.set(run.id, child);
+    if (stoppedRunIds.has(run.id)) {
+      child.kill("SIGINT");
+    }
     let { stdout, rawOutput, stderr, exitCode, sessionId, streamPrUrl } = await output;
+    activeProcesses.delete(run.id);
     lastClaude = { stderr, stdout, rawOutput, exitCode, sessionId };
+    if (stoppedRunIds.has(run.id)) {
+      stoppedRunIds.delete(run.id);
+      if (sessionId) sessionCache.set(run.taskId, sessionId);
+      log(`\u{1F6D1} Run stopped from UI`);
+      return;
+    }
     if (exitCode !== 0 && isFollowUp) {
       log(`\u26A0  Session resume failed, retrying with fresh session\u2026`);
       sessionCache.delete(run.taskId);
@@ -985,6 +1069,9 @@ async function processRun(client, run, config, worktreeDir, detail) {
     }
     if (sessionId) {
       sessionCache.set(run.taskId, sessionId);
+      if (config.verbose) {
+        log(`\u{1F4BE} Session ${sessionId.slice(0, 12)}\u2026 cached for task ${run.taskId}`);
+      }
     }
     const pullRequestUrl = streamPrUrl ?? await detectPullRequestUrl(effectiveCwd) ?? extractPullRequestUrlFromOutput(stdout) ?? extractPullRequestUrlFromOutput(rawOutput);
     const streamEvents = parseClaudeNdjsonEvents(rawOutput);
@@ -1019,7 +1106,8 @@ async function processRun(client, run, config, worktreeDir, detail) {
       await client.errorRun(run.id, errorMsg, {
         pullRequestUrl,
         errorType: retryInfo?.errorType,
-        retryAfter: retryInfo?.retryAfterMs
+        retryAfter: retryInfo?.retryAfterMs,
+        sessionId: lastClaude.sessionId
       });
       if (retryInfo) {
         const retryAt = new Date(retryInfo.retryAfterMs).toLocaleString(void 0, {
@@ -1050,7 +1138,11 @@ async function processRun(client, run, config, worktreeDir, detail) {
     }
     const resultText = extractResultText(stdout);
     const cost = extractCost(stdout);
-    await client.completeRun(run.id, resultText, { ...cost, pullRequestUrl });
+    await client.completeRun(run.id, resultText, {
+      ...cost,
+      pullRequestUrl,
+      sessionId: lastClaude.sessionId
+    });
     if (pullRequestUrl) logGreen(`\u{1F517} PR: ${pullRequestUrl}`);
     logGreen(`\u2705 Run completed`);
   } catch (err) {
@@ -1082,7 +1174,7 @@ async function processRun(client, run, config, worktreeDir, detail) {
 ${message.slice(0, 2e3)}
 \`\`\``;
     try {
-      await client.errorRun(run.id, errorBody);
+      await client.errorRun(run.id, errorBody, { sessionId: lastClaude.sessionId });
     } catch {
       log(`${C.dim}\u26A0  Failed to report error to API${C.reset}`);
     }
@@ -1113,6 +1205,66 @@ function loadEnvFile() {
     }
   }
 }
+var repoRegistry = /* @__PURE__ */ new Map();
+function normalizeRepoUrl(url) {
+  return url.replace(/\.git$/, "").replace(/^git@github\.com:/, "https://github.com/").toLowerCase();
+}
+function gitRemoteUrl(dir) {
+  try {
+    return execFileSync("git", ["remote", "get-url", "origin"], {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: "pipe"
+    }).trim();
+  } catch {
+    return void 0;
+  }
+}
+function dirMatchesRepo(dir, repoUrl) {
+  const remote = gitRemoteUrl(dir);
+  if (!remote) return false;
+  return normalizeRepoUrl(remote) === normalizeRepoUrl(repoUrl);
+}
+function scanForRepo(repoUrl) {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  if (!home) return void 0;
+  const searchDirs = ["Developer", "Projects", "src", "dev", "code", "repos"].map(
+    (d) => path.join(home, d)
+  );
+  for (const searchDir of searchDirs) {
+    let entries;
+    try {
+      entries = readdirSync(searchDir);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const candidate = path.join(searchDir, entry);
+      try {
+        if (!statSync(candidate).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (dirMatchesRepo(candidate, repoUrl)) return candidate;
+    }
+  }
+  return void 0;
+}
+function resolveRepoCwd(repoUrl, currentWorkDir) {
+  const cached = repoRegistry.get(normalizeRepoUrl(repoUrl));
+  if (cached) return cached;
+  if (dirMatchesRepo(currentWorkDir, repoUrl)) {
+    repoRegistry.set(normalizeRepoUrl(repoUrl), currentWorkDir);
+    return currentWorkDir;
+  }
+  const found = scanForRepo(repoUrl);
+  if (found) {
+    repoRegistry.set(normalizeRepoUrl(repoUrl), found);
+    return found;
+  }
+  return void 0;
+}
 function getRunnerPackageInfo() {
   try {
     const here = path.dirname(fileURLToPath(import.meta.url));
@@ -1327,12 +1479,21 @@ async function processRunWithDrain(client, run, scheduler, config) {
     drainSchedulerSlot(scheduler, run);
     return;
   }
+  let runBaseDir = config.workDir;
+  let repoFound = false;
+  if (detail.repoUrl) {
+    const resolved = resolveRepoCwd(detail.repoUrl, config.workDir);
+    if (resolved) {
+      runBaseDir = resolved;
+      repoFound = true;
+    }
+  }
   let worktreeDir;
-  if (config.useWorktrees) {
+  if (config.useWorktrees && (!detail.repoUrl || repoFound)) {
     try {
-      const existingBranch = await resolveExistingPrBranch(detail, config.workDir);
-      worktreeDir = createWorktree(config.workDir, run.taskId, existingBranch);
-      const rel = path.relative(config.workDir, worktreeDir);
+      const existingBranch = await resolveExistingPrBranch(detail, runBaseDir);
+      worktreeDir = createWorktree(runBaseDir, run.taskId, existingBranch);
+      const rel = path.relative(runBaseDir, worktreeDir);
       if (existingBranch) {
         console.log(`  \u{1F333} Worktree from existing PR branch ${existingBranch} \u2192 ${rel}`);
       } else {
@@ -1346,7 +1507,7 @@ async function processRunWithDrain(client, run, scheduler, config) {
   let currentDetail = detail;
   while (current) {
     try {
-      await processRun(client, current, config, worktreeDir, currentDetail);
+      await processRun(client, current, config, worktreeDir, currentDetail, runBaseDir, repoFound);
     } catch (err) {
       console.error(`Unhandled error processing run ${current.id}:`, err);
     }
@@ -1363,14 +1524,19 @@ async function processRunWithDrain(client, run, scheduler, config) {
     }
   }
   if (worktreeDir) {
-    sessionCache.delete(run.taskId);
     try {
-      removeWorktreeSimple(config.workDir, worktreeDir);
+      removeWorktreeSimple(runBaseDir, worktreeDir);
       console.log(`  \u{1F9F9} Worktree cleaned up`);
     } catch (err) {
       console.error(`  \u26A0  Failed to clean up worktree:`, err);
     }
   }
+  if (detail.repoUrl && !repoFound) {
+    const found = resolveRepoCwd(detail.repoUrl, config.workDir);
+    if (found) {
+      console.log(`  \u{1F4C2} Repo cached for future runs: ${found}`);
+    }
+  }
 }
 async function runWithWebSocket(client, config, scheduler) {
   let ConvexClient;
@@ -1395,6 +1561,30 @@ async function runWithWebSocket(client, config, scheduler) {
       handlePendingRuns(runs, scheduler, client, config);
     }
   );
+  let stoppedRunsWarned = false;
+  convex.onUpdate(
+    anyApi.agentWebSocket.stoppedRuns,
+    { token: config.token },
+    (runIds) => {
+      if (!runIds) return;
+      for (const runId of runIds) {
+        if (activeProcesses.has(runId)) {
+          console.log(`  \u{1F6D1} Run stopped from UI \u2014 sending stop signal to Claude Code\u2026`);
+          stopActiveProcess(runId);
+        }
+      }
+    },
+    () => {
+      if (!stoppedRunsWarned) {
+        stoppedRunsWarned = true;
+        if (config.verbose) {
+          console.log(
+            `${C.dim}\u2139  stoppedRuns query not available on server \u2014 stop-from-UI disabled${C.reset}`
+          );
+        }
+      }
+    }
+  );
   await new Promise((resolve) => {
     function shutdown() {
       if (!tryBeginClaudeRunnerSignalTeardown()) return;
@@ -1444,6 +1634,16 @@ async function runWithPolling(client, config, scheduler) {
     return;
   }
   while (running) {
+    for (const runId of activeProcesses.keys()) {
+      try {
+        const detail = await client.getRunDetail(runId);
+        if (detail.status === "STOPPED") {
+          console.log(`  \u{1F6D1} Run stopped from UI \u2014 sending stop signal to Claude Code\u2026`);
+          stopActiveProcess(runId);
+        }
+      } catch {
+      }
+    }
     try {
       const pending = await client.listPendingRuns();
       handlePendingRuns(pending, scheduler, client, config);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groupchatai/claude-runner",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Run GroupChat AI agent tasks locally with Claude Code",
   "type": "module",
   "bin": {