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

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "execution-browser-extension",
     packageName: "@tomflow/proflow-execution-browser-extension",
-    moduleVersion: "0.1.12",
+    moduleVersion: "0.1.13",
     kind: "browser-extension",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",
@@ -16,6 +16,10 @@ export const descriptor = {
             contractRef: "execution-browser-executor",
             version: "1.0.0",
         },
+        {
+            contractRef: "custom-gpt-web-provisioning",
+            version: "1.0.0",
+        },
     ],
     requires: [
         {

package/dist/extension/background.js

@@ -13912,6 +13912,7 @@ async function bootstrapManagedRuntimeConfig() {
   if (!isRecord(raw)) return;
   const managed = raw;
   const bridge = parseConfig(managed.proflowRuntimeBridge);
+  const provisioning = parseConfig(managed.proflowProvisioningBridge);
   const task = parseConfig(managed.proflowTaskApplication);
   const approval = parseConfig(managed.proflowApprovalApplication);
   if (!bridge || !task || !approval) {
@@ -13919,6 +13920,7 @@ async function bootstrapManagedRuntimeConfig() {
   }
   await chrome.storage.local.set({
     proflowRuntimeBridge: bridge,
+    ...provisioning ? { proflowProvisioningBridge: provisioning } : {},
     proflowTaskApplication: task,
     proflowApprovalApplication: approval
   });
@@ -13927,6 +13929,10 @@ async function bridgeConfig() {
   const stored = await chrome.storage.local.get("proflowRuntimeBridge");
   return parseConfig(stored.proflowRuntimeBridge);
 }
+async function provisioningBridgeConfig() {
+  const stored = await chrome.storage.local.get("proflowProvisioningBridge");
+  return parseConfig(stored.proflowProvisioningBridge);
+}
 async function taskApplicationConfig() {
   const stored = await chrome.storage.local.get("proflowTaskApplication");
   return parseConfig(stored.proflowTaskApplication);
@@ -14379,6 +14385,68 @@ async function executeCommand(command) {
   }
   throw new Error("BROWSER_PRIMITIVE_UNAVAILABLE");
 }
+function missingProvisioningReceiver(error46) {
+  const message = error46 instanceof Error ? error46.message : String(error46);
+  return message.includes("Could not establish connection") || message.includes("Receiving end does not exist");
+}
+function isEditorUrl(url2) {
+  return url2 === "https://chatgpt.com/gpts/editor" || Boolean(url2?.startsWith("https://chatgpt.com/gpts/editor/"));
+}
+async function provisioningContentCommand(tabId, operation, request) {
+  let receiverReloaded = false;
+  for (let attempt = 0; attempt < 60; attempt += 1) {
+    let response;
+    try {
+      response = await chrome.tabs.sendMessage(tabId, {
+        type: "PROFLOW_PROVISIONING_COMMAND",
+        operation,
+        request
+      });
+    } catch (error46) {
+      if (!receiverReloaded && missingProvisioningReceiver(error46)) {
+        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 error46;
+      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) {
+  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(config2, path, init = {}) {
   return fetch(`${config2.endpoint}${path}`, {
     ...init,
@@ -14471,7 +14539,127 @@ async function runBridgeLoop() {
     }
   }
 }
+var provisioningBridgeLoopStarted = false;
+async function runProvisioningBridgeLoop() {
+  if (provisioningBridgeLoopStarted) return;
+  provisioningBridgeLoopStarted = true;
+  while (true) {
+    const config2 = await provisioningBridgeConfig();
+    if (!config2) {
+      await sleep(1e3);
+      continue;
+    }
+    const query = `?extensionInstanceId=${encodeURIComponent(extensionInstanceId)}`;
+    try {
+      const hello = await bridgeFetch(
+        config2,
+        "/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 >= 5e3) {
+          const heartbeat = await bridgeFetch(
+            config2,
+            `/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(
+          config2,
+          `/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();
+        const commandHeartbeat = setInterval(() => {
+          void bridgeFetch(
+            config2,
+            `/v1/provisioning/session/heartbeat${query}`,
+            { method: "POST", body: "{}" }
+          ).catch(() => void 0);
+        }, 2e3);
+        let result;
+        try {
+          result = {
+            commandId: command.commandId,
+            ok: true,
+            value: await executeProvisioningCommand(command)
+          };
+        } catch (error46) {
+          result = {
+            commandId: command.commandId,
+            ok: false,
+            error: error46 instanceof Error ? error46.message : "PROVISIONING_EXTENSION_COMMAND_FAILED"
+          };
+        } finally {
+          clearInterval(commandHeartbeat);
+        }
+        const reported = await bridgeFetch(
+          config2,
+          `/v1/provisioning/commands/result${query}`,
+          { method: "POST", body: JSON.stringify(result) }
+        );
+        if (!reported.ok)
+          throw new Error("PROVISIONING_BRIDGE_RESULT_REJECTED");
+      }
+    } catch {
+      await sleep(1e3);
+    }
+  }
+}
+function provisioningRelayBase64(bytes) {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 32768)
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 32768));
+  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;
+    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) });
+      },
+      (error46) => sendResponse({
+        ok: false,
+        error: error46 instanceof Error ? `KNOWLEDGE_RELAY_FETCH_FAILED:${error46.message}` : "KNOWLEDGE_RELAY_FETCH_FAILED"
+      })
+    );
+    return true;
+  }
   if (message.type === "PROFLOW_CONTENT_OBSERVATION" && message.observation && sender.tab?.id !== void 0 && sender.tab.windowId !== void 0) {
     const observed = {
       ...message.observation,
@@ -14554,6 +14742,7 @@ async function startBackgroundRuntime() {
   await bootstrapManagedRuntimeConfig();
   await persistSnapshot();
   void runBridgeLoop();
+  void runProvisioningBridgeLoop();
   void runObserverRecovery();
 }
 chrome.runtime.onInstalled.addListener(() => {

package/dist/extension/provisioning-content.d.ts

@@ -0,0 +1 @@
+export {};