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

package/dist/src/provisioning-bridge.js

@@ -0,0 +1,314 @@
+import { createHash, randomUUID, timingSafeEqual } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createServer, } from "node:http";
+export class CustomGptProvisioningBridgeError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "CustomGptProvisioningBridgeError";
+        this.code = code;
+    }
+}
+const jsonHeaders = {
+    "content-type": "application/json; charset=utf-8",
+    "cache-control": "no-store",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(value, key) {
+    const item = value[key];
+    if (typeof item !== "string" || item.length === 0) {
+        throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", `${key} must be a non-empty string`);
+    }
+    return item;
+}
+function sha256(bytes) {
+    return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function safeRelayName(value) {
+    return (value.length > 0 &&
+        value.length <= 255 &&
+        !value.includes("/") &&
+        !value.includes("\\") &&
+        !value.includes("\0"));
+}
+function safeMime(value) {
+    return /^[a-z0-9.+-]+\/[a-z0-9.+-]+(?:;[ a-z0-9=._+-]+)?$/i.test(value);
+}
+function safeEqual(left, right) {
+    const leftBytes = Buffer.from(left);
+    const rightBytes = Buffer.from(right);
+    return (leftBytes.length === rightBytes.length &&
+        timingSafeEqual(leftBytes, rightBytes));
+}
+async function readJson(request) {
+    let body = "";
+    for await (const chunk of request) {
+        body += String(chunk);
+        if (body.length > 100_000) {
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning bridge body exceeds 100000 characters");
+        }
+    }
+    try {
+        return body.length === 0 ? {} : JSON.parse(body);
+    }
+    catch {
+        throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning bridge body is not valid JSON");
+    }
+}
+function send(response, status, value) {
+    response.writeHead(status, jsonHeaders);
+    response.end(value === undefined ? "" : JSON.stringify(value));
+}
+export async function createCustomGptProvisioningBridgeServer(options) {
+    if (options.token.length < 32) {
+        throw new TypeError("provisioning bridge token must contain at least 32 characters");
+    }
+    if (!/^[a-z]{32}$/.test(options.extensionId)) {
+        throw new TypeError("extensionId must be a canonical Chromium extension id");
+    }
+    const now = options.now ?? (() => new Date());
+    const idFactory = options.idFactory ?? randomUUID;
+    const freshnessMs = options.heartbeatFreshnessMs ?? 10_000;
+    const commandTimeoutMs = options.commandTimeoutMs ?? 180_000;
+    const expectedOrigin = `chrome-extension://${options.extensionId}`;
+    const queue = [];
+    const pending = new Map();
+    const relayFiles = new Map();
+    let session;
+    let closed = false;
+    const authenticate = (request, url) => {
+        const authorization = request.headers.authorization;
+        const origin = request.headers.origin;
+        const originlessCommandPoll = request.method === "GET" &&
+            url.pathname === "/v1/provisioning/commands/next" &&
+            (origin === undefined || origin === "null");
+        if (!authorization?.startsWith("Bearer ") ||
+            !safeEqual(authorization.slice(7), options.token) ||
+            (!originlessCommandPoll && origin !== expectedOrigin)) {
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_AUTH_INVALID", "provisioning bridge authentication failed");
+        }
+    };
+    const assertSession = (url) => {
+        if (!session) {
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_OFFLINE", "provisioning session has not completed hello");
+        }
+        if (url.searchParams.get("extensionInstanceId") !==
+            session.extensionInstanceId) {
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_AUTH_INVALID", "stale provisioning extension session");
+        }
+    };
+    const server = createServer(async (request, response) => {
+        try {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            if (request.method === "GET" &&
+                url.pathname.startsWith("/v1/provisioning/files/")) {
+                response.setHeader("access-control-allow-origin", "https://chatgpt.com");
+                response.setHeader("vary", "origin");
+                if (request.headers.origin !== undefined &&
+                    request.headers.origin !== "https://chatgpt.com" &&
+                    request.headers.origin !== expectedOrigin)
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_AUTH_INVALID", "provisioning file relay origin is invalid");
+                if (!session || now().getTime() - session.lastHeartbeatAt > freshnessMs)
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_OFFLINE", "provisioning extension heartbeat is not fresh");
+                const fileId = decodeURIComponent(url.pathname.slice("/v1/provisioning/files/".length));
+                const relay = relayFiles.get(fileId);
+                if (!relay) {
+                    send(response, 404, { error: "NOT_FOUND" });
+                    return;
+                }
+                relayFiles.delete(fileId);
+                const bytes = await readFile(relay.path);
+                if (bytes.length !== relay.sizeBytes || sha256(bytes) !== relay.sha256)
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "registered provisioning file changed before relay");
+                response.writeHead(200, {
+                    "access-control-allow-origin": "https://chatgpt.com",
+                    vary: "origin",
+                    "content-type": relay.mime,
+                    "content-length": String(bytes.length),
+                    "cache-control": "no-store",
+                    "content-disposition": `attachment; filename="${relay.name.replace(/["\r\n]/g, "_")}"`,
+                });
+                response.end(bytes);
+                return;
+            }
+            response.setHeader("access-control-allow-origin", expectedOrigin);
+            response.setHeader("vary", "origin");
+            if (request.method === "OPTIONS") {
+                response.setHeader("access-control-allow-headers", "authorization, content-type");
+                response.setHeader("access-control-allow-methods", "GET, POST, OPTIONS");
+                response.writeHead(204);
+                response.end();
+                return;
+            }
+            authenticate(request, url);
+            if (request.method === "POST" &&
+                url.pathname === "/v1/provisioning/session/hello") {
+                const body = await readJson(request);
+                if (!isRecord(body) ||
+                    stringField(body, "extensionId") !== options.extensionId) {
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_AUTH_INVALID", "provisioning extension identity mismatch");
+                }
+                session = {
+                    extensionInstanceId: stringField(body, "extensionInstanceId"),
+                    lastHeartbeatAt: now().getTime(),
+                };
+                send(response, 200, { accepted: true });
+                return;
+            }
+            assertSession(url);
+            if (request.method === "POST" &&
+                url.pathname === "/v1/provisioning/session/heartbeat") {
+                if (session)
+                    session.lastHeartbeatAt = now().getTime();
+                send(response, 200, { accepted: true });
+                return;
+            }
+            if (request.method === "GET" &&
+                url.pathname === "/v1/provisioning/commands/next") {
+                if (session)
+                    session.lastHeartbeatAt = now().getTime();
+                const command = queue.shift();
+                if (command) {
+                    const tracked = pending.get(command.commandId);
+                    if (tracked)
+                        tracked.stage = "DELIVERED";
+                }
+                send(response, command ? 200 : 204, command);
+                return;
+            }
+            if (request.method === "POST" &&
+                url.pathname === "/v1/provisioning/commands/result") {
+                const body = await readJson(request);
+                if (!isRecord(body)) {
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning command result must be an object");
+                }
+                const commandId = stringField(body, "commandId");
+                const tracked = pending.get(commandId);
+                if (!tracked) {
+                    throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning command result is stale or unknown");
+                }
+                pending.delete(commandId);
+                clearTimeout(tracked.timer);
+                if (body.ok === true)
+                    tracked.resolve(body.value);
+                else {
+                    tracked.reject(new CustomGptProvisioningBridgeError("PROVISIONING_COMMAND_FAILED", typeof body.error === "string"
+                        ? body.error
+                        : "provisioning extension command failed"));
+                }
+                send(response, 200, { accepted: true });
+                return;
+            }
+            send(response, 404, { error: "NOT_FOUND" });
+        }
+        catch (error) {
+            const bridgeError = error instanceof CustomGptProvisioningBridgeError
+                ? error
+                : new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", error instanceof Error
+                    ? error.message
+                    : "provisioning request failed");
+            send(response, bridgeError.code === "PROVISIONING_AUTH_INVALID" ? 401 : 400, { error: bridgeError.code });
+        }
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(options.port ?? 0, options.host ?? "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+        throw new Error("provisioning bridge address missing");
+    const endpoint = `http://127.0.0.1:${address.port}`;
+    const online = () => !closed &&
+        session !== undefined &&
+        now().getTime() - session.lastHeartbeatAt <= freshnessMs;
+    const requestProvisioning = (input) => {
+        if ((input.type !== "PROVISION_CUSTOM_GPT" &&
+            input.type !== "FINALIZE_CUSTOM_GPT_AUTH") ||
+            !isRecord(input.request)) {
+            return Promise.reject(new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "unsupported provisioning command"));
+        }
+        if (!online()) {
+            return Promise.reject(new CustomGptProvisioningBridgeError("PROVISIONING_OFFLINE", "provisioning extension heartbeat is not fresh"));
+        }
+        const commandId = `provisioning-command:${idFactory()}`;
+        const command = { ...input, commandId };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                const tracked = pending.get(commandId);
+                if (tracked?.stage === "QUEUED") {
+                    const index = queue.findIndex((item) => item.commandId === commandId);
+                    if (index >= 0)
+                        queue.splice(index, 1);
+                }
+                pending.delete(commandId);
+                reject(new CustomGptProvisioningBridgeError("PROVISIONING_COMMAND_TIMEOUT", "provisioning extension command result timed out"));
+            }, commandTimeoutMs);
+            pending.set(commandId, {
+                command,
+                stage: "QUEUED",
+                resolve,
+                reject,
+                timer,
+            });
+            queue.push(command);
+        });
+    };
+    const registerFiles = async (files) => {
+        if (!online())
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_OFFLINE", "provisioning extension heartbeat is not fresh");
+        if (!Array.isArray(files) || files.length === 0 || files.length > 64)
+            throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning relay file list is invalid");
+        const descriptors = [];
+        for (const file of files) {
+            if (!safeRelayName(file.name) ||
+                !safeMime(file.mime) ||
+                file.path.length === 0)
+                throw new CustomGptProvisioningBridgeError("PROVISIONING_INPUT_INVALID", "provisioning relay file metadata is invalid");
+            const bytes = await readFile(file.path);
+            const fileId = `file:${idFactory()}`;
+            const descriptor = {
+                fileId,
+                name: file.name,
+                mime: file.mime,
+                sizeBytes: bytes.length,
+                sha256: sha256(bytes),
+                url: `${endpoint}/v1/provisioning/files/${encodeURIComponent(fileId)}`,
+            };
+            relayFiles.set(fileId, { ...descriptor, path: file.path });
+            descriptors.push(descriptor);
+        }
+        return descriptors;
+    };
+    return Object.freeze({
+        endpoint,
+        provisioning: Object.freeze({
+            request: requestProvisioning,
+            registerFiles,
+        }),
+        status() {
+            return {
+                online: online(),
+                extensionInstanceId: session?.extensionInstanceId ?? null,
+                queuedCommands: queue.length,
+                pendingCommands: pending.size,
+                relayFiles: relayFiles.size,
+            };
+        },
+        async close() {
+            closed = true;
+            for (const item of pending.values()) {
+                clearTimeout(item.timer);
+                item.reject(new CustomGptProvisioningBridgeError("PROVISIONING_OFFLINE", "provisioning bridge server closed"));
+            }
+            pending.clear();
+            queue.length = 0;
+            relayFiles.clear();
+            await new Promise((resolve, reject) => server.close((error) => (error ? reject(error) : resolve())));
+        },
+    });
+}

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();
 }