@xopcai/xopc 0.0.368 → 0.0.370

package/dist/src/browser/drivers/playwright-driver.js

@@ -1,3 +1,5 @@
+import { browserDom } from "../../../packages/browser-control-contract/src/automation.js";
+import "../../../packages/browser-control-contract/src/index.js";
 import { verifyBrowserExpectation } from "../verification/expectation.js";
 import { randomUUID } from "node:crypto";
 //#region src/browser/drivers/playwright-driver.ts
@@ -174,6 +176,47 @@ var PlaywrightDriver = class {
 		try {
 			throwIfAborted(signal);
 			const state = await this.activeState(sessionId);
+			if (input.action === "resolve") {
+				const resolved = await state.page.evaluate(browserDom, {
+					operation: "resolve",
+					target: input.semanticTarget
+				});
+				if (resolved.matches !== 1) return {
+					ok: false,
+					error: {
+						code: "TARGET_NOT_FOUND",
+						message: `Semantic target must match exactly one element; matched ${resolved.matches}.`
+					}
+				};
+				const handle = await state.page.locator(`[data-xopc-ref="${resolved.node.ref}"]`).elementHandle();
+				if (!handle) return targetNotFound(resolved.node.ref);
+				state.refs.set(resolved.node.ref, handle);
+				state.revision += 1;
+				const observation = {
+					sessionId,
+					tabId: state.id,
+					revision: state.revision,
+					documentId: state.documentId,
+					url: state.page.url(),
+					title: await state.page.title(),
+					nodes: [resolved.node],
+					changes: {
+						added: [resolved.node],
+						changed: [],
+						removed: []
+					}
+				};
+				return {
+					ok: true,
+					receipt: {
+						action: "resolve",
+						risk: "read",
+						durationMs: Date.now() - startedAt,
+						verified: true,
+						observation
+					}
+				};
+			}
 			if ("revision" in input && input.revision !== state.revision) return stale(await this.observe(sessionId, {
 				action: "observe",
 				visual: "never"
@@ -188,6 +231,9 @@ var PlaywrightDriver = class {
 					await handle.fill(input.value, { timeout: this.options.actionTimeoutMs });
 					if (input.submit) await handle.press("Enter");
 					break;
+				case "check":
+					await handle.setChecked(input.checked, { timeout: this.options.actionTimeoutMs });
+					break;
 				case "select":
 					await handle.selectOption(input.value);
 					break;

package/dist/src/browser/index.d.ts

@@ -4,8 +4,7 @@ export type { BrowserDriver, BrowserPrimitiveInput } from './drivers/browser-dri
 export { PlaywrightDriver, type PlaywrightDriverOptions } from './drivers/playwright-driver.js';
 export { ExtensionDriver } from './drivers/extension-driver.js';
 export { formatBrowserObservation } from './observation/format.js';
-export { classifyBrowserRisk, browserRiskNeedsApproval } from './policy/browser-policy.js';
-export { createBrowserApproval, consumeBrowserApproval, decideBrowserApproval, listBrowserApprovals, } from './policy/approval-store.js';
+export { classifyBrowserRisk } from './policy/browser-policy.js';
 export { verifyBrowserExpectation } from './verification/expectation.js';
 export { BrowserNotReadyError, buildBrowserSetupDeepLink, checkBrowserReadiness, type BrowserDriverKind, type BrowserNotReadyReason, type BrowserSetupHint, } from './readiness.js';
 export { assertBrowserUrlAllowed, checkPostRedirectUrl, containsApiKeyPattern, isAlwaysBlockedUrl, } from './url-policy.js';

package/dist/src/browser/index.js

@@ -1,6 +1,5 @@
 import { assertBrowserUrlAllowed, checkPostRedirectUrl, containsApiKeyPattern, isAlwaysBlockedUrl } from "./url-policy.js";
-import { consumeBrowserApproval, createBrowserApproval, decideBrowserApproval, listBrowserApprovals } from "./policy/approval-store.js";
-import { browserRiskNeedsApproval, classifyBrowserRisk } from "./policy/browser-policy.js";
+import { classifyBrowserRisk } from "./policy/browser-policy.js";
 import { BrowserRuntime } from "./runtime/browser-runtime.js";
 import { ExtensionDriver } from "./drivers/extension-driver.js";
 import { verifyBrowserExpectation } from "./verification/expectation.js";
@@ -8,4 +7,4 @@ import { PlaywrightDriver } from "./drivers/playwright-driver.js";
 import { createBrowserDriver } from "./drivers/create-driver.js";
 import { formatBrowserObservation } from "./observation/format.js";
 import { BrowserNotReadyError, buildBrowserSetupDeepLink, checkBrowserReadiness } from "./readiness.js";
-export { BrowserNotReadyError, BrowserRuntime, ExtensionDriver, PlaywrightDriver, assertBrowserUrlAllowed, browserRiskNeedsApproval, buildBrowserSetupDeepLink, checkBrowserReadiness, checkPostRedirectUrl, classifyBrowserRisk, consumeBrowserApproval, containsApiKeyPattern, createBrowserApproval, createBrowserDriver, decideBrowserApproval, formatBrowserObservation, isAlwaysBlockedUrl, listBrowserApprovals, verifyBrowserExpectation };
+export { BrowserNotReadyError, BrowserRuntime, ExtensionDriver, PlaywrightDriver, assertBrowserUrlAllowed, buildBrowserSetupDeepLink, checkBrowserReadiness, checkPostRedirectUrl, classifyBrowserRisk, containsApiKeyPattern, createBrowserDriver, formatBrowserObservation, isAlwaysBlockedUrl, verifyBrowserExpectation };

package/dist/src/browser/policy/browser-policy.d.ts

@@ -1,3 +1,2 @@
 import type { BrowserActionInput, BrowserNode, BrowserRiskLevel } from '@xopcai/browser-control-contract';
 export declare function classifyBrowserRisk(input: BrowserActionInput, target?: BrowserNode): BrowserRiskLevel;
-export declare function browserRiskNeedsApproval(risk: BrowserRiskLevel): boolean;

package/dist/src/browser/policy/browser-policy.js

@@ -20,8 +20,5 @@ function classifyBrowserRisk(input, target) {
 	if (EXTERNAL_EFFECT_PATTERN.test(label)) return "external_effect";
 	return "draft";
 }
-function browserRiskNeedsApproval(risk) {
-	return risk === "external_effect" || risk === "destructive" || risk === "sensitive";
-}
 //#endregion
-export { browserRiskNeedsApproval, classifyBrowserRisk };
+export { classifyBrowserRisk };

package/dist/src/browser/providers/index.d.ts

@@ -1,4 +1,4 @@
 export type { CloudBrowserProvider, CloudBrowserProviderConfig } from './types.js';
 export { BrowserbaseProvider } from './browserbase.js';
 export { BrowserUseProvider } from './browser-use.js';
-export { ExtensionBrowserProvider } from './extension.js';
+export { RealtimeExtensionBrowserProvider } from './realtime-extension.js';

package/dist/src/browser/providers/index.js

@@ -1,4 +1,4 @@
 import { BrowserbaseProvider } from "./browserbase.js";
 import { BrowserUseProvider } from "./browser-use.js";
-import { ExtensionBrowserProvider } from "./extension.js";
-export { BrowserUseProvider, BrowserbaseProvider, ExtensionBrowserProvider };
+import { RealtimeExtensionBrowserProvider } from "./realtime-extension.js";
+export { BrowserUseProvider, BrowserbaseProvider, RealtimeExtensionBrowserProvider };

package/dist/src/browser/providers/realtime-extension.d.ts

@@ -12,7 +12,7 @@ export declare class RealtimeExtensionBrowserProvider {
     constructor(runtime: EndpointToolRuntime, config?: RealtimeExtensionProviderConfig);
     start(): Promise<void>;
     waitForConnection(timeoutMs?: number): Promise<void>;
-    send(input: BrowserActionInput, timeoutMs?: number, visualFallback?: boolean): Promise<BrowserWireResult>;
+    send(input: BrowserActionInput, timeoutMs?: number, visualFallback?: boolean, signal?: AbortSignal): Promise<BrowserWireResult>;
     isConnected(): boolean;
     getConnectionStatus(): {
         socketConnected: boolean;

package/dist/src/browser/providers/realtime-extension.js

@@ -20,7 +20,7 @@ var RealtimeExtensionBrowserProvider = class {
 			await new Promise((resolve) => setTimeout(resolve, 200));
 		}
 	}
-	async send(input, timeoutMs = this.commandTimeout, visualFallback = true) {
+	async send(input, timeoutMs = this.commandTimeout, visualFallback = true, signal) {
 		const endpoint = this.endpointForInput(input);
 		if (!endpoint) {
 			if (input.target?.kind === "endpoint") throw new Error(`The Chrome endpoint bound to this Session is offline (${input.target.endpointId}). Reconnect that browser or bind another one.`);
@@ -31,6 +31,9 @@ var RealtimeExtensionBrowserProvider = class {
 		if (!tool) throw new Error("Connected browser extension does not support authenticated Realtime browser control. Reload or update the extension.");
 		const id = crypto.randomUUID();
 		const controller = new AbortController();
+		const abort = () => controller.abort();
+		signal?.addEventListener("abort", abort, { once: true });
+		if (signal?.aborted) controller.abort();
 		const timer = setTimeout(() => controller.abort(), timeoutMs);
 		try {
 			const value = (await this.runtime.invocations.invoke({
@@ -53,6 +56,7 @@ var RealtimeExtensionBrowserProvider = class {
 			};
 		} finally {
 			clearTimeout(timer);
+			signal?.removeEventListener("abort", abort);
 		}
 	}
 	isConnected() {

package/dist/src/browser/recordings/service.d.ts

@@ -0,0 +1,22 @@
+import type { BrowserRecordingEvent } from '@xopcai/browser-control-contract';
+import type { BrowserAutomationService, BrowserAutomationDefinition } from '../automations/index.js';
+type RecordingRow = {
+    recording_id: string;
+    principal_id: string;
+    state: string;
+    ack_seq: number;
+    final_seq: number | null;
+    automation_id: string | null;
+    error: string | null;
+};
+export declare class BrowserRecordingService {
+    private readonly automations;
+    constructor(automations: BrowserAutomationService);
+    get(id: string, principalId: string): RecordingRow | null;
+    append(id: string, principalId: string, payload: unknown): {
+        ackThrough: number;
+    };
+    finish(id: string, principalId: string, finalSeq: number): import("../automations/types.js").BrowserAutomation;
+}
+export declare function compileRecording(id: string, events: BrowserRecordingEvent[]): BrowserAutomationDefinition;
+export {};

package/dist/src/browser/recordings/service.js

@@ -0,0 +1,160 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
+import { z } from "zod";
+//#region src/browser/recordings/service.ts
+init_sqlite();
+const Target = z.object({
+	role: z.string().min(1),
+	name: z.string().max(240).optional(),
+	nameIncludes: z.string().max(240).optional(),
+	testId: z.string().max(240).optional(),
+	scope: z.object({
+		role: z.string(),
+		name: z.string().max(240)
+	}).strict().optional()
+}).strict();
+const Event = z.object({
+	id: z.string().uuid(),
+	seq: z.number().int().positive(),
+	documentId: z.string().max(200),
+	sourceSeq: z.number().int().positive(),
+	url: z.string().url().max(4096),
+	action: z.enum([
+		"navigate",
+		"click",
+		"fill",
+		"select",
+		"check",
+		"press",
+		"checkpoint",
+		"unsupported"
+	]),
+	target: Target.optional(),
+	value: z.string().max(4096).optional(),
+	checked: z.boolean().optional(),
+	key: z.enum(["Enter", "Escape"]).optional()
+}).strict();
+const Batch = z.array(Event).min(1).max(100);
+var BrowserRecordingService = class {
+	constructor(automations) {
+		this.automations = automations;
+	}
+	get(id, principalId) {
+		return getSqliteDatabase().prepare("SELECT * FROM browser_recordings WHERE recording_id=? AND principal_id=?").get(id, principalId) ?? null;
+	}
+	append(id, principalId, payload) {
+		z.string().uuid().parse(id);
+		const events = Batch.parse(payload);
+		return runSqliteWriteTransaction((db) => {
+			const now = Date.now();
+			db.prepare("INSERT OR IGNORE INTO browser_recordings (recording_id, principal_id, state, created_at_ms, updated_at_ms) VALUES (?, ?, 'recording', ?, ?)").run(id, principalId, now, now);
+			const row = this.get(id, principalId);
+			if (!row) throw new Error("Recording belongs to another device.");
+			if (Math.max(row.ack_seq, events.at(-1).seq) > 1e4) throw new Error("Recording event budget exceeded.");
+			let bytes = db.prepare("SELECT COALESCE(SUM(length(CAST(payload_json AS BLOB))),0) AS bytes FROM browser_recording_events WHERE recording_id=?").get(id).bytes;
+			for (const event of events) {
+				const prior = db.prepare("SELECT payload_json FROM browser_recording_events WHERE recording_id=? AND seq=?").get(id, event.seq);
+				const serialized = JSON.stringify(event);
+				if (prior) {
+					if (prior.payload_json !== serialized) throw new Error("Recording event conflict.");
+					continue;
+				}
+				bytes += Buffer.byteLength(serialized);
+				if (bytes > 20 * 1024 * 1024) throw new Error("Recording storage budget exceeded.");
+				if (row.state === "saved") throw new Error("Recording is already finished.");
+				if (event.seq !== this.get(id, principalId).ack_seq + 1) throw new Error("Recording event sequence has a gap.");
+				if (!["http:", "https:"].includes(new URL(event.url).protocol)) throw new Error("Only HTTP pages can be recorded.");
+				db.prepare("INSERT INTO browser_recording_events (recording_id, seq, event_id, payload_json) VALUES (?, ?, ?, ?)").run(id, event.seq, event.id, serialized);
+				db.prepare("UPDATE browser_recordings SET ack_seq=?, updated_at_ms=? WHERE recording_id=?").run(event.seq, now, id);
+			}
+			return { ackThrough: this.get(id, principalId).ack_seq };
+		});
+	}
+	finish(id, principalId, finalSeq) {
+		z.number().int().min(1).max(1e4).parse(finalSeq);
+		const row = this.get(id, principalId);
+		if (!row) throw new Error("Recording not found.");
+		if (row.state === "saved") {
+			if (row.final_seq !== finalSeq) throw new Error("Recording final sequence conflicts with the saved recording.");
+			return this.automations.get(row.automation_id);
+		}
+		if (row.ack_seq !== finalSeq) throw new Error("Recording is incomplete. Waiting for all events.");
+		const events = getSqliteDatabase().prepare("SELECT payload_json FROM browser_recording_events WHERE recording_id=? ORDER BY seq").all(id).map((item) => JSON.parse(item.payload_json));
+		const sources = /* @__PURE__ */ new Map();
+		for (const event of events) {
+			if (event.sourceSeq !== (sources.get(event.documentId) ?? 0) + 1) throw new Error("Recording is incomplete: document events are missing.");
+			sources.set(event.documentId, event.sourceSeq);
+		}
+		for (const documentId of sources.keys()) if (events.filter((event) => event.documentId === documentId).at(-1)?.action !== "checkpoint") throw new Error("Recording is incomplete: a document did not confirm its final events.");
+		const definition = compileRecording(id, events);
+		return runSqliteWriteTransaction((db) => {
+			const automation = this.automations.save({ definition });
+			db.prepare("UPDATE browser_recordings SET state='saved', final_seq=?, automation_id=?, updated_at_ms=? WHERE recording_id=?").run(finalSeq, automation.id, Date.now(), id);
+			return automation;
+		});
+	}
+};
+function compileRecording(id, events) {
+	const steps = [];
+	const inputs = {};
+	for (const event of events) {
+		if (event.action === "checkpoint") continue;
+		if (event.action === "unsupported") throw new Error(event.value || "Recording contains an unsupported action.");
+		if (event.action === "navigate") {
+			if (steps.length && ["click", "press"].includes(steps.at(-1).action)) steps.push({
+				action: "wait",
+				condition: "page_idle"
+			});
+			else if (!steps.length || steps.at(-1)?.action !== "wait") steps.push({
+				action: "navigate",
+				url: event.url
+			});
+			continue;
+		}
+		if (!event.target) throw new Error("Recording contains an unsupported target.");
+		if (event.action === "fill" || event.action === "select") {
+			const key = `value${Object.keys(inputs).length + 1}`;
+			inputs[key] = {
+				type: "string",
+				default: event.value ?? "",
+				description: event.target.name || key
+			};
+			steps.push({
+				action: event.action,
+				target: event.target,
+				value: `\${input.${key}}`
+			});
+		} else if (event.action === "check") {
+			if (event.checked === void 0) throw new Error("Recording checkbox state is missing.");
+			steps.push({
+				action: "check",
+				target: event.target,
+				checked: event.checked
+			});
+		} else if (event.action === "press") {
+			if (!event.key) throw new Error("Recording key is missing.");
+			steps.push({
+				action: "press",
+				target: event.target,
+				key: event.key
+			});
+		} else steps.push({
+			action: "click",
+			target: event.target
+		});
+	}
+	if (!steps.length || steps.length > 100) throw new Error("Recording must contain between 1 and 100 executable steps.");
+	const first = events[0];
+	return {
+		id: `recording-${id}`,
+		name: events.find((event) => event.target?.name)?.target?.name || new URL(first.url).hostname,
+		description: "Recorded browser workflow",
+		allowedDomains: [...new Set(events.map((event) => new URL(event.url).hostname))],
+		risk: steps.some((step) => ["click", "press"].includes(step.action)) ? "external_effect" : "draft",
+		inputs,
+		steps,
+		outputs: { url: { field: "url" } }
+	};
+}
+//#endregion
+export { BrowserRecordingService, compileRecording };

package/dist/src/browser/runtime/browser-runtime.d.ts

@@ -18,7 +18,7 @@ export declare class BrowserRuntime {
     closeTaskSession(taskKey: string): Promise<void>;
     private dispatch;
     private executeSequence;
-    private authorize;
+    private actionDenied;
     private validateUrl;
     private validateRedirect;
     private blockedRedirect;

package/dist/src/browser/runtime/browser-runtime.js

@@ -1,6 +1,5 @@
 import { assertBrowserUrlAllowed, checkPostRedirectUrl, containsApiKeyPattern } from "../url-policy.js";
-import { consumeBrowserApproval, createBrowserApproval } from "../policy/approval-store.js";
-import { browserRiskNeedsApproval, classifyBrowserRisk } from "../policy/browser-policy.js";
+import { classifyBrowserRisk } from "../policy/browser-policy.js";
 import { isAbsolute, relative, resolve } from "node:path";
 import { randomUUID } from "node:crypto";
 //#region src/browser/runtime/browser-runtime.ts
@@ -94,10 +93,7 @@ var BrowserRuntime = class {
 		if (input.action === "navigate") {
 			const blocked = this.validateUrl(input.url);
 			if (blocked) return failure("BLOCKED_URL", blocked);
-			const crossDomainPolicy = this.crossDomainPolicy(session.observation?.url, input.url);
-			if (crossDomainPolicy === "deny") return failure("BLOCKED_URL", "Cross-domain navigation is denied by policy.");
-			const authorization = this.authorize(session.taskKey, input, crossDomainPolicy === "ask" ? "external_effect" : "read", crossDomainPolicy);
-			if (authorization) return authorization;
+			if (this.crossDomainPolicy(session.observation?.url, input.url) === "deny") return failure("BLOCKED_URL", "Cross-domain navigation is denied by policy.");
 			const result = await driver.navigate(session.id, input, signal);
 			return this.validateRedirect(input.url, result);
 		}
@@ -105,10 +101,7 @@ var BrowserRuntime = class {
 			if (input.url) {
 				const blocked = this.validateUrl(input.url);
 				if (blocked) return failure("BLOCKED_URL", blocked);
-				const crossDomainPolicy = this.crossDomainPolicy(session.observation?.url, input.url);
-				if (crossDomainPolicy === "deny") return failure("BLOCKED_URL", "Cross-domain navigation is denied by policy.");
-				const authorization = this.authorize(session.taskKey, input, crossDomainPolicy === "ask" ? "external_effect" : "read", crossDomainPolicy);
-				if (authorization) return authorization;
+				if (this.crossDomainPolicy(session.observation?.url, input.url) === "deny") return failure("BLOCKED_URL", "Cross-domain navigation is denied by policy.");
 			}
 			const result = await driver.tabs(session.id, input, signal);
 			if (!input.url || !result.ok) return result;
@@ -117,15 +110,21 @@ var BrowserRuntime = class {
 			return blocked ? failure("BLOCKED_URL", blocked) : result;
 		}
 		if (input.action === "sequence") return this.executeSequence(driver, session, input, signal);
+		if (input.action === "resolve") return driver.perform(session.id, input, signal);
 		const target = findActionTarget(input, session.observation);
 		const risk = classifyBrowserRisk(input, target);
 		if (input.action === "upload") {
 			const invalidPath = this.invalidUploadPath(input.paths);
 			if (invalidPath) return failure("INVALID_INPUT", invalidPath);
 		}
-		const authorization = this.authorize(session.taskKey, input, risk, void 0, target);
-		if (authorization) return authorization;
-		return withRisk(await driver.perform(session.id, input, signal), risk);
+		if (this.actionDenied(input, risk)) return failure("INVALID_INPUT", `Browser action is denied by policy (${risk}).`);
+		if (input.action === "click" && target?.href) {
+			const blocked = this.validateUrl(target.href);
+			if (blocked) return failure("BLOCKED_URL", blocked);
+			if (this.crossDomainPolicy(session.observation?.url, target.href) === "deny") return failure("BLOCKED_URL", "Cross-domain navigation is denied by policy.");
+		}
+		const result = await driver.perform(session.id, input, signal);
+		return withRisk(this.validateRedirect(session.observation?.url ?? "", result), risk);
 	}
 	async executeSequence(driver, session, input, signal) {
 		const config = this.options.getConfig();
@@ -138,8 +137,7 @@ var BrowserRuntime = class {
 			const risk = classifyBrowserRisk(step, findActionTarget(step, session.observation));
 			if (riskRank(risk) > riskRank(highestRisk)) highestRisk = risk;
 		}
-		const authorization = this.authorize(session.taskKey, input, highestRisk);
-		if (authorization) return authorization;
+		if (this.actionDenied(input, highestRisk)) return failure("INVALID_INPUT", `Browser action is denied by policy (${highestRisk}).`);
 		for (const step of input.steps) {
 			const primitive = {
 				...step,
@@ -165,27 +163,13 @@ var BrowserRuntime = class {
 			}
 		};
 	}
-	authorize(conversationId, input, risk, explicitPolicy, target) {
+	actionDenied(input, risk) {
 		const security = this.options.getConfig().security;
-		const policy = explicitPolicy ?? (input.action === "upload" ? security.uploads : security.consequentialActions);
-		if (!browserRiskNeedsApproval(risk) || policy === "allow") return null;
-		if (policy === "deny") return failure("APPROVAL_REQUIRED", `Browser action is denied by policy (${risk}).`);
-		if (consumeBrowserApproval(input.approvalId, conversationId, input)) return null;
-		const approval = createBrowserApproval(conversationId, input, risk, browserApprovalSummary(input, target));
-		this.options.emit?.("browser.approval.required", approval);
-		return {
-			ok: false,
-			error: {
-				code: "APPROVAL_REQUIRED",
-				message: "This browser action needs local-owner approval before it can run.",
-				approval: {
-					id: approval.id,
-					risk,
-					summary: approval.summary,
-					expiresAt: approval.expiresAt
-				}
-			}
-		};
+		return (input.action === "upload" ? security.uploads : security.consequentialActions) === "deny" && [
+			"external_effect",
+			"destructive",
+			"sensitive"
+		].includes(risk);
 	}
 	validateUrl(url) {
 		if (containsApiKeyPattern(url)) return "URL contains a credential-like value.";
@@ -338,27 +322,6 @@ function findActionTarget(input, observation) {
 	const ref = "ref" in input && input.ref ? input.ref : input.action === "press" ? observation?.focused : void 0;
 	return ref ? observation?.nodes.find((node) => node.ref === ref) : void 0;
 }
-function browserApprovalSummary(input, target) {
-	const targetName = target?.name.trim() ? ` “${target.name.slice(0, 120)}”` : "";
-	switch (input.action) {
-		case "navigate": return `Navigate to ${safeUrlLabel(input.url)}.`;
-		case "tabs": return input.url ? `Open a tab at ${safeUrlLabel(input.url)}.` : `Change browser tabs (${input.operation}).`;
-		case "click": return `Click${targetName || ` element ${input.ref}`}.`;
-		case "fill": return `${target?.states.includes("sensitive") ? "Fill a sensitive field" : "Fill field"}${targetName || ` ${input.ref}`}${input.submit ? " and submit the form" : ""}.`;
-		case "upload": return `Upload ${input.paths.length} file${input.paths.length === 1 ? "" : "s"}${targetName ? ` using${targetName}` : ""}.`;
-		case "press": return `Press ${input.key}${targetName ? ` on${targetName}` : ""}.`;
-		case "sequence": return `Run ${input.steps.length} browser actions as one sequence.`;
-		default: return `Run browser action “${input.action}”${targetName ? ` on${targetName}` : ""}.`;
-	}
-}
-function safeUrlLabel(raw) {
-	try {
-		const url = new URL(raw);
-		return `${url.origin}${url.pathname}`.slice(0, 240);
-	} catch {
-		return "the requested URL";
-	}
-}
 function withoutVisual(value) {
 	if (!value || typeof value !== "object") return value;
 	return JSON.parse(JSON.stringify(value, (key, child) => key === "visual" ? void 0 : child));

package/dist/src/chat-commands/builtins/model.js

@@ -66,10 +66,10 @@ const switchCommand = {
 		"group"
 	],
 	acceptsArgs: true,
-	examples: ["/switch openai/gpt-5.6", "/switch anthropic/claude-sonnet-5"],
+	examples: ["/switch openai/gpt-6-sol", "/switch anthropic/claude-sonnet-5"],
 	handler: async (ctx, args) => {
 		if (!args.trim()) return {
-			content: joinBlocks("❌ Missing model ref.", "**Usage:** `/switch provider/model-id`", "Run `/models` — each line shows a display name and a `provider/model` ref in backticks. Copy that ref.", "**Example:** `/switch openai/gpt-5.6`"),
+			content: joinBlocks("❌ Missing model ref.", "**Usage:** `/switch provider/model-id`", "Run `/models` — each line shows a display name and a `provider/model` ref in backticks. Copy that ref.", "**Example:** `/switch openai/gpt-6-sol`"),
 			success: false
 		};
 		await ctx.setTyping(true);

package/dist/src/cli/command-manifest.js

@@ -97,7 +97,7 @@ const ROOT_HELP_COMMANDS = [
 	},
 	{
 		name: "mcp",
-		description: "Expose selected Gateway capabilities over MCP"
+		description: "Manage native pi MCP servers and expose Gateway capabilities"
 	},
 	{
 		name: "platform",

package/dist/src/cli/commands/doctor/checks/database-schema.js

@@ -53,7 +53,7 @@ async function checkDatabaseSchema(ctx) {
 		id: "database-schema",
 		label: "Database schema",
 		status: "pass",
-		message: `SQLite schema v${status.dbVersion} (current release v237).`,
+		message: `SQLite schema v${status.dbVersion} (current release v241).`,
 		hints: []
 	};
 }

package/dist/src/cli/commands/extension-agent-plugin.js

@@ -1,10 +1,6 @@
-import { pluginServerId } from "../../extensions/agent-plugins/validation.js";
 import { AgentPluginStore } from "../../extensions/agent-plugins/store.js";
-import { savePluginAuthBinding } from "../../extensions/agent-plugins/auth.js";
-import { materializePluginServers } from "../../extensions/agent-plugins/mcp-adapter.js";
 import { loadConfig } from "../../config/loader.js";
 import { getContextWithOpts } from "../context.js";
-import { getMcpOAuthManager } from "../../agent/mcp/oauth/mcp-oauth-manager.js";
 import { isAgentPluginArchive, withAgentPluginSource } from "../../extensions/agent-plugins/sources.js";
 import { removePluginCredentials } from "../../extensions/agent-plugins/credentials.js";
 import { join, resolve } from "node:path";
@@ -63,21 +59,6 @@ function addAgentPluginLifecycleCommands(command) {
 		store.remove(id, options.removeData);
 		console.log(`Removed ${raw}; credentials ${options.removeCredentials ? "deleted" : "retained"}${options.removeData ? ", plugin data deleted" : ", plugin data retained"}.`);
 	});
-	command.command("connect").argument("<id>", "plugin:<name>").requiredOption("--mcp <server>", "MCP server name").action(async (raw, options) => {
-		const store = new AgentPluginStore();
-		const id = raw.replace(/^plugin:/, "");
-		const plugin = store.get(id);
-		if (!plugin || plugin.readiness === "blocked") throw new Error("Plugin is unavailable");
-		await savePluginAuthBinding(store, id, options.mcp, { mode: "oauth" });
-		const serverId = pluginServerId(id, options.mcp);
-		const server = materializePluginServers(plugin, store)[serverId];
-		if (!server) throw new Error("MCP server not found");
-		const status = await getMcpOAuthManager(server).start({
-			serverId,
-			rawServer: server
-		});
-		console.log(JSON.stringify(status, null, 2));
-	});
 }
 //#endregion
 export { addAgentPluginLifecycleCommands, installAgentPluginFromCli, isAgentPluginSource };

package/dist/src/cli/commands/mcp.js

@@ -1,12 +1,46 @@
+import { getNativePiAgentDir, prepareNativeMcpConfig } from "../../agent/mcp/native-mcp.js";
 import { loadConfig } from "../../config/loader.js";
 import { register } from "../registry.js";
 import { createGatewayHttpClientFromConfig } from "../../mcp/gateway-http-client.js";
 import { createCapabilityMcpServer } from "../../mcp/capability-server.js";
+import { join } from "node:path";
+import { chmodSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { main } from "@earendil-works/pi-coding-agent";
 import { Command } from "commander";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 //#region src/cli/commands/mcp.ts
 function createMcpCommand(ctx) {
-	const command = new Command("mcp").description("Expose selected Gateway capabilities over MCP");
+	const command = new Command("mcp").description("Manage native pi MCP servers and expose Gateway capabilities");
+	for (const action of [
+		"list",
+		"login",
+		"logout"
+	]) {
+		const native = command.command(action).description(`Use pi's native MCP ${action}`);
+		if (action !== "list") native.argument("<server>", "Configured MCP server ID");
+		if (action === "list") native.option("--json", "Print pi MCP diagnostics as JSON");
+		if (action === "login") native.option("--timeout <seconds>", "Browser sign-in timeout in seconds");
+		native.action(async (serverOrOptions, loginOptions) => {
+			const server = typeof serverOrOptions === "string" ? serverOrOptions : void 0;
+			const options = typeof serverOrOptions === "string" ? loginOptions : serverOrOptions;
+			const mcp = await prepareNativeMcpConfig(loadConfig(ctx.configPath), ctx.workspacePath || process.cwd());
+			if (mcp.errors.length) throw new Error(mcp.errors.join("\n"));
+			const path = join(getNativePiAgentDir(), "mcp.json");
+			if (existsSync(path) && JSON.parse(readFileSync(path, "utf8")).xopcGenerated !== true) throw new Error("The pi directory contains a user-managed mcp.json. Use a dedicated PI_CODING_AGENT_DIR for xopc.");
+			if (existsSync(path)) chmodSync(path, 384);
+			writeFileSync(path, JSON.stringify({
+				xopcGenerated: true,
+				mcpServers: Object.fromEntries(mcp.servers.map((entry) => [entry.name, entry.config]))
+			}), { mode: 384 });
+			await main([
+				"mcp",
+				action,
+				...server ? [server] : [],
+				...action === "list" && options?.json ? ["--json"] : [],
+				...action === "login" && loginOptions?.timeout ? ["--timeout", loginOptions.timeout] : []
+			]);
+		});
+	}
 	command.command("capabilities").description("Run an opt-in stdio MCP proxy for an explicit capability allowlist").requiredOption("--allow-capability <ids...>", "Exact capability IDs; no wildcards").action(async (options) => {
 		const server = createCapabilityMcpServer(createGatewayHttpClientFromConfig({ config: loadConfig(ctx.configPath) }), options.allowCapability);
 		const transport = new StdioServerTransport();
@@ -39,7 +73,7 @@ function createMcpCommand(ctx) {
 register({
 	id: "mcp",
 	name: "mcp",
-	description: "Expose selected Gateway capabilities over MCP",
+	description: "Manage native pi MCP servers and expose Gateway capabilities",
 	factory: createMcpCommand,
 	metadata: {
 		category: "utility",

package/dist/src/cli/commands/models.js

@@ -22,7 +22,7 @@ init_repository();
 init_providers();
 const IMAGE_GENERATION_IDS = new Set(listImageProviderSpecs().flatMap((provider) => provider.models.map((model) => model.id)));
 const VISION_IDS = new Set([
-	"gpt-5.6",
+	"gpt-6-sol",
 	"gpt-5.6-luna",
 	"gpt-5.6-sol",
 	"gpt-5.6-terra",

package/dist/src/cli/utils/oauth-login.js

@@ -51,8 +51,8 @@ function buildCliOAuthCallbacks(params) {
 		onPrompt: async (prompt) => input({
 			message: prompt.message,
 			validate: prompt.allowEmpty ? void 0 : (value) => value.trim().length > 0 || "Required"
-		}),
-		onManualCodeInput: params.provider.usesCallbackServer && params.provider.id !== "openai-codex" ? promptForManualCode : void 0,
+		}, { signal: prompt.signal }),
+		onManualCodeInput: params.provider.usesCallbackServer && params.provider.id !== "openai" ? promptForManualCode : void 0,
 		onProgress: (message) => {
 			params.onProgress?.(message);
 		},

package/dist/src/computer/runtime.js

@@ -173,7 +173,7 @@ var ComputerRuntime = class {
 				const metadata = (await readComputerJson(response, 2 * 1024 * 1024)).data?.find((item) => item.id === model.id)?.xopc;
 				const parsedDeployment = z.object({
 					revision: z.string().regex(/^[a-f0-9]{64}$/),
-					origin: z.string().url()
+					origin: z.string().url().optional()
 				}).safeParse(metadata?.computerDeployment);
 				const parsedLimits = ComputerServiceLimitsSchema.optional().safeParse(metadata?.computerLimits);
 				if (!parsedDeployment.success || !parsedLimits.success) throw new Error("COMPUTER_DEPLOYMENT_UNAVAILABLE");
@@ -204,7 +204,7 @@ var ComputerRuntime = class {
 					profile,
 					origin: new URL(model.baseUrl).origin,
 					runtimeLocation: "unknown",
-					...deployment ? { upstreamOrigin: deployment.origin } : {}
+					...deployment?.origin ? { upstreamOrigin: deployment.origin } : {}
 				},
 				createdAt: Date.now(),
 				actions: 0,