@gajae-code/coding-agent 0.5.4 → 0.6.1

package/src/tools/browser/registry.ts

@@ -3,12 +3,28 @@ import { logger } from "@gajae-code/utils";
 import type { Subprocess } from "bun";
 import type { Browser, CDPSession } from "puppeteer-core";
 import { ToolAbortError, ToolError } from "../tool-errors";
-import { findFreeCdpPort, findReusableCdp, gracefulKillTreeOnce, killExistingByPath, waitForCdp } from "./attach";
+import {
+	findFreeCdpPort,
+	findReusableCdp,
+	findRunningChromeProfile,
+	gracefulKillTreeOnce,
+	killExistingByPath,
+	waitForCdp,
+} from "./attach";
 import { BROWSER_PROTOCOL_TIMEOUT_MS, launchHeadlessBrowser, loadPuppeteer, type UserAgentOverride } from "./launch";
 
 export type BrowserKind =
 	| { kind: "headless"; headless: boolean }
 	| { kind: "spawned"; path: string }
+	| {
+			kind: "chrome-profile";
+			path: string;
+			userDataDir: string;
+			profileDirectory: string;
+			background: boolean;
+			noFocus: boolean;
+			cdpPort?: number;
+	  }
 	| { kind: "connected"; cdpUrl: string };
 
 export type BrowserKindTag = BrowserKind["kind"];
@@ -24,6 +40,8 @@ export interface BrowserHandle {
 	stealth: { browserSession: CDPSession | null; override: UserAgentOverride | null };
 }
 
+type SpawnedChromeProfileKind = Extract<BrowserKind, { kind: "chrome-profile" }>;
+
 const browsers = new Map<string, BrowserHandle>();
 
 /**
@@ -39,6 +57,8 @@ function browserKey(kind: BrowserKind): string {
 			return `headless:${kind.headless ? "1" : "0"}`;
 		case "spawned":
 			return `spawned:${kind.path}`;
+		case "chrome-profile":
+			return `chrome-profile:${kind.path}:${kind.userDataDir}:${kind.profileDirectory}:${kind.cdpPort ?? 0}`;
 		case "connected":
 			return `connected:${kind.cdpUrl}`;
 	}
@@ -94,7 +114,160 @@ async function openBrowserHandle(kind: BrowserKind, opts: AcquireBrowserOptions)
 			stealth: { browserSession: null, override: null },
 		};
 	}
+	if (kind.kind === "chrome-profile") {
+		return await openChromeProfileHandle(kind, opts);
+	}
+
+	return await openSpawnedBrowserHandle(kind, opts);
+}
+
+const CHROME_PROFILE_LOCK_FILES = ["SingletonLock", "SingletonSocket", "SingletonCookie"] as const;
+
+async function hasChromeProfileLock(userDataDir: string): Promise<boolean> {
+	for (const lockFile of CHROME_PROFILE_LOCK_FILES) {
+		if (await Bun.file(path.join(userDataDir, lockFile)).exists()) return true;
+	}
+	return false;
+}
+
+const CHROME_PROFILE_MANAGED_FLAGS = new Set([
+	"--user-data-dir",
+	"--profile-directory",
+	"--remote-debugging-address",
+	"--remote-debugging-port",
+]);
+
+function filterChromeProfileAppArgs(appArgs: readonly string[] | undefined): string[] {
+	if (!appArgs?.length) return [];
+	const filtered: string[] = [];
+	for (let i = 0; i < appArgs.length; i++) {
+		const arg = appArgs[i]!;
+		const flagName = arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg;
+		if (CHROME_PROFILE_MANAGED_FLAGS.has(flagName)) {
+			if (!arg.includes("=") && i < appArgs.length - 1) i++;
+			continue;
+		}
+		filtered.push(arg);
+	}
+	return filtered;
+}
+
+export function buildChromeProfileLaunchArgs(
+	kind: SpawnedChromeProfileKind,
+	appArgs: readonly string[] | undefined,
+	port: number,
+): string[] {
+	const args = [
+		...filterChromeProfileAppArgs(appArgs),
+		`--user-data-dir=${kind.userDataDir}`,
+		`--profile-directory=${kind.profileDirectory}`,
+		`--remote-debugging-port=${port}`,
+		"--remote-debugging-address=127.0.0.1",
+	];
+	if (kind.background || kind.noFocus) args.push("--no-startup-window");
+	return args;
+}
+
+export function buildChromeProfileLaunchArgsForTest(
+	kind: SpawnedChromeProfileKind,
+	appArgs: readonly string[] | undefined,
+	port: number,
+): string[] {
+	return buildChromeProfileLaunchArgs(kind, appArgs, port);
+}
+
+export async function openChromeProfileHandle(
+	kind: SpawnedChromeProfileKind,
+	opts: AcquireBrowserOptions,
+): Promise<BrowserHandle> {
+	const exe = kind.path;
+	if (!path.isAbsolute(exe)) {
+		throw new ToolError(
+			`app.path must be absolute for app.browser="chrome" (got ${JSON.stringify(exe)}). Pass the Chrome binary path, not the .app bundle.`,
+		);
+	}
+
+	const running = await findRunningChromeProfile(
+		exe,
+		{ userDataDir: kind.userDataDir, profileDirectory: kind.profileDirectory },
+		opts.signal,
+	);
+	let cdpUrl: string;
+	let pid: number | undefined;
+	let subprocess: Subprocess | undefined;
+	if (running?.cdpUrl) {
+		logger.debug("Reusing existing Chrome profile CDP endpoint", {
+			exe,
+			pid: running.pid,
+			cdpUrl: running.cdpUrl,
+			profileDirectory: kind.profileDirectory,
+		});
+		cdpUrl = running.cdpUrl;
+		pid = running.pid;
+	} else if (running) {
+		throw new ToolError(
+			running.unsafeCdpReason ??
+				`Chrome profile ${JSON.stringify(kind.profileDirectory)} under ${kind.userDataDir} is already running without an attachable localhost CDP endpoint. ` +
+					"GJC will not kill or relaunch an existing Chrome profile. Close that Chrome profile first, or restart Chrome yourself with --remote-debugging-address=127.0.0.1 and --remote-debugging-port=<port> then use app.cdp_url.",
+		);
+	} else {
+		if (await hasChromeProfileLock(kind.userDataDir)) {
+			throw new ToolError(
+				`Chrome user data directory ${kind.userDataDir} appears to be locked by an existing Chrome process without an attachable localhost CDP endpoint. ` +
+					"GJC will not kill or relaunch an existing Chrome profile. Close that Chrome profile first, or restart Chrome yourself with --remote-debugging-address=127.0.0.1 and --remote-debugging-port=<port> then use app.cdp_url.",
+			);
+		}
+		const port = kind.cdpPort ?? (await findFreeCdpPort());
+		const launchArgs = buildChromeProfileLaunchArgs(kind, opts.appArgs, port);
+		const child = Bun.spawn([exe, ...launchArgs], {
+			stdout: "ignore",
+			stderr: "ignore",
+			stdin: "ignore",
+		});
+		child.unref();
+		subprocess = child;
+		pid = child.pid;
+		cdpUrl = `http://127.0.0.1:${port}`;
+		try {
+			await waitForCdp(cdpUrl, 30_000, opts.signal);
+		} catch (err) {
+			await gracefulKillTreeOnce(child.pid).catch(() => undefined);
+			if (err instanceof ToolAbortError) throw err;
+			if (err instanceof Error && err.name === "AbortError") throw err;
+			throw new ToolError(
+				`Failed to attach to Chrome profile ${JSON.stringify(kind.profileDirectory)} on ${cdpUrl}: ${(err as Error).message}`,
+			);
+		}
+	}
+
+	const puppeteer = await loadPuppeteer();
+	let browser: Browser;
+	try {
+		browser = await puppeteer.connect({
+			browserURL: cdpUrl,
+			defaultViewport: null,
+			protocolTimeout: BROWSER_PROTOCOL_TIMEOUT_MS,
+		});
+	} catch (err) {
+		if (subprocess) await gracefulKillTreeOnce(subprocess.pid);
+		throw new ToolError(`Connected to ${cdpUrl} but puppeteer.connect failed: ${(err as Error).message}`);
+	}
+	return {
+		key: browserKey(kind),
+		kind,
+		browser,
+		cdpUrl,
+		pid,
+		subprocess,
+		refCount: 0,
+		stealth: { browserSession: null, override: null },
+	};
+}
 
+async function openSpawnedBrowserHandle(
+	kind: Extract<BrowserKind, { kind: "spawned" }>,
+	opts: AcquireBrowserOptions,
+): Promise<BrowserHandle> {
 	const exe = kind.path;
 	if (!path.isAbsolute(exe)) {
 		throw new ToolError(
@@ -203,8 +376,9 @@ async function disposeBrowserHandle(handle: BrowserHandle, opts: { kill: boolean
 		try {
 			handle.browser.disconnect();
 		} catch (err) {
-			logger.debug("Failed to disconnect from spawned browser", { error: (err as Error).message });
+			logger.debug(`Failed to disconnect from ${handle.kind.kind} browser`, { error: (err as Error).message });
 		}
 	}
+	if (handle.kind.kind === "chrome-profile" && !handle.subprocess) return;
 	if (opts.kill && handle.pid !== undefined) await gracefulKillTreeOnce(handle.pid);
 }

package/src/tools/browser/render.ts

@@ -23,7 +23,14 @@ interface BrowserRenderArgs {
 	code?: string;
 	all?: boolean;
 	kill?: boolean;
-	app?: { path?: string; cdp_url?: string; target?: string };
+	app?: {
+		path?: string;
+		cdp_url?: string;
+		browser?: string;
+		user_data_dir?: string;
+		profile_directory?: string;
+		target?: string;
+	};
 	viewport?: { width: number; height: number; scale?: number };
 	timeout?: number;
 }
@@ -35,6 +42,7 @@ interface BrowserRenderContext {
 
 function describeBrowser(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string | undefined {
 	if (args.app?.cdp_url) return `connected ${args.app.cdp_url}`;
+	if (args.app?.browser === "chrome") return `Chrome profile ${args.app.profile_directory ?? "<profile>"}`;
 	if (args.app?.path) return `spawned ${shortenPath(args.app.path)}`;
 	switch (details?.browser) {
 		case "headless":

package/src/tools/browser.ts

@@ -21,6 +21,12 @@ const DEFAULT_TAB_NAME = "main";
 const appSchema = z.object({
 	path: z.string().describe("binary path to spawn").optional(),
 	cdp_url: z.string().describe("existing cdp endpoint").optional(),
+	browser: z.enum(["chrome"]).describe("existing browser profile mode").optional(),
+	user_data_dir: z.string().describe("Chrome user data directory containing profiles").optional(),
+	profile_directory: z.string().describe("Chrome profile directory name, e.g. Profile 10").optional(),
+	background: z.boolean().describe("prefer background/hidden Chrome profile launch when supported").optional(),
+	no_focus: z.boolean().describe("avoid focusing Chrome during profile launch when supported").optional(),
+	cdp_port: z.number().int().positive().describe("local CDP port for launched Chrome profile").optional(),
 	args: z.array(z.string()).describe("extra cli args").optional(),
 	target: z.string().describe("substring to pick a window").optional(),
 });
@@ -104,11 +110,31 @@ export interface BrowserToolDetails {
 	meta?: OutputMeta;
 }
 
+export function resolveBrowserKindForTest(params: BrowserParams, session: ToolSession): BrowserKind {
+	return resolveBrowserKind(params, session);
+}
+
 function resolveBrowserKind(params: BrowserParams, session: ToolSession): BrowserKind {
 	const app = params.app;
 	if (app?.cdp_url) {
 		return { kind: "connected", cdpUrl: app.cdp_url.replace(/\/+$/, "") };
 	}
+	if (app?.browser === "chrome") {
+		if (!app.path) throw new ToolError('app.path is required when app.browser is "chrome".');
+		if (!app.user_data_dir) throw new ToolError('app.user_data_dir is required when app.browser is "chrome".');
+		if (!app.profile_directory)
+			throw new ToolError('app.profile_directory is required when app.browser is "chrome".');
+		const exe = resolveToCwd(app.path, session.cwd);
+		return {
+			kind: "chrome-profile",
+			path: exe,
+			userDataDir: resolveToCwd(app.user_data_dir, session.cwd),
+			profileDirectory: app.profile_directory,
+			background: app.background ?? false,
+			noFocus: app.no_focus ?? false,
+			cdpPort: app.cdp_port,
+		};
+	}
 	if (app?.path) {
 		const exe = resolveToCwd(app.path, session.cwd);
 		return { kind: "spawned", path: exe };
@@ -358,6 +384,8 @@ function describeBrowser(handle: BrowserHandle): string {
 			return `headless browser (${handle.kind.headless ? "hidden" : "visible"})`;
 		case "spawned":
 			return `spawned ${handle.kind.path} (pid ${handle.pid ?? "?"})`;
+		case "chrome-profile":
+			return `Chrome profile ${handle.kind.profileDirectory} at ${handle.kind.userDataDir} (${handle.subprocess ? `pid ${handle.pid ?? "?"}` : "external CDP"})`;
 		case "connected":
 			return `connected ${handle.cdpUrl ?? handle.kind.cdpUrl}`;
 	}
@@ -369,6 +397,8 @@ function describeKind(kind: BrowserKind): string {
 			return `headless ${kind.headless ? "hidden" : "visible"}`;
 		case "spawned":
 			return `spawned:${kind.path}`;
+		case "chrome-profile":
+			return `chrome-profile:${kind.path}:${kind.userDataDir}:${kind.profileDirectory}`;
 		case "connected":
 			return `connected:${kind.cdpUrl}`;
 	}
@@ -378,6 +408,9 @@ function sameBrowserKind(a: BrowserKind, b: BrowserKind): boolean {
 	if (a.kind !== b.kind) return false;
 	if (a.kind === "headless" && b.kind === "headless") return a.headless === b.headless;
 	if (a.kind === "spawned" && b.kind === "spawned") return a.path === b.path;
+	if (a.kind === "chrome-profile" && b.kind === "chrome-profile") {
+		return a.path === b.path && a.userDataDir === b.userDataDir && a.profileDirectory === b.profileDirectory;
+	}
 	if (a.kind === "connected" && b.kind === "connected") return a.cdpUrl === b.cdpUrl;
 	return false;
 }

package/src/tools/computer/render.ts

@@ -0,0 +1,78 @@
+import type { Component } from "@gajae-code/tui";
+import { Text } from "@gajae-code/tui";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
+import type { Theme } from "../../modes/theme/theme";
+import type { ComputerToolDetails } from "../computer";
+import { formatBadge, formatErrorMessage } from "../render-utils";
+
+function asRecord(value: unknown): Record<string, unknown> {
+	return value && typeof value === "object" ? (value as Record<string, unknown>) : {};
+}
+
+function summarizeArgs(args: unknown): string {
+	const input = asRecord(args);
+	if (input.action === "batch" && Array.isArray(input.actions)) {
+		return `batch ${input.actions.length} step${input.actions.length === 1 ? "" : "s"}`;
+	}
+	const action = typeof input.action === "string" ? input.action : "computer";
+	const parts = [action];
+	if (typeof input.x === "number" && typeof input.y === "number") parts.push(`@ ${input.x},${input.y}`);
+	if (typeof input.to_x === "number" && typeof input.to_y === "number") parts.push(`→ ${input.to_x},${input.to_y}`);
+	if (typeof input.scroll_x === "number" || typeof input.scroll_y === "number") {
+		parts.push(`scroll ${input.scroll_x ?? 0},${input.scroll_y ?? 0}`);
+	}
+	if (Array.isArray(input.keys)) parts.push(`keys ${input.keys.join("+")}`);
+	if (typeof input.ms === "number") parts.push(`${input.ms}ms`);
+	return parts.join(" ");
+}
+
+export function summarizeComputerDetails(
+	details: ComputerToolDetails | undefined,
+	isError: boolean,
+	theme: Theme,
+): string {
+	if (!details) return isError ? "Computer action failed" : "Computer action completed";
+	if (details.action === "batch" && details.steps) {
+		const successCount = details.steps.filter(s => s.status === "success").length;
+		const parts: string[] = [`batch ${successCount}/${details.steps.length}`];
+		if (details.screenshot) parts.push(`screenshot ${details.screenshot.widthPx}x${details.screenshot.heightPx}`);
+		if (details.code) parts.push(theme.fg(isError ? "error" : "muted", details.code));
+		return parts.join(" ");
+	}
+	const parts: string[] = [details.action];
+	if (details.x !== undefined && details.y !== undefined) parts.push(`@ ${details.x},${details.y}`);
+	if (details.toX !== undefined && details.toY !== undefined) parts.push(`→ ${details.toX},${details.toY}`);
+	if (details.scrollX !== undefined || details.scrollY !== undefined)
+		parts.push(`scroll ${details.scrollX ?? 0},${details.scrollY ?? 0}`);
+	if (details.screenshot) {
+		const shot = details.screenshot;
+		parts.push(`screenshot ${shot.widthPx}x${shot.heightPx}`);
+		if (shot.pngBytes !== undefined) parts.push(`${shot.pngBytes} bytes`);
+		if (shot.captureId) parts.push(`capture ${shot.captureId}`);
+	}
+	if (details.supervisor) parts.push(`supervisor ${details.supervisor}`);
+	if (details.code) parts.push(theme.fg(isError ? "error" : "muted", details.code));
+	return parts.join(" ");
+}
+
+export const computerToolRenderer = {
+	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme): Component {
+		return new Text(`${formatBadge("computer", "accent", theme)} ${summarizeArgs(args)}`);
+	},
+	renderResult(
+		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
+		_options: RenderResultOptions,
+		theme: Theme,
+	): Component {
+		if (result.isError) {
+			const details = result.details as ComputerToolDetails | undefined;
+			return new Text(
+				formatErrorMessage(details?.message ?? result.content.find(c => c.type === "text")?.text, theme),
+			);
+		}
+		return new Text(
+			`${formatBadge("computer", "success", theme)} ${summarizeComputerDetails(result.details as ComputerToolDetails | undefined, false, theme)}`,
+		);
+	},
+	mergeCallAndResult: true,
+};