@polderlabs/bizar 6.2.5 → 6.3.0

package/bizar-dash/src/server/claude-sdk.mjs

@@ -0,0 +1,191 @@
+/**
+ * src/server/claude-sdk.mjs
+ *
+ * v6.3.0 — Dashboard-side wrapper around the Claude Code Agent SDK
+ * (`@anthropic-ai/claude-agent-sdk`).
+ *
+ * Replaces cline-sdk.mjs (the legacy wrapper around
+ * `@polderlabs/bizar-sdk/cline`). Claude Code's SDK is an in-process
+ * library: it exposes `query()` for one-shot prompts and
+ * `ClaudeSDKClient` for streaming sessions. There is no equivalent
+ * of cline's `serve` subprocess — Claude Code runs in-process by
+ * default.
+ *
+ * Public surface:
+ *   - `getClaudeSdk()`           — returns the SDK module or `null`
+ *                                   if not installed (so callers can
+ *                                   degrade gracefully).
+ *   - `getClaudeSdkOrThrow()`    — same, but throws when missing.
+ *   - `subscribeToSession(id)`   — wraps `ClaudeSDKClient.subscribe()`
+ *                                   for streaming a session's events.
+ *   - `pingClaudeSdk()`          — quick health probe; uses a short
+ *                                   `query()` against `--model haiku`
+ *                                   to verify the SDK is reachable.
+ *
+ * Storage location for Claude Code sessions:
+ *   - Sessions live at `~/.claude/sessions/<sessionId>/` with the
+ *     conversation as `messages.jsonl`. This module does not own
+ *     that directory — Claude Code writes it directly. We read it
+ *     when callers ask for `listClaudeSessions` / `listClaudeMessages`.
+ *
+ * Environment:
+ *   - Claude Code reads API keys from the environment
+ *     (`ANTHROPIC_API_KEY` or the OAuth flow). We do NOT need to
+ *     build an `Authorization: Basic base64("cline:<password>")`
+ *     header — Claude Code handles authentication itself.
+ */
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+let _sdk = null;
+/** @type {Promise<any> | null} */
+let _sdkPromise = null;
+
+const HOME = homedir();
+const CLAUDE_SESSIONS_DIR = join(HOME, '.claude', 'sessions');
+
+/**
+ * Lazily import the Claude Code Agent SDK. Returns the module on
+ * success and `null` if the package is not installed (so callers can
+ * fall back to subprocess execution via claude-runner.mjs).
+ *
+ * The result is cached so subsequent calls are synchronous.
+ *
+ * @returns {Promise<any | null>}
+ */
+export async function getClaudeSdk() {
+  if (_sdk) return _sdk;
+  if (_sdkPromise) return _sdkPromise;
+  _sdkPromise = (async () => {
+    try {
+      const mod = await import('@anthropic-ai/claude-agent-sdk');
+      _sdk = mod;
+      return mod;
+    } catch {
+      // SDK package not installed — caller should use the
+      // subprocess fallback in claude-runner.mjs.
+      _sdk = null;
+      return null;
+    } finally {
+      _sdkPromise = null;
+    }
+  })();
+  return _sdkPromise;
+}
+
+/**
+ * Same as {@link getClaudeSdk} but throws when the SDK isn't
+ * available. Use this from code paths that REQUIRE the in-process
+ * SDK (e.g. callers that want typed event streams rather than the
+ * JSONL subprocess path).
+ *
+ * @returns {Promise<any>}
+ */
+export async function getClaudeSdkOrThrow() {
+  const sdk = await getClaudeSdk();
+  if (!sdk) {
+    throw new Error(
+      'claude_sdk_unavailable: @anthropic-ai/claude-agent-sdk is not installed. ' +
+        'Run `npm install @anthropic-ai/claude-agent-sdk` at the repo root, ' +
+        'or use the subprocess path (claude-runner.mjs).',
+    );
+  }
+  return sdk;
+}
+
+/**
+ * Subscribe to a Claude Code session's event stream. Thin wrapper
+ * around `ClaudeSDKClient.subscribe({ sessionId })`.
+ *
+ * Returns `{ stream, close }` — `stream` is an `AsyncIterable` of
+ * typed event envelopes; `close()` aborts the underlying subscription.
+ *
+ * Returns `null` when the SDK is unavailable or the session id is
+ * missing — callers should fall back to the JSONL tailing path in
+ * `claude-sessions.mjs`.
+ *
+ * @param {string} sessionId
+ * @returns {Promise<AsyncIterable<unknown> & { close: () => void } | null>}
+ */
+export async function subscribeToSession(sessionId) {
+  if (!sessionId) return null;
+  const sdk = await getClaudeSdk();
+  if (!sdk || typeof sdk.subscribe !== 'function') return null;
+  try {
+    const sub = await sdk.subscribe({ sessionId });
+    return sub;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Quick liveness probe for the Claude Code SDK. Performs a tiny
+ * `query()` call against `haiku` and waits up to 1.5s for the
+ * response. Returns `true` on any successful response, `false`
+ * otherwise.
+ *
+ * Used by the dashboard's /api/health endpoint and by callers that
+ * want to decide between the in-process SDK and the subprocess
+ * fallback.
+ *
+ * @returns {Promise<boolean>}
+ */
+export async function pingClaudeSdk() {
+  const sdk = await getClaudeSdk();
+  if (!sdk || typeof sdk.query !== 'function') return false;
+  try {
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), 1500);
+    try {
+      const stream = sdk.query({
+        prompt: 'ping',
+        options: { model: 'haiku', maxTurns: 1, permissionMode: 'plan' },
+      });
+      // Drain the first event or the abort signal — either proves
+      // the SDK is reachable.
+      const result = await Promise.race([
+        stream[Symbol.asyncIterator]().next().then(() => true),
+        new Promise((resolve) => {
+          ac.signal.addEventListener('abort', () => resolve(false));
+        }),
+      ]);
+      // Best-effort close of the stream.
+      try { await stream.close?.(); } catch { /* ignore */ }
+      return Boolean(result);
+    } finally {
+      clearTimeout(timer);
+      ac.abort();
+    }
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Return the canonical on-disk directory for Claude Code sessions.
+ * Useful for callers that need to enumerate `messages.jsonl` files
+ * directly (e.g. listing historical messages for a session).
+ *
+ * @returns {string}
+ */
+export function claudeSessionsDir() {
+  return CLAUDE_SESSIONS_DIR;
+}
+
+/**
+ * Best-effort check that the Claude Code session directory exists
+ * (or its parent does). Lets callers fall back to "no sessions yet"
+ * rather than throwing when the user has never run `claude`.
+ *
+ * @returns {boolean}
+ */
+export function claudeSessionsDirExists() {
+  try {
+    return existsSync(CLAUDE_SESSIONS_DIR) || existsSync(join(HOME, '.claude'));
+  } catch {
+    return false;
+  }
+}

package/bizar-dash/src/server/providers-store.mjs

@@ -1074,58 +1074,31 @@ export const providersStore = {
       /* best-effort */
     }
 
-    // Source 3: cline serve HTTP API
+    // Source 3: claude CLI probe. v6.3.0 — Claude Code has no
+    // equivalent of the old cline serve HTTP API. Instead we
+    // ping `claude -v` to confirm the runtime is reachable and,
+    // if so, surface it as a "claude-cli" provider entry with the
+    // models Claude Code natively supports.
     try {
-      const { readServeInfo } = await import('./serve-info.mjs');
-      const info = readServeInfo();
-      if (info && info.baseUrl) {
-        const auth = 'Basic ' + Buffer.from(`cline:${info.password || ''}`).toString('base64');
-        const ctrl = new AbortController();
-        const timer = setTimeout(() => ctrl.abort(), 1500);
-        try {
-          const resp = await fetch(`${info.baseUrl}/api/providers`, {
-            headers: { Authorization: auth },
-            signal: ctrl.signal,
-          });
-          if (resp.ok) {
-            const body = await resp.json().catch(() => null);
-            const list = Array.isArray(body?.providers)
-              ? body.providers
-              : Array.isArray(body?.data)
-              ? body.data
-              : Array.isArray(body)
-              ? body
-              : [];
-            for (const p of list) {
-              if (!p || typeof p !== 'object') continue;
-              const id = p.id || p.name;
-              if (!id) continue;
-              const models = (Array.isArray(p.models) ? p.models : []).map((m) => {
-                if (typeof m === 'string') return { id: m, name: m };
-                return {
-                  id: m.id || m.name || String(m),
-                  name: m.name || m.id || String(m),
-                };
-              });
-              upsert(
-                id,
-                {
-                  name: p.name || id,
-                  baseURL: p.baseURL || '',
-                  models,
-                },
-                'serve',
-              );
-            }
-          }
-        } catch {
-          /* serve unreachable — fall through */
-        } finally {
-          clearTimeout(timer);
-        }
+      const { spawnSync } = await import('node:child_process');
+      const probe = spawnSync('claude', ['-v'], { stdio: 'ignore', timeout: 1500 });
+      if (probe.status === 0) {
+        upsert(
+          'claude-cli',
+          {
+            name: 'Claude Code CLI',
+            baseURL: '',
+            models: [
+              { id: 'claude-opus-4', name: 'Claude Opus 4' },
+              { id: 'claude-sonnet-4', name: 'Claude Sonnet 4' },
+              { id: 'claude-haiku-4', name: 'Claude Haiku 4' },
+            ],
+          },
+          'cli',
+        );
       }
     } catch {
-      /* best-effort */
+      /* claude CLI unreachable — fall through */
     }
 
     return Array.from(byId.values()).sort((a, b) => a.id.localeCompare(b.id));

package/bizar-dash/src/server/routes/background.mjs

@@ -14,10 +14,12 @@
  * /api/background/:id/retry (POST)         — manual unstick (v3.11.0)
  * /api/background/:id (DELETE)             — kill
  *
- * Backed by the cline-plugin's bg instance store. Imports the
- * store lazily so this module loads even when the plugin is offline.
+ * Backed by the bg instance store at `~/.cache/bizar/bg/<id>.json`.
+ * Imports the store lazily so this module loads even when the Claude
+ * Code CLI is offline.
  *
- * v5.5.1: the spawner is now SDK-based (see ../bg-spawner.mjs).
+ * v6.3.0: the spawner is now Claude-Code-based (see
+ * ../claude-bg-spawner.mjs).
  * `POST /api/background/:id/steer` performs a true mid-flight prompt
  * (no kill+respawn); the response shape stays backwards compatible with
  * the v5.5.0 contract except `newInstanceId` is `null` (same instance
@@ -34,9 +36,10 @@ import { wrap } from './_shared.mjs';
 export function createBackgroundRouter({ broadcast }) {
   const router = Router();
 
-  // Wire bg-spawner's broadcast so spawned agents broadcast on the
-  // existing WS bus (mirroring the way `bg-poller.mjs` does it).
-  import('../bg-spawner.mjs').then((m) => {
+  // Wire claude-bg-spawner's broadcast so spawned agents broadcast
+  // on the existing WS bus (mirroring the way `bg-poller.mjs` does
+  // it).
+  import('../claude-bg-spawner.mjs').then((m) => {
     if (m && typeof m.configureSpawner === 'function') {
       m.configureSpawner({ broadcast });
     }
@@ -71,7 +74,7 @@ export function createBackgroundRouter({ broadcast }) {
     const tags = Array.isArray(body.tags)
       ? body.tags.filter((t) => typeof t === 'string').slice(0, 10)
       : undefined;
-    const { spawnBgAgent } = await import('../bg-spawner.mjs');
+    const { spawnBgAgent } = await import('../claude-bg-spawner.mjs');
     const result = await spawnBgAgent({
       agent,
       prompt,
@@ -114,9 +117,9 @@ export function createBackgroundRouter({ broadcast }) {
   }));
 
   // v5.x — Tool-call history. The state file carries a `toolCalls`
-  // array populated by the plugin's InstanceManager as it observes
-  // cline events. This endpoint is read-only; the plugin owns the
-  // shape.
+  // array populated by claude-bg-spawner.mjs as it observes
+  // Claude Code events. This endpoint is read-only; the spawner
+  // owns the shape.
   router.get('/background/:id/tool-calls', wrap(async (req, res) => {
     const { backgroundStore } = await import('../background-store.mjs');
     const inst = backgroundStore.get(req.params.id);
@@ -130,7 +133,7 @@ export function createBackgroundRouter({ broadcast }) {
 
   // v5.x — Pause. SIGSTOP the subprocess.
   router.post('/background/:id/pause', wrap(async (req, res) => {
-    const { pauseBgAgent } = await import('../bg-spawner.mjs');
+    const { pauseBgAgent } = await import('../claude-bg-spawner.mjs');
     const result = pauseBgAgent(req.params.id);
     if (!result.ok) {
       res.status(result.error === 'unsupported_on_win32' ? 501 : 400).json({ ok: false, error: result.error });
@@ -142,7 +145,7 @@ export function createBackgroundRouter({ broadcast }) {
 
   // v5.x — Resume. SIGCONT the subprocess.
   router.post('/background/:id/resume', wrap(async (req, res) => {
-    const { resumeBgAgent } = await import('../bg-spawner.mjs');
+    const { resumeBgAgent } = await import('../claude-bg-spawner.mjs');
     const result = resumeBgAgent(req.params.id);
     if (!result.ok) {
       res.status(result.error === 'unsupported_on_win32' ? 501 : 400).json({ ok: false, error: result.error });
@@ -152,8 +155,9 @@ export function createBackgroundRouter({ broadcast }) {
     res.json({ ok: true, status: 'running' });
   }));
 
-  // v5.5.1 — Steer is now TRUE mid-flight: the dashboard calls
-  // sdk.sessions.prompt() on the live cline session. No kill+respawn.
+  // v6.3.0 — Steer is TRUE mid-flight: the dashboard calls
+  // claude-bg-spawner.mjs's `steerBgAgent()` on the live Claude Code
+  // session. No kill+respawn.
   // The response shape is the same `{ ok, newInstanceId?, processId? }` —
   // `newInstanceId` is omitted (the same instance is reused); the
   // `mode` field tells the dashboard this was a true mid-flight steer.
@@ -168,7 +172,7 @@ export function createBackgroundRouter({ broadcast }) {
       res.status(400).json({ ok: false, error: 'message_empty' });
       return;
     }
-    const { steerBgAgent } = await import('../bg-spawner.mjs');
+    const { steerBgAgent } = await import('../claude-bg-spawner.mjs');
     const result = await steerBgAgent(req.params.id, message);
     if (!result.ok) {
       res.status(400).json({ ok: false, error: result.error });
@@ -276,7 +280,7 @@ export function createBackgroundRouter({ broadcast }) {
     // that we own (spawned via POST /background). Falls back to the
     // plugin's tmux/abort path for instances spawned by the plugin.
     try {
-      const { isAlive: spawnerAlive, killBgAgent } = await import('../bg-spawner.mjs');
+      const { isAlive: spawnerAlive, killBgAgent } = await import('../claude-bg-spawner.mjs');
       if (spawnerAlive(req.params.id)) {
         const r = await killBgAgent(req.params.id, { signal: 'SIGTERM' });
         if (r.ok) {
@@ -288,10 +292,10 @@ export function createBackgroundRouter({ broadcast }) {
     } catch { /* ignore — fall through to legacy */ }
 
     const { backgroundStore } = await import('../background-store.mjs');
-    // v3.5.4 (bug #3) — `kill()` is now async (it awaits the abortSession
-    // HTTP call to cline serve, then deletes the state file, then
-    // best-effort tmux). The result includes a `steps[]` array so the UI
-    // can report exactly what happened.
+    // v6.3.0 — `kill()` is async (it awaits the kill on the
+    // claude-bg-spawner, then deletes the state file, then
+    // best-effort tmux). The result includes a `steps[]` array so
+    // the UI can report exactly what happened.
     //
     // We always return 200 — the result body's `ok` distinguishes
     // success from partial failure (e.g. abort succeeded but tmux kill