@xopcai/xopc 0.0.414 → 0.0.416

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

@@ -17,11 +17,14 @@ var ExtensionDriver = class {
 	async createSession(_sessionId) {
 		await this.connect();
 	}
-	async closeSession(sessionId) {
-		await this.send({
+	async closeSession(sessionId, target) {
+		const result = await this.send({
 			action: "close",
-			sessionId
+			sessionId,
+			...target ? { target } : {}
 		});
+		if ("error" in result) throw new Error(result.error.message);
+		if (!result.receipt.verified) throw new Error("Browser control release was not verified");
 	}
 	navigate(sessionId, input, signal) {
 		return this.send({

package/dist/src/browser/providers/browser-ext-install.js

@@ -9,10 +9,10 @@ import { BROWSER_EXTENSION_ID, BROWSER_NATIVE_HOST_NAME } from "../extension-ide
 import "../native-messaging-host.js";
 import { resolvePackageRoot } from "../../infra/update-check.js";
 import { dirname, join } from "node:path";
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, constants, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { execFileSync, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
+import { execFileSync, spawn } from "node:child_process";
 import { readFile, readdir, rm } from "node:fs/promises";
 import AdmZip from "adm-zip";
 //#region src/browser/providers/browser-ext-install.ts
@@ -384,6 +384,7 @@ function browserNativeHostDoctor(platform = process.platform, home = process.env
 	const manifestPaths = (platform === "win32" ? windowsRegisteredNativeManifests() : directories.map((directory) => join(directory, `${BROWSER_NATIVE_HOST_NAME}.json`))).filter((manifestPath) => {
 		try {
 			const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+			if (typeof manifest.path === "string" && platform !== "win32") accessSync(manifest.path, constants.X_OK);
 			return manifest.name === "ai.xopc.browser" && typeof manifest.path === "string" && existsSync(manifest.path) && Array.isArray(manifest.allowed_origins) && manifest.allowed_origins.includes(`chrome-extension://gopbfhaojnnhiheiikblejnpgmfmkmgd/`);
 		} catch {
 			return false;

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

@@ -5,6 +5,8 @@ export interface BrowserRuntimeOptions {
     getConfig: () => Config['browser'];
     createDriver: () => Promise<BrowserDriver>;
     allowedUploadRoots?: string[];
+    canRestoreSetupSession?: (taskKey: string, sessionId: string) => boolean;
+    isTrustedSetupUrl?: (taskKey: string, url: string) => boolean;
     emit?: (type: string, payload: unknown) => void;
     resolveTarget?: (taskKey: string) => BrowserTarget | undefined;
 }
@@ -14,8 +16,9 @@ export declare class BrowserRuntime {
     private sessionsByTask;
     constructor(options: BrowserRuntimeOptions);
     execute(taskKey: string, input: BrowserActionInput, signal?: AbortSignal): Promise<BrowserControlResult>;
+    hasSessions(): boolean;
     shutdown(): Promise<void>;
-    closeTaskSession(taskKey: string): Promise<void>;
+    closeTaskSession(taskKey: string, target?: BrowserTarget): Promise<void>;
     private dispatch;
     private executeSequence;
     private actionDenied;

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

@@ -11,7 +11,7 @@ var BrowserRuntime = class {
 	}
 	async execute(taskKey, input, signal) {
 		this.evictExpiredSessions();
-		if (!this.options.getConfig().enabled) return failure("DRIVER_UNAVAILABLE", "Browser Control is disabled.");
+		if (!this.options.getConfig().enabled && input.action !== "close") return failure("DRIVER_UNAVAILABLE", "Browser Control is disabled.");
 		if (signal?.aborted) return failure("ABORTED", "Operation was aborted.");
 		const resolvedTarget = input.target ? void 0 : this.options.resolveTarget?.(taskKey);
 		const effectiveInput = input.target || !resolvedTarget ? input : {
@@ -55,21 +55,24 @@ var BrowserRuntime = class {
 		}
 		return result;
 	}
+	hasSessions() {
+		return this.sessionsByTask.size > 0;
+	}
 	async shutdown() {
 		await this.driver?.disconnect();
 		this.driver = null;
 		this.sessionsByTask.clear();
 	}
-	async closeTaskSession(taskKey) {
+	async closeTaskSession(taskKey, target) {
 		const session = this.sessionsByTask.get(taskKey);
 		if (!session) return;
-		await this.driver?.closeSession(session.id);
+		await this.driver?.closeSession(session.id, target);
 		this.sessionsByTask.delete(taskKey);
 		this.options.emit?.("browser.session.closed", { sessionId: session.id });
 	}
 	async dispatch(driver, session, input, signal) {
 		if (input.action === "close") {
-			await this.closeTaskSession(session.taskKey);
+			await this.closeTaskSession(session.taskKey, input.target);
 			return {
 				ok: true,
 				receipt: {
@@ -91,22 +94,22 @@ var BrowserRuntime = class {
 			}
 		};
 		if (input.action === "navigate") {
-			const blocked = this.validateUrl(input.url);
+			const blocked = this.validateUrl(input.url, session.taskKey);
 			if (blocked) return failure("BLOCKED_URL", blocked);
 			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);
+			return this.validateRedirect(input.url, result, session.taskKey);
 		}
 		if (input.action === "tabs") {
 			if (input.url) {
-				const blocked = this.validateUrl(input.url);
+				const blocked = this.validateUrl(input.url, session.taskKey);
 				if (blocked) return failure("BLOCKED_URL", blocked);
 				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;
 			const finalUrl = result.receipt.tabs?.find((tab) => tab.active)?.url;
-			const blocked = finalUrl ? this.blockedRedirect(finalUrl) : "The created tab did not report its final URL.";
+			const blocked = finalUrl ? this.blockedRedirect(finalUrl, session.taskKey) : "The created tab did not report its final URL.";
 			return blocked ? failure("BLOCKED_URL", blocked) : result;
 		}
 		if (input.action === "sequence") return this.executeSequence(driver, session, input, signal);
@@ -119,12 +122,12 @@ var BrowserRuntime = class {
 		}
 		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);
+			const blocked = this.validateUrl(target.href, session.taskKey);
 			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);
+		return withRisk(this.validateRedirect(session.observation?.url ?? "", result, session.taskKey), risk);
 	}
 	async executeSequence(driver, session, input, signal) {
 		const config = this.options.getConfig();
@@ -171,27 +174,27 @@ var BrowserRuntime = class {
 			"sensitive"
 		].includes(risk);
 	}
-	validateUrl(url) {
+	validateUrl(url, taskKey) {
 		if (containsApiKeyPattern(url)) return "URL contains a credential-like value.";
 		try {
 			const host = new URL(url).hostname.toLowerCase();
-			assertBrowserUrlAllowed(url, { privateHostAllowed: this.options.getConfig().security.allowedPrivateHosts.some((candidate) => candidate.toLowerCase() === host) });
+			assertBrowserUrlAllowed(url, { privateHostAllowed: this.options.getConfig().security.allowedPrivateHosts.some((candidate) => candidate.toLowerCase() === host) || this.options.isTrustedSetupUrl?.(taskKey, url) === true });
 			return null;
 		} catch (error) {
 			return error instanceof Error ? error.message : String(error);
 		}
 	}
-	validateRedirect(requestedUrl, result) {
+	validateRedirect(requestedUrl, result, taskKey) {
 		if (!result.ok || !result.receipt.observation) return result;
 		const finalUrl = result.receipt.observation.url;
 		if (finalUrl === requestedUrl) return result;
-		const blocked = this.blockedRedirect(finalUrl);
+		const blocked = this.blockedRedirect(finalUrl, taskKey);
 		return blocked ? failure("BLOCKED_URL", blocked, result.receipt.observation) : result;
 	}
-	blockedRedirect(finalUrl) {
+	blockedRedirect(finalUrl, taskKey) {
 		try {
 			const host = new URL(finalUrl).hostname.toLowerCase();
-			return checkPostRedirectUrl(finalUrl, { privateHostAllowed: this.options.getConfig().security.allowedPrivateHosts.some((candidate) => candidate.toLowerCase() === host) });
+			return checkPostRedirectUrl(finalUrl, { privateHostAllowed: this.options.getConfig().security.allowedPrivateHosts.some((candidate) => candidate.toLowerCase() === host) || this.options.isTrustedSetupUrl?.(taskKey, finalUrl) === true });
 		} catch {
 			return "Browser returned an invalid final URL.";
 		}
@@ -222,7 +225,16 @@ var BrowserRuntime = class {
 	async resolveSession(taskKey, requestedId) {
 		const existing = this.sessionsByTask.get(taskKey);
 		if (existing) return !requestedId || requestedId === existing.id ? existing : null;
-		if (requestedId) return null;
+		if (requestedId) {
+			if (!this.options.canRestoreSetupSession?.(taskKey, requestedId)) return null;
+			const restored = {
+				id: requestedId,
+				taskKey,
+				lastUsedAt: Date.now()
+			};
+			this.sessionsByTask.set(taskKey, restored);
+			return restored;
+		}
 		const session = {
 			id: randomUUID(),
 			taskKey,

package/dist/src/browser/setup/repository.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserSetup } from './types.js';
+export declare function readBrowserSetup(id: string): BrowserSetup | undefined;
+export declare function findBrowserSetup(conversationId: string, agentId: string): BrowserSetup | undefined;
+export declare function createBrowserSetup(conversationId: string, agentId: string, configRevision: string): BrowserSetup;
+export declare function saveBrowserSetup(next: BrowserSetup, expectedRevision: number): BrowserSetup;

package/dist/src/browser/setup/repository.js

@@ -0,0 +1,42 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { randomUUID } from "node:crypto";
+//#region src/browser/setup/repository.ts
+init_transaction();
+function readBrowserSetup(id) {
+	const row = getSqliteDatabase().prepare("SELECT payload_json FROM browser_setup_runs WHERE id = ?").get(id);
+	return row ? JSON.parse(row.payload_json) : void 0;
+}
+function findBrowserSetup(conversationId, agentId) {
+	const row = getSqliteDatabase().prepare("SELECT payload_json FROM browser_setup_runs WHERE conversation_id = ? AND agent_id = ? ORDER BY updated_at DESC, rowid DESC LIMIT 1").get(conversationId, agentId);
+	return row ? JSON.parse(row.payload_json) : void 0;
+}
+function createBrowserSetup(conversationId, agentId, configRevision) {
+	return runSqliteWriteTransaction((db) => {
+		const existing = findBrowserSetup(conversationId, agentId);
+		if (existing && existing.state !== "cancelled" && existing.state !== "completed") return existing;
+		const now = Date.now();
+		const setup = {
+			id: randomUUID(),
+			conversationId,
+			agentId,
+			configRevision,
+			state: "plan_ready",
+			revision: 1,
+			createdAt: now,
+			updatedAt: now
+		};
+		db.prepare("INSERT INTO browser_setup_runs (id, conversation_id, agent_id, revision, updated_at, payload_json) VALUES (?, ?, ?, ?, ?, ?)").run(setup.id, conversationId, agentId, setup.revision, now, JSON.stringify(setup));
+		return setup;
+	});
+}
+function saveBrowserSetup(next, expectedRevision) {
+	next = {
+		...next,
+		revision: expectedRevision + 1,
+		updatedAt: Date.now()
+	};
+	if (getSqliteDatabase().prepare("UPDATE browser_setup_runs SET revision = ?, updated_at = ?, payload_json = ? WHERE id = ? AND revision = ?").run(next.revision, next.updatedAt, JSON.stringify(next), next.id, expectedRevision).changes !== 1) throw new Error("SETUP_CONFLICT: Configuration progress changed. Read it again.");
+	return next;
+}
+//#endregion
+export { createBrowserSetup, findBrowserSetup, readBrowserSetup, saveBrowserSetup };

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

@@ -0,0 +1,152 @@
+import { type BrowserActionInput, type BrowserControlResult } from '@xopcai/browser-control-contract';
+import type { BrowserSetupView } from '@xopcai/gateway-contract';
+import type { Config } from '../../config/schema.js';
+import type { EndpointToolRuntime } from '../../endpoint-tools/index.js';
+import type { BrowserSetup } from './types.js';
+export declare const browserConfigRevision: (config: Config) => string;
+export interface BrowserSetupDeps {
+    getConfig: () => Config;
+    saveConfig: (next: Config, expected: Config) => Promise<{
+        saved: boolean;
+        error?: string;
+    }>;
+    endpoints: EndpointToolRuntime;
+    canUseBrowser: (agentId: string) => boolean;
+    canSwitchDriver?: (conversationId: string) => boolean;
+    policyRevision?: (agentId: string) => string;
+    prepare: () => Promise<unknown>;
+    release: (endpointId: string, sessionId: string) => Promise<BrowserControlResult>;
+    open: (action: 'chrome' | 'folder' | 'both') => Promise<unknown>;
+    doctor: () => Promise<{
+        installed: boolean;
+        needsRefresh?: boolean;
+        extensionDir?: string;
+        nativeHost?: {
+            installed: boolean;
+        };
+    }>;
+}
+/** Mutations require a local-owner grant created by the product UI, never model-supplied identity. */
+export declare class BrowserSetupService {
+    private readonly deps;
+    private readonly preparing;
+    constructor(deps: BrowserSetupDeps);
+    private policyRevision;
+    endpoints(): {
+        endpointId: string;
+        principalId: string;
+        displayName: string;
+        appVersion: string;
+    }[];
+    owned(id: string, conversationId: string, agentId: string): BrowserSetup;
+    view(setup: BrowserSetup): BrowserSetupView & Record<string, unknown>;
+    inspect(conversationId: string, agentId: string): Promise<{
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        ownerActionRequired: boolean;
+        supportedActions: string[];
+    }>;
+    command(command: string, args: Record<string, unknown>, context: {
+        conversationId: string;
+        agentId: string;
+    }, dryRun?: boolean): Promise<(BrowserSetupView & Record<string, unknown>) | {
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        ownerActionRequired: boolean;
+        supportedActions: string[];
+    } | {
+        message: string;
+        sceneId: string;
+        supportedConnection: string;
+        configRevision: string;
+        installation: {
+            installed: boolean;
+            needsRefresh: boolean;
+            nativeHostInstalled: boolean;
+        };
+        toolPermission: string;
+        enabled: boolean;
+        driverKind: "extension" | "playwright" | "cdp" | "remote";
+        sharedScope: string;
+        endpoints: {
+            endpointId: string;
+            principalId: string;
+            displayName: string;
+            appVersion: string;
+        }[];
+        setup: BrowserSetupView & Record<string, unknown>;
+        guidanceRefs: {
+            section?: string;
+            sceneId: string;
+            path: string;
+            resourceVersion: string;
+        }[];
+        ownerActionRequired: boolean;
+        supportedActions: string[];
+        dryRun: boolean;
+    }>;
+    approve(setup: BrowserSetup, principalId: string, revision: number): BrowserSetup;
+    private revision;
+    prepare(setup: BrowserSetup): Promise<BrowserSetup>;
+    recheck(setup: BrowserSetup): Promise<BrowserSetup>;
+    open(setup: BrowserSetup, action: 'chrome' | 'folder' | 'both'): Promise<unknown>;
+    begin(setup: BrowserSetup, endpointId: string, origin: string, revision: number): BrowserSetup;
+    cancel(setup: BrowserSetup): BrowserSetup;
+    release(setup: BrowserSetup): Promise<BrowserSetup>;
+    canRestoreSession(taskKey: string, sessionId: string): boolean;
+    allowsVerificationUrl(taskKey: string, url: string): boolean;
+    /** Called only by the real Agent browser tool, before its normal runtime/policy path. */
+    beforeAction(conversationId: string, agentId: string, input: BrowserActionInput): {
+        setupId: string;
+        attemptId: string;
+        taskKey: string;
+        input: BrowserActionInput;
+    };
+    afterAction(setupId: string, attemptId: string, input: BrowserActionInput, result: BrowserControlResult): BrowserSetup;
+}