@groupchatai/claude-runner 0.4.8 → 0.4.9

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
@@ -600,6 +613,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,7 +925,7 @@ 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}`);
@@ -915,7 +936,7 @@ async function processRun(client, run, config, worktreeDir, detail) {
     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 +958,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: "",
@@ -973,8 +994,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);
@@ -1113,6 +1145,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 +1419,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 +1447,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 +1464,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 +1501,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 +1574,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.9",
   "description": "Run GroupChat AI agent tasks locally with Claude Code",
   "type": "module",
   "bin": {