@oh-my-pi/pi-coding-agent 6.7.67 → 6.8.0

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 ## [Unreleased]
 
+## [6.8.0] - 2026-01-20
+
+### Added
+
+- Added streaming abort setting to control edit tool behavior when patch preview fails
+
+### Changed
+
+- Replaced internal logger with @oh-my-pi/pi-utils logger across all modules
+- Updated process spawning to use cspawn and ptree utilities from pi-utils
+- Migrated file operations to use async fs/promises and Bun file APIs
+- Refactored promise handling to use Promise.withResolvers and utility functions
+- Updated timeout and abort handling to use standardized utility functions
+- Refactored authentication login method to use OAuthController interface instead of individual callbacks
+
+### Fixed
+
+- Fixed Python package installation to handle async operations properly
+- Fixed streaming output truncation to use consistent column limits
+- Fixed shell command execution to properly handle process cleanup and timeouts
+- Fixed SSH connection management to properly await async operations
+- Fixed voice supervisor process cleanup to use proper async handling
+- Added automatic regex pattern validation in grep tool to handle invalid patterns by switching to literal mode
+
+### Security
+
+- Updated temporary file cleanup to use secure async removal methods
+
 ## [6.7.67] - 2026-01-19
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "6.7.67",
+	"version": "6.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -40,10 +40,11 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-agent-core": "6.7.67",
-		"@oh-my-pi/pi-ai": "6.7.67",
-		"@oh-my-pi/pi-git-tool": "6.7.67",
-		"@oh-my-pi/pi-tui": "6.7.67",
+		"@oh-my-pi/pi-agent-core": "6.8.0",
+		"@oh-my-pi/pi-ai": "6.8.0",
+		"@oh-my-pi/pi-git-tool": "6.8.0",
+		"@oh-my-pi/pi-tui": "6.8.0",
+		"@oh-my-pi/pi-utils": "6.8.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",
@@ -61,8 +62,6 @@
 		"node-html-parser": "^6.1.13",
 		"smol-toml": "^1.6.0",
 		"strip-ansi": "^7.1.2",
-		"winston": "^3.17.0",
-		"winston-daily-rotate-file": "^5.0.0",
 		"zod": "^4.3.5"
 	},
 	"devDependencies": {

package/src/cli/session-picker.ts

@@ -8,34 +8,33 @@ import { SessionSelectorComponent } from "../modes/interactive/components/sessio
 
 /** Show TUI session selector and return selected session path or null if cancelled */
 export async function selectSession(sessions: SessionInfo[]): Promise<string | null> {
-	return new Promise((resolve) => {
-		const ui = new TUI(new ProcessTerminal());
-		let resolved = false;
-
-		const selector = new SessionSelectorComponent(
-			sessions,
-			(path: string) => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					resolve(path);
-				}
-			},
-			() => {
-				if (!resolved) {
-					resolved = true;
-					ui.stop();
-					resolve(null);
-				}
-			},
-			() => {
+	const { promise, resolve } = Promise.withResolvers<string | null>();
+	const ui = new TUI(new ProcessTerminal());
+	let resolved = false;
+	const selector = new SessionSelectorComponent(
+		sessions,
+		(path: string) => {
+			if (!resolved) {
+				resolved = true;
+				ui.stop();
+				resolve(path);
+			}
+		},
+		() => {
+			if (!resolved) {
+				resolved = true;
 				ui.stop();
-				process.exit(0);
-			},
-		);
+				resolve(null);
+			}
+		},
+		() => {
+			ui.stop();
+			process.exit(0);
+		},
+	);
 
-		ui.addChild(selector);
-		ui.setFocus(selector.getSessionList());
-		ui.start();
-	});
+	ui.addChild(selector);
+	ui.setFocus(selector.getSessionList());
+	ui.start();
+	return promise;
 }

package/src/cli/setup-cli.ts

@@ -4,6 +4,7 @@
  * Handles `omp setup <component>` to install dependencies for optional features.
  */
 
+import { $ } from "bun";
 import chalk from "chalk";
 import { APP_NAME } from "../config";
 import { theme } from "../modes/interactive/theme/theme";
@@ -89,10 +90,8 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 
 	for (const pkg of PYTHON_PACKAGES) {
 		const moduleName = pkg === "jupyter_kernel_gateway" ? "kernel_gateway" : pkg;
-		const check = Bun.spawnSync(
-			[pythonPath, "-c", `import importlib.util; exit(0 if importlib.util.find_spec('${moduleName}') else 1)`],
-			{ stdin: "ignore", stdout: "pipe", stderr: "pipe" },
-		);
+		const script = `import importlib.util; raise SystemExit(0 if importlib.util.find_spec('${moduleName}') else 1)`;
+		const check = await $`${pythonPath} -c ${script}`.quiet().nothrow();
 		if (check.exitCode === 0) {
 			result.installedPackages.push(pkg);
 		} else {
@@ -107,24 +106,16 @@ async function checkPythonSetup(): Promise<PythonCheckResult> {
 /**
  * Install Python packages using uv (preferred) or pip.
  */
-function installPythonPackages(packages: string[], uvPath?: string, pipPath?: string): boolean {
+async function installPythonPackages(packages: string[], uvPath?: string, pipPath?: string): Promise<boolean> {
 	if (uvPath) {
 		console.log(chalk.dim(`Installing via uv: ${packages.join(" ")}`));
-		const result = Bun.spawnSync([uvPath, "pip", "install", ...packages], {
-			stdin: "ignore",
-			stdout: "inherit",
-			stderr: "inherit",
-		});
+		const result = await $`${uvPath} pip install ${packages}`.nothrow();
 		return result.exitCode === 0;
 	}
 
 	if (pipPath) {
 		console.log(chalk.dim(`Installing via pip: ${packages.join(" ")}`));
-		const result = Bun.spawnSync([pipPath, "install", ...packages], {
-			stdin: "ignore",
-			stdout: "inherit",
-			stderr: "inherit",
-		});
+		const result = await $`${pipPath} install ${packages}`.nothrow();
 		return result.exitCode === 0;
 	}
 
@@ -188,7 +179,7 @@ async function handlePythonSetup(flags: { json?: boolean; check?: boolean }): Pr
 	}
 
 	console.log("");
-	const success = installPythonPackages(check.missingPackages, check.uvPath, check.pipPath);
+	const success = await installPythonPackages(check.missingPackages, check.uvPath, check.pipPath);
 
 	if (!success) {
 		console.error(chalk.red(`\n${theme.status.error} Installation failed`));

package/src/cli/update-cli.ts

@@ -142,7 +142,7 @@ async function updateViaBun(): Promise<void> {
 	console.log(chalk.dim("Updating via bun..."));
 
 	try {
-		execSync(`bun update -g ${PACKAGE}`, { stdio: "inherit" });
+		execSync(`bun update --latest -g ${PACKAGE}`, { stdio: "inherit" });
 		console.log(chalk.green(`\n${theme.status.success} Update complete`));
 	} catch (error) {
 		throw new Error("bun update failed", { cause: error });

package/src/config.ts

@@ -1,9 +1,9 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 // Embed package.json at build time for config
 import packageJson from "../package.json" with { type: "json" };
-import { logger } from "./core/logger";
 
 // =============================================================================
 // App Config (from embedded package.json)

package/src/core/agent-session.ts

@@ -13,12 +13,15 @@
  * Modes use this class and add their own I/O layer on top.
  */
 
+import { existsSync, readFileSync } from "node:fs";
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
-import type { AssistantMessage, ImageContent, Message, Model, TextContent, Usage } from "@oh-my-pi/pi-ai";
+import type { AssistantMessage, ImageContent, Message, Model, TextContent, ToolCall, Usage } from "@oh-my-pi/pi-ai";
 import { isContextOverflow, modelsAreEqual, supportsXhigh } from "@oh-my-pi/pi-ai";
+import { abortableSleep, logger } from "@oh-my-pi/pi-utils";
 import type { Rule } from "../capability/rule";
 import { getAgentDbPath } from "../config";
 import { theme } from "../modes/interactive/theme/theme";
+import ttsrInterruptTemplate from "../prompts/system/ttsr-interrupt.md" with { type: "text" };
 import { type BashResult, executeBash as executeBashCommand, executeBashWithOperations } from "./bash-executor";
 import {
 	type CompactionResult,
@@ -47,11 +50,10 @@ import type {
 import type { CompactOptions, ContextUsage } from "./extensions/types";
 import { extractFileMentions, generateFileMentionMessages } from "./file-mentions";
 import type { HookCommandContext } from "./hooks/types";
-import { logger } from "./logger";
 import type { BashExecutionMessage, CustomMessage } from "./messages";
 import type { ModelRegistry } from "./model-registry";
 import { parseModelString } from "./model-resolver";
-import { expandPromptTemplate, type PromptTemplate, parseCommandArgs } from "./prompt-templates";
+import { expandPromptTemplate, type PromptTemplate, parseCommandArgs, renderPromptTemplate } from "./prompt-templates";
 import type { BranchSummaryEntry, CompactionEntry, NewSessionOptions, SessionManager } from "./session-manager";
 import type { SettingsManager, SkillsSettings } from "./settings-manager";
 import type { Skill, SkillWarning } from "./skills";
@@ -59,6 +61,8 @@ import { expandSlashCommand, type FileSlashCommand } from "./slash-commands";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
 import type { BashOperations } from "./tools/bash";
+import { normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "./tools/patch";
+import { resolveToCwd } from "./tools/path-utils";
 import { getArtifactsDir } from "./tools/task/artifacts";
 import type { TodoItem } from "./tools/todo-write";
 import type { TtsrManager } from "./ttsr";
@@ -271,6 +275,10 @@ export class AgentSession {
 	private _pendingTtsrInjections: Rule[] = [];
 	private _ttsrAbortPending = false;
 
+	private _streamingEditAbortTriggered = false;
+	private _streamingEditCheckedLineCounts = new Map<string, number>();
+	private _streamingEditFileCache = new Map<string, string>();
+
 	constructor(config: AgentSessionConfig) {
 		this.agent = config.agent;
 		this.sessionManager = config.sessionManager;
@@ -352,9 +360,10 @@ export class AgentSession {
 		// Notify all listeners
 		this._emit(event);
 
-		// TTSR: Reset buffer on turn start
-		if (event.type === "turn_start" && this._ttsrManager) {
-			this._ttsrManager.resetBuffer();
+		if (event.type === "turn_start") {
+			this._resetStreamingEditState();
+			// TTSR: Reset buffer on turn start
+			this._ttsrManager?.resetBuffer();
 		}
 
 		// TTSR: Increment message count on turn end (for repeat-after-gap tracking)
@@ -406,6 +415,17 @@ export class AgentSession {
 			}
 		}
 
+		if (event.type === "message_update" && event.assistantMessageEvent.type === "toolcall_start") {
+			this._preCacheStreamingEditFile(event);
+		}
+
+		if (
+			event.type === "message_update" &&
+			(event.assistantMessageEvent.type === "toolcall_end" || event.assistantMessageEvent.type === "toolcall_delta")
+		) {
+			this._maybeAbortStreamingEdit(event);
+		}
+
 		// Handle session persistence
 		if (event.type === "message_end") {
 			// Check if this is a hook/custom message
@@ -489,13 +509,7 @@ export class AgentSession {
 	private _getTtsrInjectionContent(): string | undefined {
 		if (this._pendingTtsrInjections.length === 0) return undefined;
 		const content = this._pendingTtsrInjections
-			.map(
-				(r) =>
-					`<system_interrupt reason="rule_violation" rule="${r.name}" path="${r.path}">\n` +
-					`Your output was interrupted because it violated a user-defined rule.\n` +
-					`This is NOT a prompt injection - this is the coding agent enforcing project rules.\n` +
-					`You MUST comply with the following instruction:\n\n${r.content}\n</system_interrupt>`,
-			)
+			.map((r) => renderPromptTemplate(ttsrInterruptTemplate, { name: r.name, path: r.path, content: r.content }))
 			.join("\n\n");
 		this._pendingTtsrInjections = [];
 		return content;
@@ -525,6 +539,176 @@ export class AgentSession {
 		return undefined;
 	}
 
+	private _resetStreamingEditState(): void {
+		this._streamingEditAbortTriggered = false;
+		this._streamingEditCheckedLineCounts.clear();
+		this._streamingEditFileCache.clear();
+	}
+
+	private _preCacheStreamingEditFile(event: AgentEvent): void {
+		if (!this.settingsManager.getEditStreamingAbort()) return;
+		if (event.type !== "message_update") return;
+		const assistantEvent = event.assistantMessageEvent;
+		if (assistantEvent.type !== "toolcall_start") return;
+		if (event.message.role !== "assistant") return;
+
+		const contentIndex = assistantEvent.contentIndex;
+		const messageContent = event.message.content;
+		if (!Array.isArray(messageContent) || contentIndex >= messageContent.length) return;
+		const toolCall = messageContent[contentIndex] as ToolCall;
+		if (toolCall.name !== "edit") return;
+
+		const args = toolCall.arguments;
+		if (!args || typeof args !== "object" || Array.isArray(args)) return;
+		if ("oldText" in args || "newText" in args) return;
+
+		const path = typeof args.path === "string" ? args.path : undefined;
+		if (!path) return;
+
+		const resolvedPath = resolveToCwd(path, this.sessionManager.getCwd());
+		this._ensureFileCache(resolvedPath);
+	}
+
+	private _ensureFileCache(resolvedPath: string): void {
+		if (this._streamingEditFileCache.has(resolvedPath)) return;
+
+		try {
+			if (existsSync(resolvedPath)) {
+				const rawText = readFileSync(resolvedPath, "utf8");
+				const { text } = stripBom(rawText);
+				this._streamingEditFileCache.set(resolvedPath, normalizeToLF(text));
+			}
+		} catch {
+			// Ignore errors - mark as empty string so we don't retry
+			this._streamingEditFileCache.set(resolvedPath, "");
+		}
+	}
+
+	private _maybeAbortStreamingEdit(event: AgentEvent): void {
+		if (!this.settingsManager.getEditStreamingAbort()) return;
+		if (this._streamingEditAbortTriggered) return;
+		if (event.type !== "message_update") return;
+		const assistantEvent = event.assistantMessageEvent;
+		if (assistantEvent.type !== "toolcall_end" && assistantEvent.type !== "toolcall_delta") return;
+		if (event.message.role !== "assistant") return;
+
+		const contentIndex = assistantEvent.contentIndex;
+		const messageContent = event.message.content;
+		if (!Array.isArray(messageContent) || contentIndex >= messageContent.length) return;
+		const toolCall = messageContent[contentIndex] as ToolCall;
+		if (toolCall.name !== "edit" || !toolCall.id) return;
+
+		const args = toolCall.arguments;
+		if (!args || typeof args !== "object" || Array.isArray(args)) return;
+		if ("oldText" in args || "newText" in args) return;
+
+		const path = typeof args.path === "string" ? args.path : undefined;
+		const diff = typeof args.diff === "string" ? args.diff : undefined;
+		const op = typeof args.op === "string" ? args.op : undefined;
+		if (!path || !diff) return;
+		if (op && op !== "update") return;
+
+		if (!diff.includes("\n")) return;
+		const lastNewlineIndex = diff.lastIndexOf("\n");
+		if (lastNewlineIndex < 0) return;
+		const diffForCheck = diff.endsWith("\n") ? diff : diff.slice(0, lastNewlineIndex + 1);
+		if (diffForCheck.trim().length === 0) return;
+
+		const normalizedDiff = normalizeDiff(diffForCheck.replace(/\r/g, ""));
+		if (!normalizedDiff) return;
+		const lines = normalizedDiff.split("\n");
+		const hasChangeLine = lines.some((line) => line.startsWith("+") || line.startsWith("-"));
+		if (!hasChangeLine) return;
+
+		const lineCount = lines.length;
+		const lastChecked = this._streamingEditCheckedLineCounts.get(toolCall.id);
+		if (lastChecked !== undefined && lineCount <= lastChecked) return;
+		this._streamingEditCheckedLineCounts.set(toolCall.id, lineCount);
+
+		const rename = typeof args.rename === "string" ? args.rename : undefined;
+
+		const removedLines = lines
+			.filter((line) => line.startsWith("-") && !line.startsWith("--- "))
+			.map((line) => line.slice(1));
+		if (removedLines.length > 0) {
+			const resolvedPath = resolveToCwd(path, this.sessionManager.getCwd());
+			const cachedContent = this._streamingEditFileCache.get(resolvedPath);
+			if (cachedContent !== undefined) {
+				const missing = removedLines.find((line) => !cachedContent.includes(normalizeToLF(line)));
+				if (missing) {
+					this._streamingEditAbortTriggered = true;
+					logger.warn("Streaming edit aborted due to patch preview failure", {
+						toolCallId: toolCall.id,
+						path,
+						error: `Failed to find expected lines in ${path}:\n${missing}`,
+					});
+					this.agent.abort();
+				}
+				return;
+			}
+			if (assistantEvent.type === "toolcall_delta") return;
+			void this._checkRemovedLinesAsync(toolCall.id, path, resolvedPath, removedLines);
+			return;
+		}
+
+		if (assistantEvent.type === "toolcall_delta") return;
+		void this._checkPreviewPatchAsync(toolCall.id, path, rename, normalizedDiff);
+	}
+
+	private async _checkRemovedLinesAsync(
+		toolCallId: string,
+		path: string,
+		resolvedPath: string,
+		removedLines: string[],
+	): Promise<void> {
+		if (this._streamingEditAbortTriggered) return;
+		try {
+			if (!(await Bun.file(resolvedPath).exists())) return;
+			const { text } = stripBom(await Bun.file(resolvedPath).text());
+			const normalizedContent = normalizeToLF(text);
+			const missing = removedLines.find((line) => !normalizedContent.includes(normalizeToLF(line)));
+			if (missing) {
+				this._streamingEditAbortTriggered = true;
+				logger.warn("Streaming edit aborted due to patch preview failure", {
+					toolCallId,
+					path,
+					error: `Failed to find expected lines in ${path}:\n${missing}`,
+				});
+				this.agent.abort();
+			}
+		} catch {
+			// Ignore errors during async fallback
+		}
+	}
+
+	private async _checkPreviewPatchAsync(
+		toolCallId: string,
+		path: string,
+		rename: string | undefined,
+		normalizedDiff: string,
+	): Promise<void> {
+		if (this._streamingEditAbortTriggered) return;
+		try {
+			await previewPatch(
+				{ path, op: "update", rename, diff: normalizedDiff },
+				{
+					cwd: this.sessionManager.getCwd(),
+					allowFuzzy: this.settingsManager.getEditFuzzyMatch(),
+					fuzzyThreshold: this.settingsManager.getEditFuzzyThreshold(),
+				},
+			);
+		} catch (error) {
+			if (error instanceof ParseError) return;
+			this._streamingEditAbortTriggered = true;
+			logger.warn("Streaming edit aborted due to patch preview failure", {
+				toolCallId,
+				path,
+				error: error instanceof Error ? error.message : String(error),
+			});
+			this.agent.abort();
+		}
+	}
+
 	/** Rewrite tool call arguments in agent state and persisted session history. */
 	private async _rewriteToolCallArgs(toolCallId: string, args: Record<string, unknown>): Promise<void> {
 		let updated = false;
@@ -2042,7 +2226,7 @@ export class AgentSession {
 								error: message,
 								model: `${candidate.provider}/${candidate.id}`,
 							});
-							await new Promise((resolve) => setTimeout(resolve, delayMs));
+							await Bun.sleep(delayMs);
 						}
 					}
 
@@ -2223,9 +2407,9 @@ export class AgentSession {
 		// Create retry promise on first attempt so waitForRetry() can await it
 		// Ensure only one promise exists (avoid orphaned promises from concurrent calls)
 		if (!this._retryPromise) {
-			this._retryPromise = new Promise((resolve) => {
-				this._retryResolve = resolve;
-			});
+			const { promise, resolve } = Promise.withResolvers<void>();
+			this._retryPromise = promise;
+			this._retryResolve = resolve;
 		}
 
 		if (this._retryAttempt > settings.maxRetries) {
@@ -2280,7 +2464,7 @@ export class AgentSession {
 		}
 		this._retryAbortController = new AbortController();
 		try {
-			await this._sleep(delayMs, this._retryAbortController.signal);
+			await abortableSleep(delayMs, this._retryAbortController.signal);
 		} catch {
 			// Aborted during sleep - emit end event so UI can clean up
 			const attempt = this._retryAttempt;
@@ -2307,25 +2491,6 @@ export class AgentSession {
 		return true;
 	}
 
-	/**
-	 * Sleep helper that respects abort signal.
-	 */
-	private _sleep(ms: number, signal?: AbortSignal): Promise<void> {
-		return new Promise((resolve, reject) => {
-			if (signal?.aborted) {
-				reject(new Error("Aborted"));
-				return;
-			}
-
-			const timeout = setTimeout(resolve, ms);
-
-			signal?.addEventListener("abort", () => {
-				clearTimeout(timeout);
-				reject(new Error("Aborted"));
-			});
-		});
-	}
-
 	/**
 	 * Cancel in-progress retry.
 	 */

package/src/core/agent-storage.ts

@@ -1,9 +1,9 @@
 import { Database } from "bun:sqlite";
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath } from "../config";
 import type { AuthCredential } from "./auth-storage";
-import { logger } from "./logger";
 import type { Settings } from "./settings-manager";
 
 /** Prepared SQLite statement type from bun:sqlite */

package/src/core/auth-storage.ts

@@ -13,12 +13,13 @@ import {
 	loginGeminiCli,
 	loginGitHubCopilot,
 	loginOpenAICodex,
+	type OAuthController,
 	type OAuthCredentials,
 	type OAuthProvider,
 } from "@oh-my-pi/pi-ai";
+import { logger } from "@oh-my-pi/pi-utils";
 import { getAgentDbPath, getAuthPath } from "../config";
 import { AgentStorage } from "./agent-storage";
-import { logger } from "./logger";
 import { migrateJsonStorage } from "./storage-migration";
 
 export type ApiKeyCredential = {
@@ -545,51 +546,40 @@ export class AuthStorage {
 	 */
 	async login(
 		provider: OAuthProvider,
-		callbacks: {
+		ctrl: OAuthController & {
+			/** onAuth is required by auth-storage but optional in OAuthController */
 			onAuth: (info: { url: string; instructions?: string }) => void;
+			/** onPrompt is required for some providers (github-copilot, openai-codex) */
 			onPrompt: (prompt: { message: string; placeholder?: string }) => Promise<string>;
-			onProgress?: (message: string) => void;
-			/** For providers with local callback servers (e.g., openai-codex), races with browser callback */
-			onManualCodeInput?: () => Promise<string>;
-			/** For cancellation support (e.g., github-copilot polling) */
-			signal?: AbortSignal;
 		},
 	): Promise<void> {
 		let credentials: OAuthCredentials;
 
 		switch (provider) {
 			case "anthropic":
-				credentials = await loginAnthropic(
-					(url) => callbacks.onAuth({ url }),
-					() => callbacks.onPrompt({ message: "Paste the authorization code:" }),
-				);
+				credentials = await loginAnthropic(ctrl);
 				break;
 			case "github-copilot":
 				credentials = await loginGitHubCopilot({
-					onAuth: (url, instructions) => callbacks.onAuth({ url, instructions }),
-					onPrompt: callbacks.onPrompt,
-					onProgress: callbacks.onProgress,
-					signal: callbacks.signal,
+					onAuth: (url, instructions) => ctrl.onAuth({ url, instructions }),
+					onPrompt: ctrl.onPrompt,
+					onProgress: ctrl.onProgress,
+					signal: ctrl.signal,
 				});
 				break;
 			case "google-gemini-cli":
-				credentials = await loginGeminiCli(callbacks.onAuth, callbacks.onProgress, callbacks.onManualCodeInput);
+				credentials = await loginGeminiCli(ctrl);
 				break;
 			case "google-antigravity":
-				credentials = await loginAntigravity(callbacks.onAuth, callbacks.onProgress, callbacks.onManualCodeInput);
+				credentials = await loginAntigravity(ctrl);
 				break;
 			case "openai-codex":
-				credentials = await loginOpenAICodex({
-					onAuth: callbacks.onAuth,
-					onPrompt: callbacks.onPrompt,
-					onProgress: callbacks.onProgress,
-					onManualCodeInput: callbacks.onManualCodeInput,
-				});
+				credentials = await loginOpenAICodex(ctrl);
 				break;
 			case "cursor":
 				credentials = await loginCursor(
-					(url) => callbacks.onAuth({ url }),
-					callbacks.onProgress ? () => callbacks.onProgress?.("Waiting for browser authentication...") : undefined,
+					(url) => ctrl.onAuth({ url }),
+					ctrl.onProgress ? () => ctrl.onProgress?.("Waiting for browser authentication...") : undefined,
 				);
 				break;
 			default: