@polderlabs/bizar 6.2.5 → 7.0.0

package/bizar-dash/src/server/bg-retry.mjs

@@ -1,32 +1,23 @@
 /**
  * src/server/bg-retry.mjs
  *
- * v3.11.0 — Periodic recovery for background-agent instances stuck
+ * v6.3.0 — Periodic recovery for background-agent instances stuck
  * in `dispatchPending: true` with `toolCallCount === 0`.
  *
  * Why this exists:
- *   Before v3.11.0, the task delegator's
- *   `dispatchToBackground(main, subtasks, …)` short-circuited when
- *   `pingClineServe()` returned false. The bg state file was
- *   written with `dispatchPending: true` and a tmux session was
- *   never created. The only recovery path was the user manually
- *   hitting `POST /api/tasks/:id/start` (or restarting the
- *   dashboard). The user's "home folder project" got stuck this way
- *   with 7 instances in `dispatchPending: true` — 6 from a Jun 19
- *   E2E test fixture and 1 active (`bgr_738FFSKMAT5SP58SVF5HQW`,
- *   "Install vLLM as a Python package").
+ *   Before v6.3.0, the task delegator's `dispatchToBackground` would
+ *   short-circuit when `pingClaudeSdk()` returned false and the
+ *   `claude` binary wasn't on PATH. The bg state file was written
+ *   with `dispatchPending: true` and the actual spawn never happened.
+ *   The only recovery path was the user manually hitting
+ *   `POST /api/tasks/:id/start` (or restarting the dashboard).
  *
  * What this module does:
  *   - On a 30s timer, walk every bg state file under BG_DIRS.
  *   - For any instance whose `dispatchPending === true` AND
  *     `toolCallCount === 0` AND `startedAt` is older than the
- *     30-second grace window, attempt to re-dispatch by:
- *       1. Reading serve-info (the v3.11.0 fix makes this lenient).
- *       2. POSTing `/api/session` to the cline serve child.
- *       3. POSTing `/api/session/{id}/prompt` with the recorded
- *          prompt.
- *       4. Wrapping the agent run in a tmux session via
- *          `backgroundStore.spawnTmuxFor`.
+ *     30-second grace window, attempt to re-dispatch by spawning
+ *     `claude -p "<prompt>"` via `claude-runner.mjs`.
  *   - On success, clear `dispatchPending`, persist the real
  *     `sessionId`, bump `lastActivityAt`, and write the file back
  *     atomically.
@@ -49,9 +40,6 @@
  *     non-existent) tmux session — `spawnTmuxFor` already handles
  *     pre-existing sessions via its `note: 'session already existed'`
  *     return path.
- *   - The cline plugin's own bg state. The retry only writes the
- *     dashboard's view of the bg instance. The plugin will pick up
- *     the new dispatch on its next `GET /api/session` poll.
  */
 
 import {
@@ -66,18 +54,13 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 
 import { backgroundStore } from './background-store.mjs';
-import {
-  readServeInfo,
-  pingClineServe,
-  createClineSession,
-  sendClinePrompt,
-} from './serve-info.mjs';
 import { tasksStore } from './tasks-store.mjs';
 import {
   deriveAbsoluteBgLogPath,
   isBrokenBgLogPath,
   getActualBgLogPath,
 } from './lib/path-safe.mjs';
+import { spawnAgent } from './claude-runner.mjs';
 
 const HOME = homedir();
 
@@ -144,15 +127,7 @@ function findBgFile(instanceId) {
  *   - `retryCount < MAX_DISPATCH_RETRIES` (we don't retry past cap)
  *   - The instance is "stuck": either `dispatchPending === true`,
  *     OR `sessionId` is missing/empty (a sentinel for "spawn never
- *     returned an cline session"). The user's actual stuck
- *     `bgr_738FFSKMAT5SP58SVF5HQW.json` does NOT have a
- *     `dispatchPending` field — it was written by the cline
- *     plugin itself, not by the dashboard's task-delegator, so
- *     its stuckness is encoded as `sessionId: ""` instead.
- *
- * @param {object} inst
- * @param {number} now
- * @returns {boolean}
+ *     returned a Claude Code session").
  */
 export function shouldRetryDispatch(inst, now = Date.now()) {
   if (!inst || typeof inst !== 'object') return false;
@@ -165,9 +140,6 @@ export function shouldRetryDispatch(inst, now = Date.now()) {
   const startedAt = typeof inst.startedAt === 'number' ? inst.startedAt : 0;
   if (startedAt <= 0) return false;
   if (now - startedAt < DISPATCH_GRACE_MS) return false;
-  // Stuckness detector — either the dashboard marked this as
-  // dispatchPending, OR the plugin wrote an empty sessionId
-  // (meaning the cline session was never created).
   const sessionId = inst.sessionId;
   const emptySession = sessionId === null || sessionId === undefined || sessionId === '';
   if (inst.dispatchPending !== true && !emptySession) return false;
@@ -175,16 +147,7 @@ export function shouldRetryDispatch(inst, now = Date.now()) {
 }
 
 /**
- * Repair a bg instance's `logPath` if it is missing or broken
- * (empty / not absolute / contains `//`). The plugin writes the
- * logPath as `${worktree}/.cline/log/<id>.log` — when worktree
- * was missing, the resulting path becomes `//.cline/log/<id>.log`
- * and is unusable. We rebuild from a sane source: serve.json's
- * `worktree` first, then the instance's existing worktree field,
- * then `~/.cache/bizar/logs` as the last-resort fallback.
- *
- * @param {object} inst
- * @returns {{ repaired: boolean, logPath: string }}
+ * Repair a bg instance's `logPath` if it is missing or broken.
  */
 function repairLogPath(inst) {
   const current = inst.logPath;
@@ -192,17 +155,8 @@ function repairLogPath(inst) {
     return { repaired: false, logPath: typeof current === 'string' ? current : '' };
   }
   let worktree = '';
-  try {
-    const serve = readServeInfo();
-    if (serve && typeof serve.worktree === 'string' && serve.worktree.length > 0) {
-      worktree = serve.worktree;
-    }
-  } catch {
-    /* ignore */
-  }
-  if (!worktree && typeof inst.worktree === 'string') {
-    worktree = inst.worktree;
-  }
+  if (typeof inst.worktree === 'string') worktree = inst.worktree;
+  if (!worktree) worktree = process.cwd();
   const fixed = deriveAbsoluteBgLogPath(worktree, inst.instanceId || '');
   return { repaired: true, logPath: fixed };
 }
@@ -216,13 +170,6 @@ function repairLogPath(inst) {
  * manual-retry endpoint) can render a useful message.
  *
  * @param {string} instanceId
- * @returns {Promise<{
- *   ok: boolean,
- *   reason?: string,
- *   retryCount?: number,
- *   sessionId?: string,
- *   logPath?: string,
- * }>}
  */
 export async function retryDispatchOnce(instanceId) {
   const found = findBgFile(instanceId);
@@ -248,133 +195,78 @@ export async function retryDispatchOnce(instanceId) {
     return { ok: false, reason: 'max_retries_exceeded', retryCount };
   }
 
-  // v3.11.0 — Repair a broken logPath so the new run can write logs.
   const { repaired, logPath } = repairLogPath(inst);
 
-  // v3.11.0 — Resolve serve-info. The relaxed schema means a partial
-  // `{password, pid, port}` file is now usable: we derive baseUrl
-  // from the port and treat missing worktree as empty.
-  const serveInfo = readServeInfo();
-  if (!serveInfo) {
-    // Serve not running yet — bump retryCount but leave dispatchPending.
-    const updated = {
-      ...inst,
-      retryCount,
-      lastRetryAt: Date.now(),
-      lastActivityAt: Date.now(),
-      ...(repaired ? { logPath } : {}),
-      retryError: 'serve-info unavailable',
-    };
-    atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'serve_unavailable', retryCount };
-  }
-
-  const reachable = await pingClineServe(serveInfo);
-  if (!reachable) {
-    const updated = {
-      ...inst,
-      retryCount,
-      lastRetryAt: Date.now(),
-      lastActivityAt: Date.now(),
-      ...(repaired ? { logPath } : {}),
-      retryError: 'serve_unreachable',
-    };
-    atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'serve_unreachable', retryCount };
-  }
-
-  // Attempt the actual session creation + prompt.
-  let createRes;
-  let sendRes;
+  // Verify the Claude Code runtime is reachable.
+  let claudeAvailable = false;
   try {
-    createRes = await createClineSession(
-      serveInfo,
-      {
-        title: inst.promptPreview || `bg: ${instanceId}`,
-        agent: inst.agent || 'tyr',
-        parentID: undefined,
-      },
-      serveInfo.worktree || inst.worktree || '',
-    );
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const updated = {
-      ...inst,
-      retryCount,
-      lastRetryAt: Date.now(),
-      lastActivityAt: Date.now(),
-      ...(repaired ? { logPath } : {}),
-      retryError: `createSession threw: ${message}`,
-    };
-    atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'create_threw', retryCount };
+    const { pingClaudeSdk } = await import('./claude-sdk.mjs');
+    claudeAvailable = await pingClaudeSdk();
+  } catch {
+    claudeAvailable = false;
   }
-
-  if (!createRes.ok) {
+  if (!claudeAvailable) {
+    try {
+      const { spawnSync } = await import('node:child_process');
+      const probe = spawnSync('claude', ['-v'], { stdio: 'ignore', timeout: 1500 });
+      claudeAvailable = probe.status === 0;
+    } catch {
+      claudeAvailable = false;
+    }
+  }
+  if (!claudeAvailable) {
     const updated = {
       ...inst,
       retryCount,
       lastRetryAt: Date.now(),
       lastActivityAt: Date.now(),
       ...(repaired ? { logPath } : {}),
-      retryError: createRes.error || 'createSession failed',
+      retryError: 'claude runtime unavailable',
     };
     atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'create_failed', retryCount };
+    return { ok: false, reason: 'claude_unavailable', retryCount };
   }
 
-  const sessionId = createRes.sessionId;
+  // Spawn the Claude Code process for this bg instance.
+  let sessionId = null;
   try {
     const promptText = buildReplayPromptText(inst);
-    sendRes = await sendClinePrompt(
-      serveInfo,
-      {
-        sessionId,
-        agent: inst.agent || 'tyr',
-        text: promptText,
-      },
-      serveInfo.worktree || inst.worktree || '',
-    );
+    const dispatchWorktree = inst.worktree || process.cwd();
+    const spawnRes = await spawnAgent({
+      prompt: promptText,
+      agent: inst.agent || 'tyr',
+      worktree: dispatchWorktree,
+      logPath: repaired ? logPath : (inst.logPath || getActualBgLogPath({ sessionId: instanceId })),
+      title: `retry:${instanceId}`,
+    });
+    if (!spawnRes.ok || !spawnRes.sessionId) {
+      const updated = {
+        ...inst,
+        retryCount,
+        lastRetryAt: Date.now(),
+        lastActivityAt: Date.now(),
+        ...(repaired ? { logPath } : {}),
+        retryError: spawnRes.error || 'spawn failed',
+      };
+      atomicWriteJson(found.file, updated);
+      return { ok: false, reason: 'spawn_failed', retryCount };
+    }
+    sessionId = spawnRes.sessionId;
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
-    // Session was created but prompt failed. Mark the instance as
-    // running-with-sessionId so the operator can interact with it via
-    // cline directly; the next retry tick will re-issue the prompt
-    // only if toolCallCount stays at 0.
     const updated = {
       ...inst,
-      sessionId,
       retryCount,
       lastRetryAt: Date.now(),
       lastActivityAt: Date.now(),
-      status: 'running',
-      dispatchPending: false,
       ...(repaired ? { logPath } : {}),
-      retryError: `sendPrompt threw: ${message}`,
+      retryError: `spawn threw: ${message}`,
     };
     atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'send_threw', retryCount, sessionId };
+    return { ok: false, reason: 'spawn_threw', retryCount };
   }
 
-  if (!sendRes.ok) {
-    const updated = {
-      ...inst,
-      sessionId,
-      retryCount,
-      lastRetryAt: Date.now(),
-      lastActivityAt: Date.now(),
-      status: 'running',
-      dispatchPending: false,
-      ...(repaired ? { logPath } : {}),
-      retryError: sendRes.error || 'sendPrompt failed',
-    };
-    atomicWriteJson(found.file, updated);
-    return { ok: false, reason: 'send_failed', retryCount, sessionId };
-  }
-
-  // Success path. Re-write the instance as `running`, clear
-  // dispatchPending, refresh activity timestamps, and wrap the agent
-  // run in a tmux session (best-effort, matches `task-delegator`).
+  // Success path.
   const updated = {
     ...inst,
     sessionId,
@@ -390,15 +282,11 @@ export async function retryDispatchOnce(instanceId) {
 
   try {
     const tmuxName = `bg_${(sessionId || instanceId).slice(0, 16)}`;
-    // v3.11.1 — Bug fix: the previous code tailed `${worktree}/.cline/log/<id>.log`,
-    // a path nothing writes to. The plugin's `LogWriter` writes to
-    // `${logDir}/${sessionId}.log` (default `~/.cache/bizar/logs`).
-    // Use the real path so the operator sees activity.
     const logFile = getActualBgLogPath({ sessionId: sessionId || instanceId });
     backgroundStore.spawnTmuxFor(
       tmuxName,
       { command: 'tail', args: ['-n', '200', '-F', logFile] },
-      serveInfo.worktree || inst.worktree || undefined,
+      inst.worktree || undefined,
     );
   } catch {
     /* best-effort */
@@ -410,7 +298,6 @@ export async function retryDispatchOnce(instanceId) {
       await tasksStore.update(null, inst.taskId, {
         status: 'doing',
         metadata: {
-          ...(typeof inst.mainTaskId === 'string' ? {} : {}),
           progress: 5,
           currentStep: `Re-dispatched (${sessionId})`,
           dispatchedAt: Date.now(),
@@ -426,14 +313,7 @@ export async function retryDispatchOnce(instanceId) {
 
 /**
  * Reconstruct the prompt text for the retry from what the bg file
- * stored. The original `task-delegator.dispatchToBackground` builds
- * a multi-line prompt (`# Title`, body, `---`, IDs); we approximate
- * that here using the promptPreview + instanceId context. If the
- * upstream caller stored the full prompt in `metadata.promptText`,
- * use that; otherwise fall back to the preview.
- *
- * @param {object} inst
- * @returns {string}
+ * stored.
  */
 function buildReplayPromptText(inst) {
   const full = inst?.metadata?.promptText;
@@ -444,24 +324,23 @@ function buildReplayPromptText(inst) {
   parts.push('');
   parts.push('(Re-dispatched by the bg-retry loop — full prompt was not');
   parts.push('persisted. The dashboard recovered this instance after the');
-  parts.push('plugin was reachable. The original prompt preview is above;');
-  parts.push('if more context is required, inspect the linked task.)');
+  parts.push('Claude Code runtime was reachable. The original prompt');
+  parts.push('preview is above; if more context is required, inspect the');
+  parts.push('linked task.)');
   parts.push('');
   parts.push('---');
   parts.push(`Subtask ID: ${inst.taskId || '(unknown)'}`);
   parts.push(`Assigned agent: ${inst.agent || 'tyr'}`);
   parts.push(`Parent task ID: ${inst.mainTaskId || '(none)'}`);
   parts.push(`Instance ID: ${inst.instanceId}`);
+  parts.push(`Runtime: Claude Code (claude -p)`);
   return parts.join('\n');
 }
 
 /**
  * One pass of the retry loop. Walks every bg state file, identifies
  * candidates via `shouldRetryDispatch`, and calls `retryDispatchOnce`
- * for each. Failures are caught so a single broken file cannot
- * poison the rest of the pass.
- *
- * @returns {Promise<{ scanned: number, retried: number, succeeded: number, failed: number, skipped: number }>}
+ * for each.
  */
 export async function tickRetryLoop() {
   if (inFlightTick) {
@@ -528,9 +407,6 @@ export async function tickRetryLoop() {
 
 /**
  * Start the periodic retry loop. Idempotent.
- *
- * @param {object} [opts]
- * @param {number} [opts.intervalMs]  override the default 30s tick
  */
 export function startBgRetryLoop({ intervalMs } = {}) {
   if (intervalHandle) return { ok: true, alreadyRunning: true };
@@ -542,9 +418,6 @@ export function startBgRetryLoop({ intervalMs } = {}) {
     });
   }, ms);
   if (typeof intervalHandle.unref === 'function') intervalHandle.unref();
-  // Kick off a first tick on the next event-loop turn so the
-  // dashboard recovers any pre-existing stuck instances immediately
-  // after a restart, without waiting 30s.
   setImmediate(() => {
     tickRetryLoop().catch(() => { /* logged inside */ });
   });
@@ -570,5 +443,4 @@ export const _BG_RETRY_INTERNAL = {
   MAX_DISPATCH_RETRIES,
 };
 
-// Silence unused-import warnings for helpers used transitively.
-void mkdirSync;
+void mkdirSync;