@oh-my-pi/pi-coding-agent 4.2.2 → 4.3.0

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [4.3.0] - 2026-01-11
+
+### Added
+
+- Added Cursor provider support with browser-based OAuth authentication
+- Added default model configuration for Cursor provider (claude-sonnet-4-5)
+- Added execution bridge for Cursor tool calls including read, ls, grep, write, delete, shell, diagnostics, and MCP operations
+
+### Fixed
+
+- Improved fuzzy matching accuracy for edit operations when file and target have inconsistent indentation patterns
+
+## [4.2.3] - 2026-01-11
+
+### Changed
+
+- Changed default for `hidden` option in find tool from `false` to `true`, now including hidden files by default
+
+### Fixed
+
+- Fixed serialized auth storage initialization so OAuth refreshes in subagents don't crash
+
 ## [4.2.2] - 2026-01-11
 ### Added
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "4.2.2",
+	"version": "4.3.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -39,10 +39,10 @@
 		"prepublishOnly": "bun run generate-template && bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-ai": "4.2.2",
-		"@oh-my-pi/pi-agent-core": "4.2.2",
-		"@oh-my-pi/pi-git-tool": "4.2.2",
-		"@oh-my-pi/pi-tui": "4.2.2",
+		"@oh-my-pi/pi-ai": "4.3.0",
+		"@oh-my-pi/pi-agent-core": "4.3.0",
+		"@oh-my-pi/pi-git-tool": "4.3.0",
+		"@oh-my-pi/pi-tui": "4.3.0",
 		"@openai/agents": "^0.3.7",
 		"@sinclair/typebox": "^0.34.46",
 		"ajv": "^8.17.1",

package/src/core/auth-storage.ts

@@ -9,13 +9,14 @@ import {
 	getOAuthApiKey,
 	loginAnthropic,
 	loginAntigravity,
+	loginCursor,
 	loginGeminiCli,
 	loginGitHubCopilot,
 	loginOpenAICodex,
 	type OAuthCredentials,
 	type OAuthProvider,
 } from "@oh-my-pi/pi-ai";
-import { getAgentDbPath } from "../config";
+import { getAgentDbPath, getAuthPath } from "../config";
 import { AgentStorage } from "./agent-storage";
 import { logger } from "./logger";
 import { migrateJsonStorage } from "./storage-migration";
@@ -49,6 +50,8 @@ export interface SerializedAuthStorage {
 		}>
 	>;
 	runtimeOverrides?: Record<string, string>;
+	authPath?: string;
+	dbPath?: string;
 }
 
 /**
@@ -138,6 +141,11 @@ export class AuthStorage {
 	 */
 	static fromSerialized(data: SerializedAuthStorage): AuthStorage {
 		const instance = Object.create(AuthStorage.prototype) as AuthStorage;
+		const authPath = data.authPath ?? data.dbPath ?? getAuthPath();
+		instance.authPath = authPath;
+		instance.fallbackPaths = [];
+		instance.dbPath = data.dbPath ?? AuthStorage.resolveDbPath(authPath);
+		instance.storage = AgentStorage.open(instance.dbPath);
 		instance.data = new Map();
 		instance.runtimeOverrides = new Map();
 		instance.providerRoundRobinIndex = new Map();
@@ -186,6 +194,8 @@ export class AuthStorage {
 		return {
 			credentials,
 			runtimeOverrides: Object.keys(runtimeOverrides).length > 0 ? runtimeOverrides : undefined,
+			authPath: this.authPath,
+			dbPath: this.dbPath,
 		};
 	}
 
@@ -576,6 +586,12 @@ export class AuthStorage {
 					onManualCodeInput: callbacks.onManualCodeInput,
 				});
 				break;
+			case "cursor":
+				credentials = await loginCursor(
+					(url) => callbacks.onAuth({ url }),
+					callbacks.onProgress ? () => callbacks.onProgress?.("Waiting for browser authentication...") : undefined,
+				);
+				break;
 			default:
 				throw new Error(`Unknown OAuth provider: ${provider}`);
 		}

package/src/core/cursor/exec-bridge.ts

@@ -0,0 +1,234 @@
+import { randomUUID } from "node:crypto";
+import { rmSync, statSync } from "node:fs";
+import type {
+	AgentEvent,
+	AgentTool,
+	AgentToolContext,
+	AgentToolResult,
+	AgentToolUpdateCallback,
+} from "@oh-my-pi/pi-agent-core";
+import type { CursorExecHandlers, CursorMcpCall, ToolResultMessage } from "@oh-my-pi/pi-ai";
+import { resolveToCwd } from "../tools/path-utils";
+
+interface CursorExecBridgeOptions {
+	cwd: string;
+	tools: Map<string, AgentTool>;
+	getToolContext?: () => AgentToolContext | undefined;
+	emitEvent?: (event: AgentEvent) => void;
+}
+
+function createToolResultMessage(
+	toolCallId: string,
+	toolName: string,
+	result: AgentToolResult<unknown>,
+	isError: boolean,
+): ToolResultMessage {
+	return {
+		role: "toolResult",
+		toolCallId,
+		toolName,
+		content: result.content,
+		details: result.details,
+		isError,
+		timestamp: Date.now(),
+	};
+}
+
+function buildToolErrorResult(message: string): AgentToolResult<unknown> {
+	return {
+		content: [{ type: "text", text: message }],
+		details: {},
+	};
+}
+
+async function executeTool(
+	options: CursorExecBridgeOptions,
+	toolName: string,
+	toolCallId: string,
+	args: Record<string, unknown>,
+): Promise<ToolResultMessage> {
+	const tool = options.tools.get(toolName);
+	if (!tool) {
+		const result = buildToolErrorResult(`Tool "${toolName}" not available`);
+		return createToolResultMessage(toolCallId, toolName, result, true);
+	}
+
+	options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args });
+
+	let result: AgentToolResult<unknown>;
+	let isError = false;
+
+	const onUpdate: AgentToolUpdateCallback<unknown> | undefined = options.emitEvent
+		? (partialResult) => {
+				options.emitEvent?.({
+					type: "tool_execution_update",
+					toolCallId,
+					toolName,
+					args,
+					partialResult,
+				});
+			}
+		: undefined;
+
+	try {
+		result = await tool.execute(
+			toolCallId,
+			args as Record<string, unknown>,
+			undefined,
+			onUpdate,
+			options.getToolContext?.(),
+		);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		result = buildToolErrorResult(message);
+		isError = true;
+	}
+
+	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+
+	return createToolResultMessage(toolCallId, toolName, result, isError);
+}
+
+async function executeDelete(options: CursorExecBridgeOptions, pathArg: string, toolCallId: string) {
+	const toolName = "delete";
+	options.emitEvent?.({ type: "tool_execution_start", toolCallId, toolName, args: { path: pathArg } });
+
+	const absolutePath = resolveToCwd(pathArg, options.cwd);
+	let isError = false;
+	let result: AgentToolResult<unknown>;
+
+	try {
+		const stat = statSync(absolutePath, { throwIfNoEntry: false });
+		if (!stat) {
+			throw new Error(`File not found: ${pathArg}`);
+		}
+		if (!stat.isFile()) {
+			throw new Error(`Path is not a file: ${pathArg}`);
+		}
+
+		rmSync(absolutePath);
+
+		const sizeText = stat.size ? ` (${stat.size} bytes)` : "";
+		const message = `Deleted ${pathArg}${sizeText}`;
+		result = { content: [{ type: "text", text: message }], details: {} };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		result = buildToolErrorResult(message);
+		isError = true;
+	}
+
+	options.emitEvent?.({ type: "tool_execution_end", toolCallId, toolName, result, isError });
+	return createToolResultMessage(toolCallId, toolName, result, isError);
+}
+
+function decodeToolCallId(toolCallId?: string): string {
+	return toolCallId && toolCallId.length > 0 ? toolCallId : randomUUID();
+}
+
+function decodeMcpArgs(rawArgs: Record<string, Uint8Array>): Record<string, unknown> {
+	const decoded: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(rawArgs)) {
+		const text = new TextDecoder().decode(value);
+		try {
+			decoded[key] = JSON.parse(text);
+		} catch {
+			decoded[key] = text;
+		}
+	}
+	return decoded;
+}
+
+function formatMcpToolErrorMessage(toolName: string, availableTools: string[]): string {
+	const list = availableTools.length > 0 ? availableTools.join(", ") : "none";
+	return `MCP tool "${toolName}" not found. Available tools: ${list}`;
+}
+
+export function createCursorExecHandlers(options: CursorExecBridgeOptions): CursorExecHandlers {
+	return {
+		read: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "read", toolCallId, { path: args.path });
+			return toolResultMessage;
+		},
+		ls: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "ls", toolCallId, { path: args.path });
+			return toolResultMessage;
+		},
+		grep: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "grep", toolCallId, {
+				pattern: args.pattern,
+				path: args.path || undefined,
+				glob: args.glob || undefined,
+				outputMode: args.outputMode || undefined,
+				context: args.context ?? args.contextBefore ?? args.contextAfter ?? undefined,
+				ignoreCase: args.caseInsensitive || undefined,
+				type: args.type || undefined,
+				headLimit: args.headLimit ?? undefined,
+				multiline: args.multiline || undefined,
+			});
+			return toolResultMessage;
+		},
+		write: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const content = args.fileText ?? new TextDecoder().decode(args.fileBytes ?? new Uint8Array());
+			const toolResultMessage = await executeTool(options, "write", toolCallId, {
+				path: args.path,
+				content,
+			});
+			return toolResultMessage;
+		},
+		delete: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeDelete(options, args.path, toolCallId);
+			return toolResultMessage;
+		},
+		shell: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const timeoutSeconds =
+				args.timeout && args.timeout > 0
+					? args.timeout > 1000
+						? Math.ceil(args.timeout / 1000)
+						: args.timeout
+					: undefined;
+			const toolResultMessage = await executeTool(options, "bash", toolCallId, {
+				command: args.command,
+				workdir: args.workingDirectory || undefined,
+				timeout: timeoutSeconds,
+			});
+			return toolResultMessage;
+		},
+		diagnostics: async (args) => {
+			const toolCallId = decodeToolCallId(args.toolCallId);
+			const toolResultMessage = await executeTool(options, "lsp", toolCallId, {
+				action: "diagnostics",
+				file: args.path,
+			});
+			return toolResultMessage;
+		},
+		mcp: async (call: CursorMcpCall) => {
+			const toolName = call.toolName || call.name;
+			const toolCallId = decodeToolCallId(call.toolCallId);
+			const tool = options.tools.get(toolName);
+			if (!tool) {
+				const availableTools = Array.from(options.tools.keys()).filter((name) => name.startsWith("mcp_"));
+				const message = formatMcpToolErrorMessage(toolName, availableTools);
+				const toolResult: ToolResultMessage = {
+					role: "toolResult",
+					toolCallId,
+					toolName,
+					content: [{ type: "text", text: message }],
+					details: {},
+					isError: true,
+					timestamp: Date.now(),
+				};
+				return toolResult;
+			}
+
+			const args = Object.keys(call.args ?? {}).length > 0 ? call.args : decodeMcpArgs(call.rawArgs ?? {});
+			const toolResultMessage = await executeTool(options, toolName, toolCallId, args);
+			return toolResultMessage;
+		},
+	};
+}

package/src/core/model-resolver.ts

@@ -19,6 +19,7 @@ export const defaultModelPerProvider: Record<KnownProvider, string> = {
 	"google-antigravity": "gemini-3-pro-high",
 	"google-vertex": "gemini-2.5-pro",
 	"github-copilot": "gpt-4o",
+	cursor: "claude-sonnet-4-5",
 	openrouter: "openai/gpt-5.1-codex",
 	xai: "grok-4-fast-non-reasoning",
 	groq: "openai/gpt-oss-120b",

package/src/core/sdk.ts

@@ -27,7 +27,7 @@
  */
 
 import { join } from "node:path";
-import { Agent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { Agent, type AgentEvent, type AgentMessage, type AgentTool, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Message, Model } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
@@ -40,6 +40,7 @@ import { initializeWithSettings } from "../discovery";
 import { registerAsyncCleanup } from "../modes/cleanup";
 import { AgentSession } from "./agent-session";
 import { AuthStorage } from "./auth-storage";
+import { createCursorExecHandlers } from "./cursor/exec-bridge";
 import {
 	type CustomCommandsLoadResult,
 	loadCustomCommands as loadCustomCommandsInternal,
@@ -854,6 +855,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	time("combineTools");
 
+	let cursorEventEmitter: ((event: AgentEvent) => void) | undefined;
+	const cursorExecHandlers = createCursorExecHandlers({
+		cwd,
+		tools: toolRegistry,
+		getToolContext: toolContextStore.getContext,
+		emitEvent: (event) => cursorEventEmitter?.(event),
+	});
+
 	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
 		const defaultPrompt = await buildSystemPromptInternal({
@@ -964,7 +973,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			}
 			return key;
 		},
+		cursorExecHandlers,
 	});
+	cursorEventEmitter = (event) => agent.emitExternalEvent(event);
 	time("createAgent");
 
 	// Restore messages if session has existing data

package/src/core/tools/edit-diff.ts

@@ -49,9 +49,9 @@ function countLeadingWhitespace(line: string): number {
 		const char = line[i];
 		if (char === " " || char === "\t") {
 			count++;
-			continue;
+		} else {
+			break;
 		}
-		break;
 	}
 	return count;
 }
@@ -80,15 +80,16 @@ function computeRelativeIndentDepths(lines: string[]): number[] {
 	});
 }
 
-function normalizeLinesForMatch(lines: string[]): string[] {
-	const indentDepths = computeRelativeIndentDepths(lines);
+function normalizeLinesForMatch(lines: string[], includeDepth = true): string[] {
+	const indentDepths = includeDepth ? computeRelativeIndentDepths(lines) : null;
 	return lines.map((line, index) => {
 		const trimmed = line.trim();
+		const prefix = indentDepths ? `${indentDepths[index]}|` : "|";
 		if (trimmed.length === 0) {
-			return `${indentDepths[index]}|`;
+			return prefix;
 		}
 		const collapsed = trimmed.replace(/[ \t]+/g, " ");
-		return `${indentDepths[index]}|${collapsed}`;
+		return `${prefix}${collapsed}`;
 	});
 }
 
@@ -148,22 +149,14 @@ function computeLineOffsets(lines: string[]): number[] {
 	return offsets;
 }
 
-function findBestFuzzyMatch(
-	content: string,
-	target: string,
+function findBestFuzzyMatchCore(
+	contentLines: string[],
+	targetLines: string[],
+	offsets: number[],
 	threshold: number,
+	includeDepth: boolean,
 ): { best?: EditMatch; aboveThresholdCount: number } {
-	const contentLines = content.split("\n");
-	const targetLines = target.split("\n");
-	if (targetLines.length === 0 || target.length === 0) {
-		return { aboveThresholdCount: 0 };
-	}
-	if (targetLines.length > contentLines.length) {
-		return { aboveThresholdCount: 0 };
-	}
-
-	const targetNormalized = normalizeLinesForMatch(targetLines);
-	const offsets = computeLineOffsets(contentLines);
+	const targetNormalized = normalizeLinesForMatch(targetLines, includeDepth);
 
 	let best: EditMatch | undefined;
 	let bestScore = -1;
@@ -171,7 +164,7 @@ function findBestFuzzyMatch(
 
 	for (let start = 0; start <= contentLines.length - targetLines.length; start++) {
 		const windowLines = contentLines.slice(start, start + targetLines.length);
-		const windowNormalized = normalizeLinesForMatch(windowLines);
+		const windowNormalized = normalizeLinesForMatch(windowLines, includeDepth);
 		let score = 0;
 		for (let i = 0; i < targetLines.length; i++) {
 			score += similarityScore(targetNormalized[i], windowNormalized[i]);
@@ -196,6 +189,36 @@ function findBestFuzzyMatch(
 	return { best, aboveThresholdCount };
 }
 
+const FALLBACK_THRESHOLD = 0.8;
+
+function findBestFuzzyMatch(
+	content: string,
+	target: string,
+	threshold: number,
+): { best?: EditMatch; aboveThresholdCount: number } {
+	const contentLines = content.split("\n");
+	const targetLines = target.split("\n");
+	if (targetLines.length === 0 || target.length === 0) {
+		return { aboveThresholdCount: 0 };
+	}
+	if (targetLines.length > contentLines.length) {
+		return { aboveThresholdCount: 0 };
+	}
+
+	const offsets = computeLineOffsets(contentLines);
+
+	let result = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, true);
+
+	if (result.best && result.best.confidence < threshold && result.best.confidence >= FALLBACK_THRESHOLD) {
+		const noDepthResult = findBestFuzzyMatchCore(contentLines, targetLines, offsets, threshold, false);
+		if (noDepthResult.best && noDepthResult.best.confidence > result.best.confidence) {
+			result = noDepthResult;
+		}
+	}
+
+	return result;
+}
+
 export function findEditMatch(
 	content: string,
 	target: string,

package/src/core/tools/find.ts

@@ -20,7 +20,7 @@ const findSchema = Type.Object({
 	}),
 	path: Type.Optional(Type.String({ description: "Directory to search in (default: current directory)" })),
 	limit: Type.Optional(Type.Number({ description: "Maximum number of results (default: 1000)" })),
-	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: false)" })),
+	hidden: Type.Optional(Type.Boolean({ description: "Include hidden files (default: true)" })),
 	sortByMtime: Type.Optional(
 		Type.Boolean({ description: "Sort results by modification time, most recent first (default: false)" }),
 	),
@@ -143,7 +143,7 @@ export function createFindTool(session: ToolSession, options?: FindToolOptions):
 				})();
 				const effectiveLimit = limit ?? DEFAULT_LIMIT;
 				const effectiveType = type ?? "all";
-				const includeHidden = hidden ?? false;
+				const includeHidden = hidden ?? true;
 				const shouldSortByMtime = sortByMtime ?? false;
 
 				// If custom operations provided with glob, use that instead of fd