@plannotator/pi-extension 0.21.1 → 0.21.2

package/server/agent-jobs.ts

@@ -8,7 +8,10 @@
  */
 
 import type { IncomingMessage, ServerResponse } from "node:http";
-import { spawn, execFileSync, type ChildProcess } from "node:child_process";
+import { spawn, execFileSync, execFile, type ChildProcess } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
 import {
 	type AgentJobInfo,
 	type AgentJobEvent,
@@ -21,6 +24,12 @@ import {
 	AGENT_HEARTBEAT_INTERVAL_MS,
 } from "../generated/agent-jobs.js";
 import { formatClaudeLogEvent } from "../generated/claude-review.js";
+import {
+	MARKER_ENGINES,
+	formatMarkerLogEvent,
+	type MarkerEngine,
+	type MarkerModel,
+} from "../generated/marker-review.js";
 import { json, parseBody } from "./helpers.js";
 
 // ---------------------------------------------------------------------------
@@ -32,6 +41,16 @@ const JOBS = `${BASE}/jobs`;
 const JOBS_STREAM = `${JOBS}/stream`;
 const CAPABILITIES = `${BASE}/capabilities`;
 
+// Providers whose command is owned by the server. Client-supplied argv is never
+// spawned for these — buildCommand must produce the command or the launch fails.
+const SERVER_BUILT_PROVIDERS: ReadonlySet<string> = new Set([
+	"claude",
+	"codex",
+	"tour",
+	"cursor",
+	"opencode",
+]);
+
 // ---------------------------------------------------------------------------
 // which() helper for Node.js
 // ---------------------------------------------------------------------------
@@ -54,7 +73,7 @@ export interface AgentJobHandlerOptions {
 	mode: "plan" | "review" | "annotate";
 	getServerUrl: () => string;
 	getCwd: () => string;
-	/** Server-side command builder for known providers (codex, claude, tour). */
+	/** Build the command server-side for a given provider. */
 	buildCommand?: (provider: string, config?: Record<string, unknown>) => Promise<{
 		command: string[];
 		outputPath?: string;
@@ -79,11 +98,36 @@ export interface AgentJobHandlerOptions {
 		diffScope?: string;
 		/** Diff context snapshot at launch (stored on AgentJobInfo for per-job "Copy All"). */
 		diffContext?: AgentJobInfo["diffContext"];
+		/** Resolved review profile id at launch time. Stored on AgentJobInfo. */
+		reviewProfileId?: string;
+		/** Resolved review profile label at launch time. Stored on AgentJobInfo. */
+		reviewProfileLabel?: string;
 	} | null>;
 	/** Called when a job completes successfully — parse results and push annotations. */
 	onJobComplete?: (job: AgentJobInfo, meta: { outputPath?: string; stdout?: string; cwd?: string }) => void | Promise<void>;
 }
 
+/**
+ * Best-effort model catalog for a marker engine, spawned once. The spawn lives
+ * HERE (per-runtime — child_process execFile) rather than in marker-review.ts,
+ * which must stay Bun-free for the Pi vendor build. ASYNC so it never blocks the
+ * event loop on the /capabilities request path (a slow/hanging CLI would otherwise
+ * freeze every other in-flight request for up to the timeout). Empty when discovery
+ * fails or the CLI is unauthenticated / has no providers configured — the UI falls
+ * back to the engine's default picker. Account/config-specific, so never hardcoded.
+ */
+async function discoverMarkerModels(engine: MarkerEngine): Promise<MarkerModel[]> {
+	try {
+		const { stdout } = await execFileAsync(engine.binary, engine.modelsArgv, {
+			timeout: 5000,
+			encoding: "utf8",
+		});
+		return engine.parseModels(stdout);
+	} catch {
+		return [];
+	}
+}
+
 export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 	const { mode, getServerUrl, getCwd } = options;
 
@@ -99,11 +143,32 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 		{ id: "codex", name: "Codex CLI", available: whichCmd("codex") },
 		{ id: "tour", name: "Code Tour", available: whichCmd("claude") || whichCmd("codex") },
 	];
-	const capabilitiesResponse: AgentCapabilities = {
-		mode,
-		providers: capabilities,
-		available: capabilities.some((c) => c.available),
-	};
+	// Marker engines (Cursor, OpenCode) — same shape, one loop. Available only in
+	// review mode when the binary is on PATH (NOTE: cursor's binary is `agent`).
+	// Model catalogs are discovered LAZILY (see buildCapabilitiesResponse) so a
+	// slow/unauthenticated `<binary> models` spawn never blocks startup.
+	for (const engine of Object.values(MARKER_ENGINES)) {
+		capabilities.push({
+			id: engine.id,
+			name: engine.name,
+			available: mode === "review" && whichCmd(engine.binary),
+		});
+	}
+
+	const markerModelsCache = new Map<string, MarkerModel[]>();
+	async function buildCapabilitiesResponse(): Promise<AgentCapabilities> {
+		const providers = await Promise.all(capabilities.map(async (c) => {
+			const engine = MARKER_ENGINES[c.id as "cursor" | "opencode"];
+			if (!engine || !c.available) return c;
+			let models = markerModelsCache.get(engine.id);
+			if (!models) {
+				models = await discoverMarkerModels(engine);
+				markerModelsCache.set(engine.id, models);
+			}
+			return { ...c, models };
+		}));
+		return { mode, providers, available: providers.some((p) => p.available) };
+	}
 
 	// --- SSE broadcasting ---
 	function broadcast(event: AgentJobEvent): void {
@@ -118,15 +183,16 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 		}
 	}
 
+
 	// --- Process lifecycle ---
 	function spawnJob(
+		id: string,
 		provider: string,
 		command: string[],
 		label: string,
 		outputPath?: string,
-		spawnOptions?: { captureStdout?: boolean; stdinPrompt?: string; cwd?: string; prompt?: string; engine?: string; model?: string; effort?: string; reasoningEffort?: string; fastMode?: boolean; prUrl?: string; diffScope?: string; diffContext?: AgentJobInfo["diffContext"] },
+		spawnOptions?: { captureStdout?: boolean; stdinPrompt?: string; cwd?: string; prompt?: string; engine?: string; model?: string; effort?: string; reasoningEffort?: string; fastMode?: boolean; prUrl?: string; diffScope?: string; diffContext?: AgentJobInfo["diffContext"]; reviewProfileId?: string; reviewProfileLabel?: string },
 	): AgentJobInfo {
-		const id = crypto.randomUUID();
 		const source = jobSource(id);
 
 		const info: AgentJobInfo = {
@@ -146,6 +212,8 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 			...(spawnOptions?.prUrl && { prUrl: spawnOptions.prUrl }),
 			...(spawnOptions?.diffScope && { diffScope: spawnOptions.diffScope }),
 			...(spawnOptions?.diffContext && { diffContext: spawnOptions.diffContext }),
+			...(spawnOptions?.reviewProfileId && { reviewProfileId: spawnOptions.reviewProfileId }),
+			...(spawnOptions?.reviewProfileLabel && { reviewProfileLabel: spawnOptions.reviewProfileLabel }),
 		};
 
 		let proc: ChildProcess | null = null;
@@ -183,31 +251,47 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 			if (spawnOptions?.cwd) jobOutputPaths.set(`${id}:cwd`, spawnOptions.cwd);
 			broadcast({ type: "job:started", job: { ...info } });
 
-			// --- Stdout capture (Claude JSONL streaming) ---
+			// --- Stdout capture (Claude/Cursor stream-json) ---
 			let stdoutBuf = "";
 			if (captureStdout && proc.stdout) {
+				// Format one complete JSONL line into a live-log delta (skip result
+				// events — handled in onJobComplete).
+				const emitLogLine = (line: string) => {
+					if (!line.trim()) return;
+					// Tour jobs with the Claude engine also stream Claude JSONL.
+					if (provider === "claude" || spawnOptions?.engine === "claude") {
+						const formatted = formatClaudeLogEvent(line);
+						if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+						return;
+					}
+					// Marker engines (Cursor, OpenCode): map their NDJSON stream events
+					// into readable log deltas via the engine's own formatter (Cursor
+					// applies the partial-output dedup rule; OpenCode reads text parts).
+					const markerEngine = MARKER_ENGINES[provider as "cursor" | "opencode"];
+					if (markerEngine) {
+						const formatted = formatMarkerLogEvent(line, markerEngine);
+						if (formatted !== null) broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
+						return;
+					}
+					try {
+						const event = JSON.parse(line);
+						if (event.type === 'result') return;
+					} catch { /* not JSON — forward as raw log */ }
+					broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
+				};
+				// stream-json output is NDJSON and chunk boundaries are arbitrary —
+				// carry the trailing partial line until a later chunk completes it,
+				// otherwise records split across chunks are dropped from live logs.
+				let logLineCarry = "";
 				proc.stdout.on("data", (chunk: Buffer) => {
 					const text = chunk.toString();
 					stdoutBuf += text;
-
-					// Forward JSONL lines as log events
-					const lines = text.split('\n');
-					for (const line of lines) {
-						if (!line.trim()) continue;
-						// Tour jobs with the Claude engine also stream Claude JSONL.
-						if (provider === "claude" || spawnOptions?.engine === "claude") {
-							const formatted = formatClaudeLogEvent(line);
-							if (formatted !== null) {
-								broadcast({ type: "job:log", jobId: id, delta: formatted + '\n' });
-							}
-							continue;
-						}
-						try {
-							const event = JSON.parse(line);
-							if (event.type === 'result') continue;
-						} catch { /* not JSON — forward as raw log */ }
-						broadcast({ type: "job:log", jobId: id, delta: line + '\n' });
-					}
+					const lines = (logLineCarry + text).split('\n');
+					logLineCarry = lines.pop() ?? "";
+					for (const line of lines) emitLogLine(line);
+				});
+				proc.stdout.on("end", () => {
+					if (logLineCarry) emitLogLine(logLineCarry);
 				});
 			}
 
@@ -265,13 +349,19 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 							stdout: captureStdout ? stdoutBuf : undefined,
 							cwd: jobCwd,
 						});
-					} catch {
-						// Result ingestion failure shouldn't prevent job completion broadcast
+					} catch (err) {
+						// Claude/Codex are fail-open; Cursor and OpenCode are fail-closed — an
+						// unexpected throw during prompt-enforced ingestion must fail the job,
+						// not pass it. (Their handlers normally fail by mutation and never
+						// throw; this guards future refactors.)
+						if (MARKER_ENGINES[provider as "cursor" | "opencode"]) {
+							entry.info.status = "failed";
+							entry.info.error = err instanceof Error ? err.message : `${provider} result ingestion failed`;
+						}
 					}
 				}
 				jobOutputPaths.delete(id);
 				jobOutputPaths.delete(`${id}:cwd`);
-
 				broadcast({ type: "job:completed", job: { ...entry.info } });
 			});
 
@@ -344,7 +434,7 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 		): Promise<boolean> {
 			// --- GET /api/agents/capabilities ---
 			if (url.pathname === CAPABILITIES && req.method === "GET") {
-				json(res, capabilitiesResponse);
+				json(res, await buildCapabilitiesResponse());
 				return true;
 			}
 
@@ -405,6 +495,22 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 			if (url.pathname === JOBS && req.method === "POST") {
 				try {
 					const body = await parseBody(req);
+
+					// Reject unknown fields rather than silently ignoring them (per the
+					// custom-reviews spec — a typo'd field should fail loud, not no-op).
+					const KNOWN_JOB_FIELDS = new Set([
+						"provider", "command", "label",
+						"engine", "model", "reasoningEffort", "effort", "fastMode",
+						"reviewProfileId",
+					]);
+					if (body && typeof body === "object") {
+						const unknown = Object.keys(body).filter((k) => !KNOWN_JOB_FIELDS.has(k));
+						if (unknown.length > 0) {
+							json(res, { error: `Unknown field(s): ${unknown.join(", ")}` }, 400);
+							return true;
+						}
+					}
+
 					const provider = typeof body.provider === "string" ? body.provider : "";
 					let rawCommand = Array.isArray(body.command) ? body.command : [];
 					let command = rawCommand.filter((c: unknown): c is string => typeof c === "string");
@@ -418,6 +524,19 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 						return true;
 					}
 
+					// Fail-closed enforcement for server-owned providers: the command MUST
+					// be built server-side. Client-supplied argv is never spawned for these
+					// providers — a null/throwing builder becomes an error, not a fallback.
+					if (SERVER_BUILT_PROVIDERS.has(provider)) {
+						if (!options.buildCommand) {
+							json(res, { error: `Provider ${provider} requires server-built command` }, 400);
+							return true;
+						}
+						// Discard any client-supplied argv so a null build cleanly hits the
+						// `command.length === 0` guard below instead of falling through.
+						command = [];
+					}
+
 					// Try server-side command building for known providers
 					let captureStdout = false;
 					let stdinPrompt: string | undefined;
@@ -431,6 +550,9 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 					let jobPrUrl: string | undefined;
 					let jobDiffScope: string | undefined;
 					let jobDiffContext: AgentJobInfo["diffContext"] | undefined;
+					let jobReviewProfileId: string | undefined;
+					let jobReviewProfileLabel: string | undefined;
+					const jobId = crypto.randomUUID();
 					if (options.buildCommand) {
 						// Thread config from POST body to buildCommand
 						const config: Record<string, unknown> = {};
@@ -439,6 +561,7 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 						if (typeof body.reasoningEffort === "string") config.reasoningEffort = body.reasoningEffort;
 						if (typeof body.effort === "string") config.effort = body.effort;
 						if (body.fastMode === true) config.fastMode = true;
+						if (typeof body.reviewProfileId === "string") config.reviewProfileId = body.reviewProfileId;
 						const built = await options.buildCommand(provider, Object.keys(config).length > 0 ? config : undefined);
 						if (built) {
 							command = built.command;
@@ -456,6 +579,8 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 							jobPrUrl = built.prUrl;
 							jobDiffScope = built.diffScope;
 							jobDiffContext = built.diffContext;
+							jobReviewProfileId = built.reviewProfileId;
+							jobReviewProfileLabel = built.reviewProfileLabel;
 						}
 					}
 
@@ -464,7 +589,7 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 						return true;
 					}
 
-					const job = spawnJob(provider, command, label, outputPath, {
+					const job = spawnJob(jobId, provider, command, label, outputPath, {
 						captureStdout,
 						stdinPrompt,
 						cwd: spawnCwd,
@@ -477,6 +602,8 @@ export function createAgentJobHandler(options: AgentJobHandlerOptions) {
 						prUrl: jobPrUrl,
 						diffScope: jobDiffScope,
 						diffContext: jobDiffContext,
+						reviewProfileId: jobReviewProfileId,
+						reviewProfileLabel: jobReviewProfileLabel,
 					});
 					json(res, { job }, 201);
 				} catch (err) {