pierre-review 0.1.46 → 0.1.47

package/dist/api/routes/claude-review.js

@@ -1,7 +1,7 @@
 import { config } from '../../config.js';
 import { getClaudeReviewById, getClaudeReviewContext, getFindingPostContext, getLatestClaudeReview, listAllClaudeReviews, listClaudeReviewHistory, } from '../../db/queries.js';
 import { markFindingPosted, markReviewPosted, updateFinding, updateReviewDraft, } from '../../review/persist.js';
-import { getReviewStatus, listActiveReviews, requestReviewCancel, startReview, } from '../../review/review-manager.js';
+import { getReviewStatus, listActiveReviews, requestReviewCancel, startReview, subscribeReviewStream, } from '../../review/review-manager.js';
 import { detectClaudeAuth } from '../../review/auth.js';
 import { hasUserAnthropicKey, setUserAnthropicKey, } from '../../review/local-settings.js';
 import { buildAnchorIndex, buildReview, fallbackAnchor, fetchCurrentHeadSha, fetchPrDiff, findingCommentBody, prLevelFindingBody, stripNoiseFromDiff, submitGithubComment, submitGithubIssueComment, submitGithubReview, } from '../../review/post-review.js';
@@ -169,7 +169,7 @@ export async function claudeReviewRoutes(app) {
         reply.status(202);
         return { reviewId: result.reviewId, status: 'queued' };
     });
-    // Live progress poll target.
+    // Live progress poll target (kept as a fallback + for the initial snapshot).
     app.get('/api/prs/:id/claude-review/status', { schema: idParam }, async (req) => {
         const { id } = req.params;
         if (!config.claudeReviewEnabled) {
@@ -177,6 +177,62 @@ export async function claudeReviewRoutes(app) {
         }
         return await getReviewStatus(id);
     });
+    // Live progress STREAM (SSE) — pushes each phase/activity/usage change in real
+    // time and one terminal `done`, so the UI progress bar tracks the run without
+    // polling. Local-only (Claude Review is gated off in cloud). We `hijack()` the
+    // reply and own the raw socket for the connection's lifetime.
+    app.get('/api/prs/:id/claude-review/stream', { schema: idParam }, async (req, reply) => {
+        const { id } = req.params;
+        reply.hijack();
+        const raw = reply.raw;
+        raw.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache, no-transform',
+            Connection: 'keep-alive',
+            // Disable proxy buffering (nginx) so frames flush immediately.
+            'X-Accel-Buffering': 'no',
+        });
+        const send = (data) => {
+            if (!raw.writableEnded)
+                raw.write(`data: ${JSON.stringify(data)}\n\n`);
+        };
+        if (!config.claudeReviewEnabled) {
+            send({ type: 'done', status: 'idle', reviewId: null });
+            raw.end();
+            return;
+        }
+        let closed = false;
+        let unsubscribe = null;
+        const heartbeat = setInterval(() => {
+            if (!raw.writableEnded)
+                raw.write(': hb\n\n');
+        }, 15000);
+        const cleanup = () => {
+            if (closed)
+                return;
+            closed = true;
+            clearInterval(heartbeat);
+            unsubscribe?.();
+            if (!raw.writableEnded)
+                raw.end();
+        };
+        // Subscribe BEFORE reading the snapshot so a terminal `done` emitted during
+        // setup can't slip through the gap (it'd be delivered to this callback). If
+        // the run already finished, the snapshot check below sends `done` itself.
+        unsubscribe = subscribeReviewStream(id, (e) => {
+            send(e);
+            if (e.type === 'done')
+                cleanup();
+        });
+        req.raw.on('close', cleanup);
+        // Initial snapshot so a client that connects mid-run gets current state at once.
+        const snap = await getReviewStatus(id);
+        send({ type: 'snapshot', ...snap });
+        if (snap.status !== 'running' && snap.status !== 'queued') {
+            send({ type: 'done', status: snap.status, reviewId: snap.reviewId });
+            cleanup();
+        }
+    });
     app.post('/api/prs/:id/claude-review/cancel', { schema: idParam }, async (req, reply) => {
         const { id } = req.params;
         if (!config.claudeReviewEnabled)

package/dist/config.js

@@ -183,9 +183,10 @@ export const config = {
     reviewDiffOnlyEffort: effortFromEnv('REVIEW_DIFF_ONLY_EFFORT', 'low'),
     // At most one review per PR; this caps concurrent reviews across all PRs. Default
     // 4 so the user can bulk-review (extras queue, see review-manager). Raising this
-    // also DISABLES the pasted-key override (which mutates process.env and is only
-    // safe at concurrency 1 — see local-settings.applyUserAnthropicKey); ambient auth
-    // is used instead. Set REVIEW_CONCURRENCY=1 to restore the pasted-key path.
+    // also DISABLES the per-run env auth adjustment (which mutates process.env and is
+    // only safe at concurrency 1 — see auth.applyClaudeReviewAuth); the raw ambient
+    // env is used instead. Set REVIEW_CONCURRENCY=1 to restore prefer-ambient + the
+    // API-key fallback.
     reviewConcurrency: intFromEnv('REVIEW_CONCURRENCY', 4),
     // Hard ceiling on QUEUED (not-yet-started) reviews, a runaway guard for bulk
     // triggering; further starts return 'busy' until the queue drains.

package/dist/review/agent.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { createSdkMcpServer, query, tool, } from '@anthropic-ai/claude-agent-sdk';
 import { config } from '../config.js';
 import { submitReviewShape } from './schema.js';
-import { applyUserAnthropicKey } from './local-settings.js';
+import { applyClaudeReviewAuth } from './auth.js';
 import { cleanupCloneCache, prepWorktree, removeWorktreeLocked, } from './clone-manager.js';
 import { buildUserPrompt, isNoiseFile, systemPromptForMode, } from './prompt.js';
 import { buildAnchorIndex, capDiff, extractHunk, fetchPrDiff, isFindingAnchored, splitDiffByFile, stripNoiseFromDiff, } from './post-review.js';
@@ -169,9 +169,10 @@ export async function runReview(args) {
             omittedFiles = capped.omittedFiles;
             diffCapped = capped.capped;
         }
-        // If the user supplied an Anthropic API key, override ambient Claude auth for
-        // this run (restored in finally). Safe only at reviewConcurrency === 1.
-        restoreEnv = applyUserAnthropicKey();
+        // Establish this run's auth: prefer the ambient Claude subscription, falling
+        // back to an API key only when no ambient session exists (restored in finally).
+        // Safe only at reviewConcurrency === 1.
+        restoreEnv = applyClaudeReviewAuth();
         // ---- run the agent ----
         let captured = null;
         const server = createSdkMcpServer({

package/dist/review/auth.js

@@ -1,24 +1,15 @@
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { config } from '../config.js';
 import { getUserAnthropicKey } from './local-settings.js';
-export function detectClaudeAuth() {
-    // A user-supplied key (stored locally) takes precedence — it overrides the
-    // ambient auth at run time (see local-settings.applyUserAnthropicKey).
-    if (getUserAnthropicKey()) {
-        return { status: 'ok', method: 'api_key' };
-    }
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (apiKey && apiKey.length > 0) {
-        return { status: 'ok', method: 'api_key' };
-    }
-    const oauthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN;
-    if (oauthToken && oauthToken.length > 0) {
-        return { status: 'ok', method: 'oauth_token' };
-    }
-    // Ambient logged-in Claude Code session: any of these on disk is good enough.
-    // The last two are weak signals (config dir present, but maybe not signed in) —
-    // a wrong guess just means the run fails with a clear SDK auth error.
+// Is an ambient Claude SUBSCRIPTION available (OAuth token or a logged-in Claude
+// Code session on disk)? Deliberately excludes API keys — this answers "can Claude
+// Review run on the subscription (no per-token billing)?", which drives the
+// prefer-ambient policy below.
+export function hasAmbientClaudeAuth() {
+    if (process.env.CLAUDE_CODE_OAUTH_TOKEN)
+        return true;
     const home = homedir();
     const ambientCandidates = [
         join(home, '.claude', '.credentials.json'),
@@ -26,12 +17,71 @@ export function detectClaudeAuth() {
         join(home, '.claude.json'),
         join(home, '.claude'),
     ];
-    if (ambientCandidates.some((path) => existsSync(path))) {
+    return ambientCandidates.some((path) => existsSync(path));
+}
+export function detectClaudeAuth() {
+    // Claude Review PREFERS the ambient subscription (see applyClaudeReviewAuth), so
+    // report it first when present — even if an API key also exists.
+    if (process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+        return { status: 'ok', method: 'oauth_token' };
+    }
+    if (hasAmbientClaudeAuth()) {
         return { status: 'ok', method: 'ambient' };
     }
+    // No ambient → fall back to an API key (the user's local key, then the env key).
+    if (getUserAnthropicKey() || process.env.ANTHROPIC_API_KEY) {
+        return { status: 'ok', method: 'api_key' };
+    }
     return {
         status: 'none',
-        message: 'No Claude authentication found. Set ANTHROPIC_API_KEY, or run `claude` once to sign in to an eligible Claude plan (Pro/Max/Team/Enterprise), then restart pierre-review.',
+        message: 'No Claude authentication found. Run `claude` once to sign in to an eligible Claude plan (Pro/Max/Team/Enterprise), or set an Anthropic API key, then restart pierre-review.',
     };
 }
+/**
+ * Establish the auth for ONE Claude Review run by mutating process.env, returning a
+ * restore fn (always call it in a finally). Policy — Claude Review prefers the
+ * ambient subscription so the user's plan/usage credits cover it:
+ *
+ *   • ambient available → STRIP any ANTHROPIC_API_KEY for the run so the Agent SDK
+ *     authenticates via the subscription/OAuth (an API key would otherwise win and
+ *     silently meter the run).
+ *   • no ambient → fall back to an API key (the user's local key, else the env key).
+ *
+ * process.env is process-global, so this only mutates at reviewConcurrency === 1
+ * (the env-race guard); above that it no-ops and the raw ambient env is used. The
+ * Pro summary is unaffected either way — it passes its own key explicitly to the
+ * llm seam and never reads this env.
+ */
+export function applyClaudeReviewAuth() {
+    if (config.reviewConcurrency !== 1)
+        return () => { };
+    const prevApiKey = process.env.ANTHROPIC_API_KEY;
+    const prevOauth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
+    const restore = () => {
+        if (prevApiKey === undefined)
+            delete process.env.ANTHROPIC_API_KEY;
+        else
+            process.env.ANTHROPIC_API_KEY = prevApiKey;
+        if (prevOauth === undefined)
+            delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+        else
+            process.env.CLAUDE_CODE_OAUTH_TOKEN = prevOauth;
+    };
+    if (hasAmbientClaudeAuth()) {
+        // Prefer the subscription: hide any API key so the Agent SDK uses ambient auth.
+        if (process.env.ANTHROPIC_API_KEY === undefined)
+            return () => { };
+        delete process.env.ANTHROPIC_API_KEY;
+        return restore;
+    }
+    // No ambient → use an API key. A user-supplied local key wins over the env key.
+    const key = getUserAnthropicKey();
+    if (key) {
+        process.env.ANTHROPIC_API_KEY = key;
+        delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
+        return restore;
+    }
+    // Nothing to change — leave any existing ANTHROPIC_API_KEY in place.
+    return () => { };
+}
 //# sourceMappingURL=auth.js.map

package/dist/review/llm.js

@@ -1,14 +1,27 @@
-import { getUserAnthropicKey } from './local-settings.js';
+// The cheap-tier ("Haiku") completion seam. Core-owned so the optional @pierre/pro
+// plugin can do a single-shot LLM call (e.g. the per-repo digest) through ctx.llm
+// WITHOUT adding its own Anthropic dependency. Non-agentic: one completion, no
+// tools, no thinking.
+//
+// AUTH is CALLER-OWNED (this is deliberate — it keeps each feature's auth discrete):
+//   • `opts.apiKey` given → the raw, metered `@anthropic-ai/sdk` with THAT key. The
+//     key is passed EXPLICITLY and this seam never reads/writes process.env, so a
+//     summary key can never leak into (or force metering on) Claude Review, which
+//     resolves auth separately and prefers the ambient subscription.
+//   • no `apiKey` → the Claude Agent SDK's `query()` (the SAME runtime Claude Review
+//     uses), which resolves a CLAUDE_CODE_OAUTH_TOKEN / ambient logged-in session.
+// So the Pro summary passes its own dedicated key (fast, metered) while an OSS/dev
+// caller with no key still works via the ambient session.
+//
+// Both SDK imports are LAZY (inside the function) so merely importing this module
+// needs nothing loaded — only an actual caller pays. In OSS mode nothing calls it.
 const DEFAULT_MODEL = 'claude-haiku-4-5';
 export async function cheapComplete(opts) {
     const model = opts.model ?? DEFAULT_MODEL;
-    // A real API key (user-supplied local key wins, then ANTHROPIC_API_KEY) takes the
-    // cheap, metered, exact-cost raw path.
-    const apiKey = getUserAnthropicKey() ?? process.env.ANTHROPIC_API_KEY;
-    if (apiKey)
-        return rawComplete(apiKey, model, opts);
-    // No explicit key → use the Agent SDK, which resolves a CLAUDE_CODE_OAUTH_TOKEN
-    // or an ambient logged-in Claude session exactly as Claude Review does.
+    // An explicit key → the cheap, metered, exact-cost raw path. No key → the ambient
+    // session via the Agent SDK. (No implicit env / Claude-Review-key fallback here.)
+    if (opts.apiKey)
+        return rawComplete(opts.apiKey, model, opts);
     return agentComplete(model, opts);
 }
 // ---- raw @anthropic-ai/sdk path (explicit API key) ----------------------------

package/dist/review/local-settings.js

@@ -40,32 +40,7 @@ export function setUserAnthropicKey(key) {
         delete settings.anthropicApiKey;
     write(settings);
 }
-/**
- * If the user supplied an Anthropic key, override the ambient Claude auth for the
- * duration of one review run by mutating process.env, returning a restore fn.
- *
- * process.env is process-global, so this is ONLY safe when at most one review
- * runs at a time — gated on reviewConcurrency === 1. With concurrency > 1 the
- * override is skipped (the ambient auth is used) to avoid a cross-run env race.
- * Always call the returned restore fn in a finally.
- */
-export function applyUserAnthropicKey() {
-    const key = getUserAnthropicKey();
-    if (!key || config.reviewConcurrency !== 1)
-        return () => { };
-    const prevApiKey = process.env.ANTHROPIC_API_KEY;
-    const prevOauth = process.env.CLAUDE_CODE_OAUTH_TOKEN;
-    process.env.ANTHROPIC_API_KEY = key;
-    delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-    return () => {
-        if (prevApiKey === undefined)
-            delete process.env.ANTHROPIC_API_KEY;
-        else
-            process.env.ANTHROPIC_API_KEY = prevApiKey;
-        if (prevOauth === undefined)
-            delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
-        else
-            process.env.CLAUDE_CODE_OAUTH_TOKEN = prevOauth;
-    };
-}
+// NOTE: the per-run env override for Claude Review now lives in review/auth.ts as
+// `applyClaudeReviewAuth` (it implements the prefer-ambient policy and needs the
+// ambient-session probe). This module stays a pure key store.
 //# sourceMappingURL=local-settings.js.map

package/dist/review/review-manager.js

@@ -13,6 +13,43 @@ const claimed = new Set(); // prIds either running OR pending — the sync guard
 const reviewIdByPr = new Map();
 const progressByReview = new Map();
 const controllers = new Map();
+// SSE fan-out (keyed by prId): the live-progress stream endpoint subscribes here,
+// so each phase/activity/usage change is PUSHED to connected clients in real time
+// instead of being polled. Empty in the common case (no open stream). See
+// subscribeReviewStream + GET /api/prs/:id/claude-review/stream.
+const streamSubs = new Map();
+function emitReviewStream(prId, e) {
+    const subs = streamSubs.get(prId);
+    if (!subs)
+        return;
+    for (const cb of subs) {
+        try {
+            cb(e);
+        }
+        catch {
+            /* a broken subscriber must never break the run */
+        }
+    }
+}
+// Subscribe to a PR's live review stream. Returns an unsubscribe fn. The manager
+// emits 'progress' events across the queued→running lifecycle and one terminal
+// 'done' (with the persisted final status) when the run settles.
+export function subscribeReviewStream(prId, cb) {
+    let set = streamSubs.get(prId);
+    if (!set) {
+        set = new Set();
+        streamSubs.set(prId, set);
+    }
+    set.add(cb);
+    return () => {
+        const s = streamSubs.get(prId);
+        if (!s)
+            return;
+        s.delete(cb);
+        if (s.size === 0)
+            streamSubs.delete(prId);
+    };
+}
 export async function startReview(prId, model, requestedMode, log) {
     if (!config.claudeReviewEnabled)
         return { ok: false, reason: 'disabled' };
@@ -78,7 +115,14 @@ function launch(item) {
     controllers.set(reviewId, controller);
     // The diff is fetched (and the mode decided) before any clone, so the first real
     // phase is always 'fetching_diff' — not 'cloning' (which a diff-only run skips).
-    progressByReview.set(reviewId, { phase: 'fetching_diff' });
+    const initial = { phase: 'fetching_diff' };
+    progressByReview.set(reviewId, initial);
+    emitReviewStream(prId, {
+        type: 'progress',
+        status: 'running',
+        reviewId,
+        progress: initial,
+    });
     void runReview({
         reviewId,
         prId,
@@ -94,7 +138,15 @@ function launch(item) {
         requestedMode: item.requestedMode,
         priorReviewContext: item.priorReviewContext,
         abortController: controller,
-        onProgress: (p) => progressByReview.set(reviewId, p),
+        onProgress: (p) => {
+            progressByReview.set(reviewId, p);
+            emitReviewStream(prId, {
+                type: 'progress',
+                status: 'running',
+                reviewId,
+                progress: p,
+            });
+        },
     })
         .catch((err) => {
         item.log.error(`claude review pr ${prId} failed: ${err instanceof Error ? err.message : err}`);
@@ -105,6 +157,15 @@ function launch(item) {
         controllers.delete(reviewId);
         progressByReview.delete(reviewId);
         claimed.delete(prId);
+        // Push a terminal event to any open stream with the PERSISTED final status
+        // (succeeded / failed / cancelled), then start the next queued review.
+        void getLatestClaudeReview(prId, LOCAL_ACCOUNT_ID)
+            .then((latest) => emitReviewStream(prId, {
+            type: 'done',
+            status: latest?.status ?? 'failed',
+            reviewId,
+        }))
+            .catch(() => emitReviewStream(prId, { type: 'done', status: 'failed', reviewId }));
         pump(); // a slot freed — start the next queued review
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pierre-review",
-  "version": "0.1.46",
+  "version": "0.1.47",
   "description": "Dashboard for tracking your team's GitHub PR activity across repos — local (SQLite + gh) or self-hosted multi-tenant cloud (Postgres + GitHub App).",
   "type": "module",
   "author": "Alex Wakeman",