+
▸ run {e.status} (exit {e.exitCode ?? '?'})
)
diff --git a/src/components/RunHistory.tsx b/src/components/RunHistory.tsx
index 32163cb..288f89f 100644
--- a/src/components/RunHistory.tsx
+++ b/src/components/RunHistory.tsx
@@ -111,7 +111,7 @@ function RunRow({
const status = run.status
const exit = run.exitCode
const statusColor =
- status === 'running'
+ status === 'running' || status === 'cancelled'
? 'text-amber-400'
: exit === 0
? 'text-green-500'
diff --git a/src/lib/claude.ts b/src/lib/claude.ts
index 1ca1ea8..d452f6c 100644
--- a/src/lib/claude.ts
+++ b/src/lib/claude.ts
@@ -31,6 +31,13 @@ export type AgentRunOptions = {
systemPrompt?: string
model?: string | null
skills?: string[]
+ /**
+ * Called once with the freshly spawned child process. The caller can
+ * use this to register the process in a kill-from-elsewhere registry
+ * (so a Stop button on a parallel pane can SIGTERM this run). The
+ * child is unspecified if spawn itself fails before this callback.
+ */
+ onChild?: (child: ChildProcessWithoutNullStreams) => void
}
/**
@@ -93,6 +100,11 @@ export async function* runAgent(opts: AgentRunOptions) {
child = spawn('claude', args, {
cwd: opts.cwd,
env: { ...process.env },
+ // detached:true puts the child in its own process group. SIGTERM
+ // sent to -pid then kills the whole group, including any tool
+ // subprocesses claude spawned. We still wait for the child in the
+ // current process, so the OS treats this as a regular child.
+ detached: true,
})
} catch (err) {
yield {
@@ -102,6 +114,7 @@ export async function* runAgent(opts: AgentRunOptions) {
yield { type: 'exit', code: 1 }
return
}
+ if (opts.onChild) opts.onChild(child)
// Forward stdout as JSONL events. Buffer partial lines across
// chunks so we never yield half a JSON object.
diff --git a/src/lib/run-registry.ts b/src/lib/run-registry.ts
new file mode 100644
index 0000000..342e335
--- /dev/null
+++ b/src/lib/run-registry.ts
@@ -0,0 +1,67 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process'
+
+/**
+ * Process-local registry mapping runId -> the child process spawned
+ * for that run. Used by the Stop endpoint to find and SIGTERM a run
+ * that was started in a different request.
+ *
+ * In-memory only, single process. A `next start` worker restart drops
+ * the map and any leftover process becomes an orphan (cleaned up by
+ * the OS or by exiting on its own). Good enough for a local single-
+ * user app; revisit if Argus ever runs multi-process.
+ *
+ * Cached on globalThis so Next.js dev's module hot reload doesn't
+ * silently fork the map.
+ */
+
+declare global {
+ // eslint-disable-next-line no-var
+ var __argus_run_registry: Map
| undefined
+}
+
+const registry: Map =
+ globalThis.__argus_run_registry ??
+ (globalThis.__argus_run_registry = new Map())
+
+export function registerRun(
+ runId: string,
+ child: ChildProcessWithoutNullStreams,
+): void {
+ registry.set(runId, child)
+ // Auto-clean when the process exits, so the map doesn't grow forever
+ // and so a Stop request after a natural exit just no-ops cleanly.
+ child.once('exit', () => {
+ if (registry.get(runId) === child) registry.delete(runId)
+ })
+}
+
+export function unregisterRun(runId: string): void {
+ registry.delete(runId)
+}
+
+export function isRunning(runId: string): boolean {
+ return registry.has(runId)
+}
+
+/**
+ * SIGTERM the run's process group. Returns true if a process was
+ * found and signaled, false if there's nothing to kill (already
+ * exited, never registered, etc).
+ *
+ * Targets `-pid` (negative) so the signal hits the whole process group
+ * the child was placed into (see detached:true on spawn). That kills
+ * any tool subprocesses claude itself started.
+ */
+export function killRun(runId: string): boolean {
+ const child = registry.get(runId)
+ if (!child || child.pid == null) return false
+ try {
+ process.kill(-child.pid, 'SIGTERM')
+ return true
+ } catch {
+ // Process already gone or signal not permitted; either way, drop
+ // it from the map so we don't try again.
+ registry.delete(runId)
+ return false
+ }
+}