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

package/dist/extension/provisioning-content.js

@@ -0,0 +1,936 @@
+"use strict";
+(() => {
+  // packages/execution-browser-extension/src/custom-gpt-editor-driver.ts
+  function record(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      throw new TypeError("PROVISIONING_REQUEST_INVALID");
+    return value;
+  }
+  function requiredString(value) {
+    if (typeof value !== "string" || value.trim().length === 0)
+      throw new TypeError("PROVISIONING_REQUEST_INVALID");
+    return value;
+  }
+  function stringArray(value) {
+    if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.trim().length > 0))
+      throw new TypeError("PROVISIONING_REQUEST_INVALID");
+    return [...value];
+  }
+  function knowledgeFiles(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 64)
+      throw new TypeError("PROVISIONING_REQUEST_INVALID");
+    return value.map((candidate) => {
+      const file = record(candidate);
+      const name = requiredString(file.name);
+      const mime = requiredString(file.mime);
+      const sha256 = requiredString(file.sha256);
+      const url = requiredString(file.url);
+      const sizeBytes = file.sizeBytes;
+      if (!Number.isInteger(sizeBytes) || Number(sizeBytes) <= 0 || !/^sha256:[0-9a-f]{64}$/.test(sha256))
+        throw new TypeError("PROVISIONING_REQUEST_INVALID");
+      let parsed;
+      try {
+        parsed = new URL(url);
+      } catch {
+        throw new TypeError("PROVISIONING_REQUEST_INVALID");
+      }
+      if (parsed.protocol !== "http:" || parsed.hostname !== "127.0.0.1" || !parsed.pathname.startsWith("/v1/provisioning/files/") || parsed.username !== "" || parsed.password !== "")
+        throw new TypeError("PROVISIONING_REQUEST_INVALID");
+      return { name, mime, sizeBytes: Number(sizeBytes), sha256, url };
+    });
+  }
+  function parseCustomGptProvisioningRequest(input) {
+    const source = record(input);
+    const capabilities = record(source.capabilities);
+    for (const name of [
+      "webSearch",
+      "imageGeneration",
+      "codeInterpreter"
+    ])
+      if (typeof capabilities[name] !== "boolean")
+        throw new TypeError("PROVISIONING_REQUEST_INVALID");
+    return {
+      packageName: requiredString(source.packageName),
+      version: requiredString(source.version),
+      displayName: requiredString(source.displayName),
+      description: requiredString(source.description),
+      instructions: requiredString(source.instructions),
+      conversationStarters: stringArray(source.conversationStarters),
+      recommendedModel: requiredString(source.recommendedModel),
+      capabilities: {
+        webSearch: capabilities.webSearch,
+        imageGeneration: capabilities.imageGeneration,
+        codeInterpreter: capabilities.codeInterpreter
+      },
+      knowledgeBundle: requiredString(source.knowledgeBundle),
+      actionSchema: requiredString(source.actionSchema),
+      knowledgeFiles: knowledgeFiles(source.knowledgeFiles),
+      ...source.bearerCredential === void 0 ? {} : { bearerCredential: requiredString(source.bearerCredential) }
+    };
+  }
+  function createCustomGptEditorDriver(port) {
+    const configureDraft = async (material) => {
+      await port.setTextField("displayName", material.displayName);
+      await port.setTextField("description", material.description);
+      await port.setTextField("instructions", material.instructions);
+      await port.replaceConversationStarters(material.conversationStarters);
+      await port.selectRecommendedModel(material.recommendedModel);
+      for (const capability of [
+        "webSearch",
+        "imageGeneration",
+        "codeInterpreter"
+      ])
+        await port.setCapability(capability, material.capabilities[capability]);
+      await port.installActionSchema(material.actionSchema);
+      if (material.bearerCredential)
+        await port.configureBearerAuth(material.bearerCredential);
+      return {
+        status: "DRAFT_CONFIGURED",
+        packageName: material.packageName,
+        version: material.version
+      };
+    };
+    return Object.freeze({
+      configureDraft,
+      async provision(material) {
+        await configureDraft(material);
+        await port.uploadKnowledge(material.knowledgeFiles);
+        await port.verifyReady(material);
+        const live = await port.createPrivate();
+        return {
+          status: "LIVE_CREATED",
+          packageName: material.packageName,
+          version: material.version,
+          ...live
+        };
+      }
+    });
+  }
+
+  // packages/execution-browser-extension/extension/provisioning-content.ts
+  var provisioningSurface = Object.freeze({
+    kind: "CUSTOM_GPT_DEPLOYMENT_PROVISIONING",
+    instanceId: `provisioning:${crypto.randomUUID()}`,
+    url: location.href
+  });
+  var sleep = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+  function normalize(value) {
+    return (value ?? "").replace(/\s+/g, " ").trim().toLowerCase();
+  }
+  function editorSurfaceReady() {
+    return location.protocol === "https:" && location.hostname === "chatgpt.com" && location.pathname.startsWith("/gpts/editor");
+  }
+  function elementSemanticText(element) {
+    return normalize(
+      [
+        element.getAttribute("aria-label"),
+        element.getAttribute("placeholder"),
+        element.getAttribute("name"),
+        element.textContent
+      ].filter(Boolean).join(" ")
+    );
+  }
+  function matchesAny(element, candidates) {
+    const semantic = elementSemanticText(element);
+    return candidates.some(
+      (candidate) => semantic.includes(normalize(candidate))
+    );
+  }
+  function controlFromLabel(label) {
+    if (label.htmlFor) {
+      const linked = document.getElementById(label.htmlFor);
+      if (linked instanceof HTMLElement) return linked;
+    }
+    const selector = 'input:not([type="file"]), textarea, select, [contenteditable="true"], [role="textbox"], [role="combobox"]';
+    const nested = label.querySelector(selector);
+    if (nested) return nested;
+    let scope = label.parentElement;
+    for (let depth = 0; depth < 4 && scope; depth += 1) {
+      const controls = [...scope.querySelectorAll(selector)];
+      if (controls.length === 1) return controls[0] ?? null;
+      scope = scope.parentElement;
+    }
+    return null;
+  }
+  function findControl(candidates) {
+    for (const label of document.querySelectorAll("label"))
+      if (matchesAny(label, candidates)) {
+        const control = controlFromLabel(label);
+        if (control) return control;
+      }
+    for (const element of document.querySelectorAll(
+      'input, textarea, select, [contenteditable="true"], [role="textbox"], [role="combobox"]'
+    ))
+      if (matchesAny(element, candidates)) return element;
+    throw new Error(`GPT_EDITOR_CONTROL_NOT_FOUND:${candidates[0] ?? "unknown"}`);
+  }
+  function setControlValue(element, value) {
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement) {
+      const prototype = element instanceof HTMLInputElement ? HTMLInputElement.prototype : element instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLSelectElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+      if (setter) setter.call(element, value);
+      else element.value = value;
+    } else {
+      element.textContent = value;
+    }
+    element.dispatchEvent(
+      new InputEvent("input", { bubbles: true, data: value })
+    );
+    element.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+  function controlValue(element) {
+    if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement)
+      return element.value.replaceAll("\r\n", "\n");
+    return (element.textContent ?? "").replaceAll("\r\n", "\n");
+  }
+  async function waitForReadback(code, predicate) {
+    for (let attempt = 0; attempt < 600; attempt += 1) {
+      if (predicate()) return;
+      await sleep(100);
+    }
+    throw new Error(code);
+  }
+  function clickable(candidates) {
+    for (const element of document.querySelectorAll(
+      'button, [role="button"], [role="option"], [role="menuitem"], [role="radio"]'
+    ))
+      if (matchesAny(element, candidates)) return element;
+    return null;
+  }
+  async function waitForClickable(candidates, attempts = 30) {
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      const element = clickable(candidates);
+      if (element) return element;
+      await sleep(100);
+    }
+    throw new Error(`GPT_EDITOR_ACTION_NOT_FOUND:${candidates[0] ?? "unknown"}`);
+  }
+  var fieldLabels = {
+    displayName: ["Name", "\u540D\u79F0", "Name your GPT", "\u4E3A\u4F60\u7684 GPT \u547D\u540D"],
+    description: [
+      "Description",
+      "\u63CF\u8FF0",
+      "Add a short description about what this GPT does",
+      "\u6DFB\u52A0\u6709\u5173\u6B64 GPT \u7684\u529F\u80FD\u7684\u7B80\u77ED\u63CF\u8FF0"
+    ],
+    instructions: ["Instructions", "\u6307\u4EE4"]
+  };
+  async function ensureConfigureMode() {
+    try {
+      findControl(fieldLabels.displayName);
+      return;
+    } catch {
+    }
+    const configure = await waitForClickable(["Configure", "\u914D\u7F6E"], 60);
+    configure.click();
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      try {
+        findControl(fieldLabels.displayName);
+        return;
+      } catch {
+        await sleep(100);
+      }
+    }
+    throw new Error("GPT_EDITOR_CONFIGURE_SURFACE_NOT_READY");
+  }
+  var capabilityLabels = {
+    webSearch: ["Web search", "\u7F51\u9875\u641C\u7D22", "\u7F51\u7EDC\u641C\u7D22", "\u6D4F\u89C8\u7F51\u9875"],
+    imageGeneration: ["Image generation", "\u56FE\u50CF\u751F\u6210", "\u56FE\u7247\u751F\u6210"],
+    codeInterpreter: [
+      "Code Interpreter & Data Analysis",
+      "Code Interpreter",
+      "Data Analysis",
+      "\u4EE3\u7801\u89E3\u91CA\u5668",
+      "\u4EE3\u7801\u89E3\u8BD1\u5668"
+    ]
+  };
+  function conversationStarterControls(minimum) {
+    const label = [...document.querySelectorAll("label")].find(
+      (element) => matchesAny(element, ["Conversation starter", "\u5BF9\u8BDD\u5F00\u573A\u767D"])
+    );
+    if (!label) return [];
+    let scope = label.parentElement;
+    for (let depth = 0; depth < 4 && scope; depth += 1) {
+      const controls = [
+        ...scope.querySelectorAll(
+          'input[type="text"], textarea:not([data-testid="gizmo-instructions-input"])'
+        )
+      ];
+      if (controls.length >= minimum) return controls;
+      scope = scope.parentElement;
+    }
+    return [];
+  }
+  async function replaceConversationStarters(values) {
+    const controls = conversationStarterControls(values.length);
+    if (controls.length < values.length)
+      throw new Error("GPT_EDITOR_STARTER_CONTROL_NOT_FOUND");
+    for (let index = 0; index < values.length; index += 1)
+      setControlValue(controls[index], values[index] ?? "");
+  }
+  function currentGptId() {
+    const match = /\/(g-[a-zA-Z0-9_-]+)(?:\/|$)/.exec(location.pathname);
+    return match?.[1] ?? null;
+  }
+  async function knowledgeFileInput() {
+    const label = [...document.querySelectorAll("label")].find(
+      (element) => matchesAny(element, ["Knowledge", "\u77E5\u8BC6"])
+    );
+    if (label) {
+      let scope = label.parentElement;
+      for (let depth = 0; depth < 4 && scope; depth += 1) {
+        const inputs = [
+          ...scope.querySelectorAll('input[type="file"]')
+        ];
+        if (inputs.length === 1) return inputs[0];
+        scope = scope.parentElement;
+      }
+    }
+    const upload = clickable([
+      "Upload files",
+      "Upload file",
+      "Add files",
+      "\u4E0A\u4F20\u6587\u4EF6",
+      "\u6DFB\u52A0\u6587\u4EF6"
+    ]);
+    if (upload) upload.click();
+    for (let attempt = 0; attempt < 40; attempt += 1) {
+      const candidates = [
+        ...document.querySelectorAll('input[type="file"]')
+      ];
+      if (candidates.length === 1) return candidates[0];
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_KNOWLEDGE_INPUT_NOT_FOUND");
+  }
+  async function fetchKnowledgeRelay(url) {
+    const result = await chrome.runtime.sendMessage({
+      type: "PROFLOW_PROVISIONING_RELAY_FETCH",
+      url
+    });
+    if (typeof result !== "object" || result === null)
+      throw new Error("KNOWLEDGE_RELAY_BACKGROUND_INVALID");
+    const record2 = result;
+    if (record2.ok !== true || typeof record2.base64 !== "string")
+      throw new Error(
+        typeof record2.error === "string" ? record2.error : "KNOWLEDGE_RELAY_BACKGROUND_FAILED"
+      );
+    const binary = atob(record2.base64);
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1)
+      bytes[index] = binary.charCodeAt(index);
+    return bytes.buffer;
+  }
+  async function sha256Bytes(bytes) {
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return `sha256:${[...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("")}`;
+  }
+  async function waitForKnowledgeName(name) {
+    await waitForReadback(
+      `GPT_EDITOR_KNOWLEDGE_UPLOAD_TIMEOUT:${name}`,
+      () => knowledgeReadbackMatches(name)
+    );
+  }
+  async function uploadKnowledge(files) {
+    for (const descriptor of files) {
+      const input = await knowledgeFileInput();
+      const bytes = await fetchKnowledgeRelay(descriptor.url);
+      if (bytes.byteLength !== descriptor.sizeBytes)
+        throw new Error("KNOWLEDGE_RELAY_SIZE_MISMATCH");
+      if (await sha256Bytes(bytes) !== descriptor.sha256)
+        throw new Error("KNOWLEDGE_RELAY_HASH_MISMATCH");
+      const transfer = new DataTransfer();
+      transfer.items.add(
+        new File([bytes], descriptor.name, { type: descriptor.mime })
+      );
+      input.files = transfer.files;
+      input.dispatchEvent(new Event("change", { bubbles: true }));
+      await waitForKnowledgeName(descriptor.name);
+    }
+  }
+  var privateVisibilityLabels = [
+    "Only me",
+    "Private",
+    "\u53EA\u6709\u6211",
+    "\u79C1\u6709",
+    "\u4EC5\u81EA\u5DF1"
+  ];
+  var nonPrivateVisibilityLabels = [
+    "Anyone",
+    "Public",
+    "Link",
+    "GPT Store",
+    "Workspace",
+    "\u6240\u6709\u4EBA",
+    "\u516C\u5F00",
+    "\u94FE\u63A5",
+    "\u5DE5\u4F5C\u533A"
+  ];
+  function semanticValues(element) {
+    const referencedText = (attribute) => (element.getAttribute(attribute) ?? "").split(/\s+/).filter(Boolean).map((id) => document.getElementById(id)?.textContent ?? "").join(" ");
+    return [
+      element.getAttribute("aria-label"),
+      referencedText("aria-labelledby"),
+      referencedText("aria-describedby"),
+      element.getAttribute("data-value"),
+      element.getAttribute("value"),
+      element.textContent
+    ].filter((value) => Boolean(value)).map(normalize);
+  }
+  function matchesExactSemantic(element, candidates) {
+    const expected = new Set(candidates.map(normalize));
+    return semanticValues(element).some((value) => expected.has(value));
+  }
+  function matchesBoundedSemantic(element, candidates) {
+    const values = semanticValues(element);
+    return candidates.some((candidate) => {
+      const expected = normalize(candidate);
+      return values.some(
+        (value) => value === expected || value.startsWith(`${expected} `) || value.endsWith(` ${expected}`)
+      );
+    });
+  }
+  function available(element) {
+    const style = getComputedStyle(element);
+    return element.getClientRects().length > 0 && style.display !== "none" && style.visibility !== "hidden" && element.getAttribute("aria-hidden") !== "true" && !element.hasAttribute("disabled") && element.getAttribute("aria-disabled") !== "true";
+  }
+  function privateVisibilityControl() {
+    const selector = 'input[type="radio"], label, button, [role="button"], [role="radio"], [role="option"], [role="menuitem"], [role="menuitemradio"]';
+    for (const element of document.querySelectorAll(selector)) {
+      if (available(element) && matchesBoundedSemantic(element, privateVisibilityLabels) && !matchesBoundedSemantic(element, nonPrivateVisibilityLabels))
+        return element;
+    }
+    return null;
+  }
+  function selected(element) {
+    if (element instanceof HTMLInputElement && element.type === "radio")
+      return element.checked;
+    if (element instanceof HTMLLabelElement && element.htmlFor) {
+      const control = document.getElementById(element.htmlFor);
+      if (control instanceof HTMLInputElement && control.type === "radio")
+        return control.checked;
+    }
+    return element.getAttribute("aria-checked") === "true" || element.getAttribute("aria-selected") === "true" || element.getAttribute("aria-pressed") === "true" || element.getAttribute("data-state") === "checked";
+  }
+  function carrierGptId(value) {
+    if (typeof value !== "string") throw new Error("ROLE_CARRIER_URL_INVALID");
+    const url = new URL(value);
+    const match = /^\/g\/(g-[A-Za-z0-9_-]+)$/.exec(url.pathname);
+    if (url.origin !== "https://chatgpt.com" || url.username !== "" || url.password !== "" || url.search !== "" || url.hash !== "" || !match?.[1])
+      throw new Error("ROLE_CARRIER_URL_INVALID");
+    return match[1];
+  }
+  async function waitForAuthSemantic(root, candidates, selector = 'button, [role="button"], [role="radio"], [role="option"], label') {
+    for (let attempt = 0; attempt < 120; attempt += 1) {
+      for (const element of root.querySelectorAll(selector))
+        if (available(element) && matchesBoundedSemantic(element, candidates))
+          return element;
+      await sleep(100);
+    }
+    throw new Error(
+      `GPT_EDITOR_AUTH_CONTROL_NOT_FOUND:${candidates[0] ?? "unknown"}`
+    );
+  }
+  function existingActionEditButton() {
+    const actionLabel = [...document.querySelectorAll("label")].find(
+      (element) => matchesExactSemantic(element, ["Actions", "\u64CD\u4F5C"])
+    );
+    let scope = actionLabel?.parentElement ?? null;
+    for (let depth = 0; depth < 5 && scope; depth += 1) {
+      const buttons = [
+        ...scope.querySelectorAll('button, [role="button"]')
+      ].filter(available);
+      const create = buttons.find(
+        (element) => matchesBoundedSemantic(element, [
+          "Create new action",
+          "New action",
+          "\u521B\u5EFA\u65B0\u64CD\u4F5C"
+        ])
+      );
+      if (create) {
+        return buttons.find(
+          (element) => element !== create && elementSemanticText(element) === "" && normalize(element.parentElement?.parentElement?.textContent).length > 0
+        ) ?? null;
+      }
+      scope = scope.parentElement;
+    }
+    return null;
+  }
+  async function openExistingActionEditor() {
+    const authLabels = ["Authentication", "\u8EAB\u4EFD\u9A8C\u8BC1", "\u8BA4\u8BC1"];
+    if (clickable(authLabels)) return;
+    const edit = existingActionEditButton();
+    if (!edit) throw new Error("GPT_EDITOR_ACTION_EDIT_NOT_FOUND");
+    edit.click();
+    for (let attempt = 0; attempt < 120; attempt += 1) {
+      if (clickable(authLabels)) return;
+      try {
+        findControl(["OpenAPI schema", "Schema", "OpenAPI", "\u67B6\u6784"]);
+        return;
+      } catch {
+      }
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_ACTION_EDITOR_NOT_READY");
+  }
+  async function waitForAuthSettingsButton() {
+    const labels = ["Authentication", "\u8EAB\u4EFD\u9A8C\u8BC1", "\u8BA4\u8BC1"];
+    for (let attempt = 0; attempt < 120; attempt += 1) {
+      for (const label of document.querySelectorAll("label")) {
+        if (!available(label) || !matchesExactSemantic(label, labels)) continue;
+        let container = label.parentElement;
+        for (let depth = 0; depth < 4 && container; depth += 1) {
+          const buttons = [
+            ...container.querySelectorAll("button")
+          ].filter(available);
+          const [button] = buttons;
+          if (buttons.length === 1 && button) return button;
+          container = container.parentElement;
+        }
+      }
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_AUTH_SETTINGS_BUTTON_NOT_FOUND");
+  }
+  async function returnFromActionEditor() {
+    let back;
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      back = [...document.querySelectorAll("button")].find(
+        (button) => {
+          if ((button.textContent ?? "").trim().length > 0) return false;
+          const context = normalize(
+            button.parentElement?.parentElement?.textContent ?? ""
+          );
+          return context.includes("add action") || context.includes("\u6DFB\u52A0\u64CD\u4F5C") || context.includes("edit action") || context.includes("\u7F16\u8F91\u64CD\u4F5C");
+        }
+      );
+      if (back) break;
+      await sleep(100);
+    }
+    if (!back) throw new Error("GPT_EDITOR_ACTION_BACK_NOT_FOUND");
+    back.click();
+    await waitForReadback(
+      "GPT_EDITOR_CONFIGURE_RETURN_TIMEOUT",
+      () => [...document.querySelectorAll("label")].some(
+        (label) => matchesAny(label, ["Knowledge", "\u77E5\u8BC6"])
+      )
+    );
+  }
+  async function configureBearerAuthDraft(credential) {
+    if (credential.length < 32) throw new Error("ROLE_CREDENTIAL_INVALID");
+    await openExistingActionEditor();
+    (await waitForAuthSettingsButton()).click();
+    let dialog = null;
+    for (let attempt = 0; attempt < 600; attempt += 1) {
+      dialog = [...document.querySelectorAll('[role="dialog"]')].find(
+        (candidate) => available(candidate)
+      ) ?? null;
+      if (dialog) break;
+      await sleep(100);
+    }
+    if (!dialog) throw new Error("GPT_EDITOR_AUTH_DIALOG_NOT_FOUND");
+    const authRadio = async (labels) => {
+      for (let attempt = 0; attempt < 120; attempt += 1) {
+        for (const radio of dialog.querySelectorAll(
+          'input[type="radio"], [role="radio"]'
+        )) {
+          let container = radio.parentElement;
+          for (let depth = 0; depth < 3 && container; depth += 1) {
+            if (matchesBoundedSemantic(container, labels)) return radio;
+            container = container.parentElement;
+          }
+        }
+        await sleep(100);
+      }
+      throw new Error(
+        `GPT_EDITOR_AUTH_RADIO_NOT_FOUND:${labels[0] ?? "unknown"}`
+      );
+    };
+    const apiKey = await authRadio(["API Key", "API \u5BC6\u94A5"]);
+    if (!selected(apiKey)) apiKey.click();
+    const bearer = await authRadio(["Bearer"]);
+    if (!selected(bearer)) bearer.click();
+    let keyInput = null;
+    for (let attempt = 0; attempt < 120; attempt += 1) {
+      const candidate = dialog.querySelector(
+        'input[type="password"]'
+      );
+      if (candidate && available(candidate)) {
+        keyInput = candidate;
+        break;
+      }
+      await sleep(100);
+    }
+    if (!keyInput) throw new Error("GPT_EDITOR_AUTH_KEY_INPUT_NOT_FOUND");
+    setControlValue(keyInput, credential);
+    if (controlValue(keyInput) !== credential)
+      throw new Error("GPT_EDITOR_AUTH_KEY_READBACK_MISMATCH");
+    (await waitForAuthSemantic(dialog, ["Save", "\u4FDD\u5B58"])).click();
+    await waitForReadback(
+      "GPT_EDITOR_AUTH_SAVE_TIMEOUT",
+      () => !available(dialog)
+    );
+    await returnFromActionEditor();
+  }
+  function savedConfirmationVisible() {
+    const labels = [
+      "Settings saved",
+      "\u8BBE\u7F6E\u5DF2\u4FDD\u5B58",
+      "GPT updated",
+      "GPT \u5DF2\u66F4\u65B0"
+    ];
+    return [...document.querySelectorAll('[role="dialog"]')].some(
+      (dialog) => available(dialog) && labels.some(
+        (label) => normalize(dialog.textContent).includes(normalize(label))
+      )
+    );
+  }
+  async function finalizeBearerAuth(credential) {
+    await configureBearerAuthDraft(credential);
+    (await waitForAuthSemantic(document, ["Update", "\u66F4\u65B0"])).click();
+    await waitForReadback(
+      "GPT_EDITOR_AUTH_UPDATE_TIMEOUT",
+      savedConfirmationVisible
+    );
+    const gptId = currentGptId();
+    if (!gptId) throw new Error("GPT_EDITOR_GPT_ID_MISSING");
+    return { status: "AUTH_UPDATED", gptId };
+  }
+  async function selectPrivateVisibility() {
+    let control = null;
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      control = privateVisibilityControl();
+      if (control) break;
+      await sleep(100);
+    }
+    if (!control) throw new Error("GPT_EDITOR_PRIVATE_CONTROL_NOT_FOUND");
+    if (!selected(control)) control.click();
+    for (let attempt = 0; attempt < 40; attempt += 1) {
+      const current = privateVisibilityControl();
+      if (current && selected(current)) return;
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_PRIVATE_SELECTION_NOT_CONFIRMED");
+  }
+  async function waitForPrivateCreateAction(initialCreateButton) {
+    const control = privateVisibilityControl();
+    const scopedRoot = control?.closest(
+      '[role="dialog"], [role="menu"], [role="listbox"]'
+    ) ?? document;
+    const labelGroups = [
+      ["Save", "\u4FDD\u5B58"],
+      ["Publish", "\u53D1\u5E03"],
+      ["Create", "\u521B\u5EFA"]
+    ];
+    for (let attempt = 0; attempt < 40; attempt += 1) {
+      for (const labels of labelGroups)
+        for (const element of scopedRoot.querySelectorAll(
+          'button, [role="button"]'
+        ))
+          if (element !== initialCreateButton && available(element) && matchesBoundedSemantic(element, labels))
+            return element;
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_PRIVATE_CREATE_ACTION_NOT_FOUND");
+  }
+  function publishCreateButton() {
+    return [...document.querySelectorAll('button, [role="button"]')].find(
+      (element) => available(element) && element.getAttribute("role") !== "radio" && element.closest('[role="radiogroup"]') === null && matchesExactSemantic(element, ["Create", "\u521B\u5EFA"])
+    ) ?? null;
+  }
+  function fieldReadbackMatches(field, expected) {
+    try {
+      return controlValue(findControl(fieldLabels[field])) === expected;
+    } catch {
+      return false;
+    }
+  }
+  function starterReadbackMatches(values) {
+    const controls = conversationStarterControls(values.length);
+    if (controls.length < values.length) return false;
+    return values.every(
+      (value, index) => controlValue(controls[index]) === value
+    );
+  }
+  function modelReadbackMatches(value) {
+    try {
+      const selector = findControl([
+        "Recommended model",
+        "\u63A8\u8350\u6A21\u578B",
+        "\u63A8\u8350\u7684\u6A21\u578B",
+        value
+      ]);
+      if (selector instanceof HTMLSelectElement) {
+        const option = selector.selectedOptions[0];
+        return Boolean(
+          option && (option.value === value || normalize(option.textContent).endsWith(`(${normalize(value)})`))
+        );
+      }
+      return semanticValues(selector).some(
+        (candidate) => candidate.includes(normalize(value))
+      );
+    } catch {
+      return false;
+    }
+  }
+  function capabilityReadbackMatches(capability, expected) {
+    try {
+      const control = findControl(capabilityLabels[capability]);
+      if (control instanceof HTMLInputElement && control.type === "checkbox")
+        return control.checked === expected;
+      return control.getAttribute("aria-checked") === "true" === expected;
+    } catch {
+      return false;
+    }
+  }
+  function knowledgeReadbackMatches(name) {
+    const expected = normalize(name);
+    return [
+      ...document.querySelectorAll('[role="group"], button')
+    ].some(
+      (element) => normalize(element.getAttribute("aria-label")) === expected || normalize(element.textContent) === expected
+    );
+  }
+  function actionReadbackMatches(schema) {
+    const match = /servers:\s*\n\s*-\s*url:\s*([^\s]+)/m.exec(schema);
+    if (!match?.[1]) return false;
+    try {
+      const host = new URL(match[1]).host;
+      return normalize(document.body.textContent).includes(normalize(host));
+    } catch {
+      return false;
+    }
+  }
+  async function verifyConfiguredMaterial(material) {
+    await waitForReadback(
+      "GPT_EDITOR_NAME_READBACK_MISMATCH",
+      () => fieldReadbackMatches("displayName", material.displayName)
+    );
+    await waitForReadback(
+      "GPT_EDITOR_DESCRIPTION_READBACK_MISMATCH",
+      () => fieldReadbackMatches("description", material.description)
+    );
+    await waitForReadback(
+      "GPT_EDITOR_INSTRUCTIONS_READBACK_MISMATCH",
+      () => fieldReadbackMatches("instructions", material.instructions)
+    );
+    await waitForReadback(
+      "GPT_EDITOR_STARTERS_READBACK_MISMATCH",
+      () => starterReadbackMatches(material.conversationStarters)
+    );
+    await waitForReadback(
+      "GPT_EDITOR_MODEL_READBACK_MISMATCH",
+      () => modelReadbackMatches(material.recommendedModel)
+    );
+    for (const capability of [
+      "webSearch",
+      "imageGeneration",
+      "codeInterpreter"
+    ])
+      await waitForReadback(
+        `GPT_EDITOR_CAPABILITY_READBACK_MISMATCH:${capability}`,
+        () => capabilityReadbackMatches(
+          capability,
+          material.capabilities[capability]
+        )
+      );
+    await waitForReadback(
+      "GPT_EDITOR_ACTION_READBACK_MISMATCH",
+      () => actionReadbackMatches(material.actionSchema)
+    );
+    for (const file of material.knowledgeFiles)
+      await waitForReadback(
+        `GPT_EDITOR_KNOWLEDGE_READBACK_MISMATCH:${file.name}`,
+        () => knowledgeReadbackMatches(file.name)
+      );
+    await waitForReadback(
+      "GPT_EDITOR_DRAFT_ID_NOT_READY",
+      () => currentGptId() !== null
+    );
+    await waitForReadback(
+      "GPT_EDITOR_CREATE_NOT_READY",
+      () => publishCreateButton() !== null
+    );
+  }
+  async function openPrivateCreateSurface(initialCreateButton) {
+    initialCreateButton.click();
+    for (let attempt = 0; attempt < 200; attempt += 1) {
+      if (privateVisibilityControl()) return;
+      await sleep(100);
+    }
+    throw new Error("GPT_EDITOR_PRIVATE_CONTROL_NOT_FOUND");
+  }
+  async function waitForLiveCreatedResult() {
+    for (let attempt = 0; attempt < 320; attempt += 1) {
+      const gptId = currentGptId();
+      if (gptId && savedConfirmationVisible())
+        return { gptId, carrierUrl: `https://chatgpt.com/g/${gptId}` };
+      await sleep(125);
+    }
+    throw new Error("GPT_EDITOR_PRIVATE_CREATE_TIMEOUT");
+  }
+  async function finalizePrivateCreateSurface(initialCreateButton) {
+    await selectPrivateVisibility();
+    (await waitForPrivateCreateAction(initialCreateButton)).click();
+    return waitForLiveCreatedResult();
+  }
+  async function createPrivateGpt() {
+    const createButton = publishCreateButton();
+    if (!createButton) throw new Error("GPT_EDITOR_FORM_READY_STATE_LOST");
+    await openPrivateCreateSurface(createButton);
+    return finalizePrivateCreateSurface(createButton);
+  }
+  var domPort = {
+    async setTextField(field, value) {
+      setControlValue(findControl(fieldLabels[field]), value);
+    },
+    async replaceConversationStarters(values) {
+      await replaceConversationStarters(values);
+    },
+    async selectRecommendedModel(value) {
+      const selector = findControl([
+        "Recommended model",
+        "\u63A8\u8350\u6A21\u578B",
+        "\u63A8\u8350\u7684\u6A21\u578B",
+        value
+      ]);
+      if (selector instanceof HTMLSelectElement) {
+        let option;
+        const normalizedValue = normalize(value);
+        for (let attempt = 0; attempt < 150; attempt += 1) {
+          option = [...selector.options].find((candidate) => {
+            const optionText = normalize(candidate.textContent);
+            return candidate.value === value || optionText === normalizedValue || optionText.endsWith(`(${normalizedValue})`);
+          });
+          if (option) break;
+          await sleep(100);
+        }
+        if (!option)
+          throw new Error(`GPT_EDITOR_MODEL_OPTION_NOT_FOUND:${value}`);
+        setControlValue(selector, option.value);
+        return;
+      }
+      selector.click();
+      (await waitForClickable([value])).click();
+    },
+    async setCapability(capability, enabled) {
+      const labels = capabilityLabels[capability];
+      let control;
+      try {
+        control = findControl(labels);
+      } catch {
+        control = await waitForClickable(labels);
+      }
+      if (control instanceof HTMLInputElement && control.type === "checkbox") {
+        if (control.checked !== enabled) control.click();
+        if (control.checked !== enabled)
+          throw new Error(
+            `GPT_EDITOR_CAPABILITY_READBACK_MISMATCH:${capability}`
+          );
+        return;
+      }
+      if (control.getAttribute("aria-checked") === "true" !== enabled)
+        control.click();
+      if (control.getAttribute("aria-checked") === "true" !== enabled)
+        throw new Error(`GPT_EDITOR_CAPABILITY_READBACK_MISMATCH:${capability}`);
+    },
+    async configureBearerAuth(value) {
+      await configureBearerAuthDraft(value);
+    },
+    async uploadKnowledge(files) {
+      await uploadKnowledge(files);
+    },
+    async verifyReady(material) {
+      await verifyConfiguredMaterial(material);
+    },
+    async installActionSchema(value) {
+      let schema = null;
+      try {
+        schema = findControl(["OpenAPI schema", "Schema", "OpenAPI", "\u67B6\u6784"]);
+      } catch {
+        const create = clickable([
+          "Create new action",
+          "New action",
+          "\u521B\u5EFA\u65B0\u64CD\u4F5C"
+        ]);
+        if (!create) throw new Error("GPT_EDITOR_ACTION_CREATE_NOT_FOUND");
+        create.click();
+        for (let attempt = 0; attempt < 200; attempt += 1) {
+          schema = document.querySelector(
+            'textarea[placeholder*="OpenAPI"]'
+          );
+          if (schema) break;
+          try {
+            schema = findControl([
+              "\u5728\u6B64\u5904\u8F93\u5165\u4F60\u7684 OpenAPI \u67B6\u6784",
+              "OpenAPI schema",
+              "Schema",
+              "OpenAPI",
+              "\u67B6\u6784"
+            ]);
+            break;
+          } catch {
+            await sleep(100);
+          }
+        }
+      }
+      if (!schema) throw new Error("GPT_EDITOR_ACTION_SCHEMA_NOT_FOUND");
+      setControlValue(schema, value);
+      await waitForReadback(
+        "GPT_EDITOR_ACTION_SCHEMA_READBACK_MISMATCH",
+        () => controlValue(schema) === value
+      );
+      await returnFromActionEditor();
+    },
+    async createPrivate() {
+      return createPrivateGpt();
+    }
+  };
+  var editorDriver = createCustomGptEditorDriver(domPort);
+  chrome.runtime.onMessage.addListener((message, _sender, sendResponse) => {
+    if (message.type !== "PROFLOW_PROVISIONING_COMMAND") return;
+    if (!editorSurfaceReady()) {
+      sendResponse({ ok: false, error: "PROVISIONING_SURFACE_NOT_READY" });
+      return;
+    }
+    void (async () => {
+      try {
+        await ensureConfigureMode();
+        if (message.operation === "PROVISION_CUSTOM_GPT") {
+          const material = parseCustomGptProvisioningRequest(message.request);
+          const result = await editorDriver.provision(material);
+          sendResponse({
+            ok: true,
+            value: {
+              ...result,
+              provisioningInstanceId: provisioningSurface.instanceId,
+              url: location.href
+            }
+          });
+          return;
+        }
+        if (message.operation !== "FINALIZE_CUSTOM_GPT_AUTH")
+          throw new Error("PROVISIONING_OPERATION_UNSUPPORTED");
+        const expectedGptId = carrierGptId(message.request.carrierUrl);
+        let credential = message.request.credential;
+        delete message.request.credential;
+        if (typeof credential !== "string" || credential.length < 32)
+          throw new Error("ROLE_CREDENTIAL_INVALID");
+        try {
+          const result = await finalizeBearerAuth(credential);
+          if (result.gptId !== expectedGptId)
+            throw new Error("GPT_EDITOR_AUTH_TARGET_MISMATCH");
+          sendResponse({ ok: true, value: result });
+        } finally {
+          credential = "";
+        }
+      } catch (error) {
+        sendResponse({
+          ok: false,
+          error: error instanceof Error ? error.message : "GPT_EDITOR_PROVISIONING_FAILED"
+        });
+      }
+    })();
+    return true;
+  });
+})();