@tomflow/proflow-execution-browser-extension 0.1.12 → 0.1.13

package/extension/background.ts

@@ -36,10 +36,12 @@ type RuntimeMessage = {
 		| "PROFLOW_CONTENT_OBSERVATION"
 		| "PROFLOW_SIDE_PANEL_SNAPSHOT"
 		| "PROFLOW_TASK_APPLICATION"
-		| "PROFLOW_APPROVAL_APPLICATION";
+		| "PROFLOW_APPROVAL_APPLICATION"
+		| "PROFLOW_PROVISIONING_RELAY_FETCH";
 	observation?: Omit<ContentObservation, "tabId" | "windowId">;
 	operation?: string;
 	input?: Record<string, unknown>;
+	url?: string;
 };
 type BridgeConfig = { endpoint: string; token: string };
 type BridgeCommand = {
@@ -67,7 +69,25 @@ type ContentCommand = {
 	value?: string;
 	fingerprint?: string;
 };
-type ChromeTab = { id?: number; windowId?: number; url?: string };
+type ProvisioningOperation =
+	| "PROVISION_CUSTOM_GPT"
+	| "FINALIZE_CUSTOM_GPT_AUTH";
+type ProvisioningBridgeCommand = {
+	commandId: string;
+	type: ProvisioningOperation;
+	request: Record<string, unknown>;
+};
+type ProvisioningContentCommand = {
+	type: "PROFLOW_PROVISIONING_COMMAND";
+	operation: ProvisioningOperation;
+	request: Record<string, unknown>;
+};
+type ChromeTab = {
+	id?: number;
+	windowId?: number;
+	url?: string;
+	status?: "loading" | "complete";
+};
 type ChromeRuntime = {
 	runtime: {
 		id: string;
@@ -98,12 +118,17 @@ type ChromeRuntime = {
 	};
 	tabs: {
 		query(query: { url?: string }): Promise<ChromeTab[]>;
+		get(tabId: number): Promise<ChromeTab>;
 		create(create: { url: string; active: boolean }): Promise<ChromeTab>;
+		reload(tabId: number): Promise<void>;
 		update(
 			tabId: number,
 			update: { url?: string; active?: boolean },
 		): Promise<ChromeTab>;
-		sendMessage(tabId: number, message: ContentCommand): Promise<unknown>;
+		sendMessage(
+			tabId: number,
+			message: ContentCommand | ProvisioningContentCommand,
+		): Promise<unknown>;
 		captureVisibleTab(
 			windowId: number,
 			options: { format: "png" },
@@ -158,6 +183,7 @@ function parseConfig(value: unknown): BridgeConfig | null {
 
 type ManagedRuntimeConfig = {
 	proflowRuntimeBridge?: unknown;
+	proflowProvisioningBridge?: unknown;
 	proflowTaskApplication?: unknown;
 	proflowApprovalApplication?: unknown;
 };
@@ -176,6 +202,7 @@ async function bootstrapManagedRuntimeConfig(): Promise<void> {
 	if (!isRecord(raw)) return;
 	const managed = raw as ManagedRuntimeConfig;
 	const bridge = parseConfig(managed.proflowRuntimeBridge);
+	const provisioning = parseConfig(managed.proflowProvisioningBridge);
 	const task = parseConfig(managed.proflowTaskApplication);
 	const approval = parseConfig(managed.proflowApprovalApplication);
 	if (!bridge || !task || !approval) {
@@ -183,6 +210,7 @@ async function bootstrapManagedRuntimeConfig(): Promise<void> {
 	}
 	await chrome.storage.local.set({
 		proflowRuntimeBridge: bridge,
+		...(provisioning ? { proflowProvisioningBridge: provisioning } : {}),
 		proflowTaskApplication: task,
 		proflowApprovalApplication: approval,
 	});
@@ -193,6 +221,11 @@ async function bridgeConfig(): Promise<BridgeConfig | null> {
 	return parseConfig(stored.proflowRuntimeBridge);
 }
 
+async function provisioningBridgeConfig(): Promise<BridgeConfig | null> {
+	const stored = await chrome.storage.local.get("proflowProvisioningBridge");
+	return parseConfig(stored.proflowProvisioningBridge);
+}
+
 async function taskApplicationConfig(): Promise<BridgeConfig | null> {
 	const stored = await chrome.storage.local.get("proflowTaskApplication");
 	return parseConfig(stored.proflowTaskApplication);
@@ -804,6 +837,96 @@ async function executeCommand(command: BridgeCommand): Promise<unknown> {
 	throw new Error("BROWSER_PRIMITIVE_UNAVAILABLE");
 }
 
+function missingProvisioningReceiver(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return (
+		message.includes("Could not establish connection") ||
+		message.includes("Receiving end does not exist")
+	);
+}
+
+function isEditorUrl(url: string | undefined): boolean {
+	return (
+		url === "https://chatgpt.com/gpts/editor" ||
+		Boolean(url?.startsWith("https://chatgpt.com/gpts/editor/"))
+	);
+}
+
+async function provisioningContentCommand(
+	tabId: number,
+	operation: ProvisioningOperation,
+	request: Record<string, unknown>,
+): Promise<unknown> {
+	let receiverReloaded = false;
+	for (let attempt = 0; attempt < 60; attempt += 1) {
+		let response: unknown;
+		try {
+			response = await chrome.tabs.sendMessage(tabId, {
+				type: "PROFLOW_PROVISIONING_COMMAND",
+				operation,
+				request,
+			});
+		} catch (error) {
+			if (!receiverReloaded && missingProvisioningReceiver(error)) {
+				try {
+					const tab = await chrome.tabs.get(tabId);
+					if (tab.status === "complete" && isEditorUrl(tab.url)) {
+						await chrome.tabs.reload(tabId);
+						receiverReloaded = true;
+					}
+				} catch {}
+			}
+			if (attempt === 59) throw error;
+			await sleep(250);
+			continue;
+		}
+		if (!isRecord(response) || response.ok !== true) {
+			const detail =
+				isRecord(response) && typeof response.error === "string"
+					? response.error
+					: "PROVISIONING_CONTENT_FAILED";
+			if (
+				(detail === "PROVISIONING_SURFACE_NOT_READY" ||
+					detail === "GPT_EDITOR_CONFIGURE_SURFACE_NOT_READY") &&
+				attempt < 59
+			) {
+				await sleep(250);
+				continue;
+			}
+			throw new Error(detail);
+		}
+		return response.value;
+	}
+	throw new Error("PROVISIONING_CONTENT_TIMEOUT");
+}
+
+async function executeProvisioningCommand(
+	command: ProvisioningBridgeCommand,
+): Promise<unknown> {
+	if (!isRecord(command.request))
+		throw new Error("PROVISIONING_COMMAND_INVALID");
+	let editorUrl = "https://chatgpt.com/gpts/editor";
+	if (command.type === "FINALIZE_CUSTOM_GPT_AUTH") {
+		const carrierUrl = new URL(text(command.request.carrierUrl, "CARRIER_URL"));
+		const match = /^\/g\/(g-[A-Za-z0-9_-]+)$/.exec(carrierUrl.pathname);
+		if (
+			carrierUrl.origin !== "https://chatgpt.com" ||
+			carrierUrl.username !== "" ||
+			carrierUrl.password !== "" ||
+			carrierUrl.search !== "" ||
+			carrierUrl.hash !== "" ||
+			!match?.[1]
+		)
+			throw new Error("PROVISIONING_CARRIER_URL_INVALID");
+		editorUrl = `https://chatgpt.com/gpts/editor/${match[1]}`;
+	}
+	const tab = await chrome.tabs.create({ url: editorUrl, active: true });
+	return provisioningContentCommand(
+		numeric(tab.id, "TAB_ID"),
+		command.type,
+		command.request,
+	);
+}
 async function bridgeFetch(
 	config: BridgeConfig,
 	path: string,
@@ -911,7 +1034,144 @@ async function runBridgeLoop() {
 	}
 }
 
+let provisioningBridgeLoopStarted = false;
+async function runProvisioningBridgeLoop() {
+	if (provisioningBridgeLoopStarted) return;
+	provisioningBridgeLoopStarted = true;
+	while (true) {
+		const config = await provisioningBridgeConfig();
+		if (!config) {
+			await sleep(1_000);
+			continue;
+		}
+		const query = `?extensionInstanceId=${encodeURIComponent(extensionInstanceId)}`;
+		try {
+			const hello = await bridgeFetch(
+				config,
+				"/v1/provisioning/session/hello",
+				{
+					method: "POST",
+					body: JSON.stringify({
+						extensionId: chrome.runtime.id,
+						extensionInstanceId,
+					}),
+				},
+			);
+			if (!hello.ok) throw new Error("PROVISIONING_BRIDGE_HELLO_REJECTED");
+			let lastHeartbeatAt = 0;
+			while (true) {
+				if (Date.now() - lastHeartbeatAt >= 5_000) {
+					const heartbeat = await bridgeFetch(
+						config,
+						`/v1/provisioning/session/heartbeat${query}`,
+						{ method: "POST", body: "{}" },
+					);
+					if (!heartbeat.ok)
+						throw new Error("PROVISIONING_BRIDGE_HEARTBEAT_REJECTED");
+					lastHeartbeatAt = Date.now();
+				}
+				const response = await bridgeFetch(
+					config,
+					`/v1/provisioning/commands/next${query}`,
+				);
+				if (response.status === 204) {
+					await sleep(250);
+					continue;
+				}
+				if (!response.ok) throw new Error("PROVISIONING_BRIDGE_POLL_REJECTED");
+				const command = (await response.json()) as ProvisioningBridgeCommand;
+				const commandHeartbeat = setInterval(() => {
+					void bridgeFetch(
+						config,
+						`/v1/provisioning/session/heartbeat${query}`,
+						{ method: "POST", body: "{}" },
+					).catch(() => undefined);
+				}, 2_000);
+				let result: Record<string, unknown>;
+				try {
+					result = {
+						commandId: command.commandId,
+						ok: true,
+						value: await executeProvisioningCommand(command),
+					};
+				} catch (error) {
+					result = {
+						commandId: command.commandId,
+						ok: false,
+						error:
+							error instanceof Error
+								? error.message
+								: "PROVISIONING_EXTENSION_COMMAND_FAILED",
+					};
+				} finally {
+					clearInterval(commandHeartbeat);
+				}
+				const reported = await bridgeFetch(
+					config,
+					`/v1/provisioning/commands/result${query}`,
+					{ method: "POST", body: JSON.stringify(result) },
+				);
+				if (!reported.ok)
+					throw new Error("PROVISIONING_BRIDGE_RESULT_REJECTED");
+			}
+		} catch {
+			await sleep(1_000);
+		}
+	}
+}
+
+function provisioningRelayBase64(bytes: Uint8Array): string {
+	let binary = "";
+	for (let offset = 0; offset < bytes.length; offset += 0x8000)
+		binary += String.fromCharCode(...bytes.subarray(offset, offset + 0x8000));
+	return btoa(binary);
+}
+
 chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+	if (message.type === "PROFLOW_PROVISIONING_RELAY_FETCH") {
+		const rawUrl = typeof message.url === "string" ? message.url : "";
+		let parsed: URL;
+		try {
+			parsed = new URL(rawUrl);
+		} catch {
+			sendResponse({ ok: false, error: "KNOWLEDGE_RELAY_URL_INVALID" });
+			return;
+		}
+		if (
+			parsed.protocol !== "http:" ||
+			parsed.hostname !== "127.0.0.1" ||
+			!parsed.pathname.startsWith("/v1/provisioning/files/") ||
+			parsed.username !== "" ||
+			parsed.password !== "" ||
+			parsed.search !== "" ||
+			parsed.hash !== ""
+		) {
+			sendResponse({ ok: false, error: "KNOWLEDGE_RELAY_URL_INVALID" });
+			return;
+		}
+		void fetch(parsed.toString(), { cache: "no-store" }).then(
+			async (response) => {
+				if (!response.ok) {
+					sendResponse({
+						ok: false,
+						error: `KNOWLEDGE_RELAY_FETCH_FAILED:${response.status}`,
+					});
+					return;
+				}
+				const bytes = new Uint8Array(await response.arrayBuffer());
+				sendResponse({ ok: true, base64: provisioningRelayBase64(bytes) });
+			},
+			(error: unknown) =>
+				sendResponse({
+					ok: false,
+					error:
+						error instanceof Error
+							? `KNOWLEDGE_RELAY_FETCH_FAILED:${error.message}`
+							: "KNOWLEDGE_RELAY_FETCH_FAILED",
+				}),
+		);
+		return true;
+	}
 	if (
 		message.type === "PROFLOW_CONTENT_OBSERVATION" &&
 		message.observation &&
@@ -1020,6 +1280,7 @@ async function startBackgroundRuntime(): Promise<void> {
 	await bootstrapManagedRuntimeConfig();
 	await persistSnapshot();
 	void runBridgeLoop();
+	void runProvisioningBridgeLoop();
 	void runObserverRecovery();
 }