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

package/dist/src/custom-gpt-editor-driver.d.ts

@@ -0,0 +1,51 @@
+export type CustomGptCapability = "webSearch" | "imageGeneration" | "codeInterpreter";
+export type CustomGptKnowledgeFile = {
+    name: string;
+    mime: string;
+    sizeBytes: number;
+    sha256: string;
+    url: string;
+};
+export type CustomGptProvisioningRequest = {
+    packageName: string;
+    version: string;
+    displayName: string;
+    description: string;
+    instructions: string;
+    conversationStarters: string[];
+    recommendedModel: string;
+    capabilities: Record<CustomGptCapability, boolean>;
+    knowledgeBundle: string;
+    actionSchema: string;
+    knowledgeFiles: CustomGptKnowledgeFile[];
+    bearerCredential?: string;
+};
+export interface CustomGptEditorPort {
+    setTextField(field: "displayName" | "description" | "instructions", value: string): Promise<void>;
+    replaceConversationStarters(values: readonly string[]): Promise<void>;
+    selectRecommendedModel(value: string): Promise<void>;
+    setCapability(capability: CustomGptCapability, enabled: boolean): Promise<void>;
+    installActionSchema(value: string): Promise<void>;
+    configureBearerAuth(value: string): Promise<void>;
+    uploadKnowledge(files: readonly CustomGptKnowledgeFile[]): Promise<void>;
+    verifyReady(material: CustomGptProvisioningRequest): Promise<void>;
+    createPrivate(): Promise<{
+        gptId: string;
+        carrierUrl: string;
+    }>;
+}
+export declare function parseCustomGptProvisioningRequest(input: unknown): CustomGptProvisioningRequest;
+export declare function createCustomGptEditorDriver(port: CustomGptEditorPort): Readonly<{
+    configureDraft: (material: CustomGptProvisioningRequest) => Promise<{
+        status: "DRAFT_CONFIGURED";
+        packageName: string;
+        version: string;
+    }>;
+    provision(material: CustomGptProvisioningRequest): Promise<{
+        gptId: string;
+        carrierUrl: string;
+        status: "LIVE_CREATED";
+        packageName: string;
+        version: string;
+    }>;
+}>;

package/dist/src/custom-gpt-editor-driver.js

@@ -0,0 +1,116 @@
+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 };
+    });
+}
+export 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 === undefined
+            ? {}
+            : { bearerCredential: requiredString(source.bearerCredential) }),
+    };
+}
+export 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,
+            };
+        },
+    });
+}

package/dist/src/custom-gpt-knowledge.d.ts

@@ -0,0 +1,21 @@
+export type MaterializedKnowledgeFile = {
+    name: string;
+    relativePath: string;
+    path: string;
+    mime: string;
+    sizeBytes: number;
+    sha256: string;
+};
+export type MaterializedKnowledgeBundle = {
+    bundlePath: string;
+    bundleSha256: string;
+    stagingDirectory: string;
+    files: MaterializedKnowledgeFile[];
+};
+export declare function materializeCustomGptKnowledgeBundle(input: {
+    bundlePath: string;
+    stagingRoot: string;
+    maxEntries?: number;
+    maxEntryBytes?: number;
+    maxTotalBytes?: number;
+}): Promise<MaterializedKnowledgeBundle>;

package/dist/src/custom-gpt-knowledge.js

@@ -0,0 +1,148 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { basename, extname, join, resolve } from "node:path";
+import { inflateRawSync } from "node:zlib";
+const MIME_BY_EXTENSION = {
+    ".md": "text/markdown",
+    ".txt": "text/plain",
+    ".pdf": "application/pdf",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".json": "application/json",
+    ".csv": "text/csv",
+    ".yaml": "text/yaml",
+    ".yml": "text/yaml",
+    ".js": "text/javascript",
+    ".ts": "text/plain",
+    ".py": "text/plain",
+};
+function sha256(bytes) {
+    return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function unsafeEntry(name) {
+    if (name.length === 0 ||
+        name.includes("\\") ||
+        name.includes("\0") ||
+        name.startsWith("/") ||
+        /^[a-zA-Z]:/.test(name))
+        return true;
+    const parts = name.split("/");
+    return parts.some((part) => part === "" || part === "." || part === "..");
+}
+function findEndOfCentralDirectory(buffer) {
+    const minimum = Math.max(0, buffer.length - 65_557);
+    for (let offset = buffer.length - 22; offset >= minimum; offset -= 1)
+        if (buffer.readUInt32LE(offset) === 0x06054b50)
+            return offset;
+    throw new Error("KNOWLEDGE_ZIP_INVALID");
+}
+function parseEntries(buffer, maxEntries) {
+    const eocd = findEndOfCentralDirectory(buffer);
+    const entries = buffer.readUInt16LE(eocd + 10);
+    const centralSize = buffer.readUInt32LE(eocd + 12);
+    const centralOffset = buffer.readUInt32LE(eocd + 16);
+    if (entries === 0 ||
+        entries > maxEntries ||
+        centralOffset + centralSize > buffer.length)
+        throw new Error("KNOWLEDGE_ZIP_INVALID");
+    const result = [];
+    let offset = centralOffset;
+    for (let index = 0; index < entries; index += 1) {
+        if (offset + 46 > buffer.length ||
+            buffer.readUInt32LE(offset) !== 0x02014b50)
+            throw new Error("KNOWLEDGE_ZIP_INVALID");
+        const flags = buffer.readUInt16LE(offset + 8);
+        const method = buffer.readUInt16LE(offset + 10);
+        const compressedSize = buffer.readUInt32LE(offset + 20);
+        const uncompressedSize = buffer.readUInt32LE(offset + 24);
+        const nameLength = buffer.readUInt16LE(offset + 28);
+        const extraLength = buffer.readUInt16LE(offset + 30);
+        const commentLength = buffer.readUInt16LE(offset + 32);
+        const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+        const end = offset + 46 + nameLength + extraLength + commentLength;
+        if (end > buffer.length || (flags & 0x1) !== 0)
+            throw new Error("KNOWLEDGE_ZIP_INVALID");
+        const name = buffer
+            .subarray(offset + 46, offset + 46 + nameLength)
+            .toString("utf8");
+        result.push({
+            name,
+            method,
+            compressedSize,
+            uncompressedSize,
+            localHeaderOffset,
+        });
+        offset = end;
+    }
+    return result;
+}
+function extractEntry(buffer, entry) {
+    const offset = entry.localHeaderOffset;
+    if (offset + 30 > buffer.length || buffer.readUInt32LE(offset) !== 0x04034b50)
+        throw new Error("KNOWLEDGE_ZIP_INVALID");
+    const nameLength = buffer.readUInt16LE(offset + 26);
+    const extraLength = buffer.readUInt16LE(offset + 28);
+    const dataOffset = offset + 30 + nameLength + extraLength;
+    const dataEnd = dataOffset + entry.compressedSize;
+    if (dataEnd > buffer.length)
+        throw new Error("KNOWLEDGE_ZIP_INVALID");
+    const compressed = buffer.subarray(dataOffset, dataEnd);
+    const output = entry.method === 0
+        ? Buffer.from(compressed)
+        : entry.method === 8
+            ? inflateRawSync(compressed)
+            : (() => {
+                throw new Error("KNOWLEDGE_ZIP_COMPRESSION_UNSUPPORTED");
+            })();
+    if (output.length !== entry.uncompressedSize)
+        throw new Error("KNOWLEDGE_ZIP_SIZE_MISMATCH");
+    return output;
+}
+export async function materializeCustomGptKnowledgeBundle(input) {
+    const maxEntries = input.maxEntries ?? 64;
+    const maxEntryBytes = input.maxEntryBytes ?? 32 * 1024 * 1024;
+    const maxTotalBytes = input.maxTotalBytes ?? 128 * 1024 * 1024;
+    const bundlePath = resolve(input.bundlePath);
+    const archive = await readFile(bundlePath);
+    const bundleSha256 = sha256(archive);
+    const entries = parseEntries(archive, maxEntries);
+    let totalBytes = 0;
+    let knowledgeEntryCount = 0;
+    for (const entry of entries) {
+        if (entry.name.endsWith("/"))
+            continue;
+        if (unsafeEntry(entry.name))
+            throw new Error("KNOWLEDGE_ZIP_ENTRY_UNSAFE");
+        if (entry.uncompressedSize > maxEntryBytes)
+            throw new Error("KNOWLEDGE_ZIP_ENTRY_TOO_LARGE");
+        totalBytes += entry.uncompressedSize;
+        if (totalBytes > maxTotalBytes)
+            throw new Error("KNOWLEDGE_ZIP_TOTAL_TOO_LARGE");
+        if (!MIME_BY_EXTENSION[extname(entry.name).toLowerCase()])
+            throw new Error("KNOWLEDGE_FILE_TYPE_UNSUPPORTED");
+        extractEntry(archive, entry);
+        knowledgeEntryCount += 1;
+    }
+    if (knowledgeEntryCount === 0)
+        throw new Error("KNOWLEDGE_ZIP_EMPTY");
+    const stagingDirectory = join(resolve(input.stagingRoot), bundleSha256.slice("sha256:".length, "sha256:".length + 24));
+    await rm(stagingDirectory, { recursive: true, force: true });
+    await mkdir(stagingDirectory, { recursive: true, mode: 0o700 });
+    const fileName = basename(bundlePath);
+    const stagedBundlePath = join(stagingDirectory, fileName);
+    await writeFile(stagedBundlePath, archive, { mode: 0o600 });
+    return {
+        bundlePath,
+        bundleSha256,
+        stagingDirectory,
+        files: [
+            {
+                name: fileName,
+                relativePath: fileName,
+                path: stagedBundlePath,
+                mime: "application/zip",
+                sizeBytes: archive.length,
+                sha256: bundleSha256,
+            },
+        ],
+    };
+}

package/dist/src/custom-gpt-provisioner.d.ts

@@ -0,0 +1,78 @@
+import type { CustomGptProvisioningRequest } from "./custom-gpt-editor-driver.ts";
+import { type CustomGptProvisioningBridgeOptions } from "./provisioning-bridge.ts";
+export type CustomGptPackageProvisioningMaterial = Omit<CustomGptProvisioningRequest, "actionSchema" | "knowledgeFiles" | "bearerCredential"> & {
+    actionSchema: string;
+};
+export type CustomGptProvisioningHostOptions = CustomGptProvisioningBridgeOptions & {
+    onlineTimeoutMs?: number;
+};
+export type CustomGptProvisioningResult = {
+    status: "LIVE_CREATED";
+    packageName: string;
+    version: string;
+    gptId: string;
+    carrierUrl: string;
+    knowledgeBundleSha256: string;
+    knowledgeFiles: Array<{
+        name: string;
+        mime: string;
+        sizeBytes: number;
+        sha256: string;
+    }>;
+};
+export declare function createCustomGptProvisioningHost(options: CustomGptProvisioningHostOptions): Promise<Readonly<{
+    endpoint: string;
+    status: () => {
+        online: boolean;
+        extensionInstanceId: string | null;
+        queuedCommands: number;
+        pendingCommands: number;
+        relayFiles: number;
+    };
+    provisionPackage: (input: {
+        packageRoot: string;
+        stagingRoot: string;
+        gatewayUrl: string;
+        material: CustomGptPackageProvisioningMaterial;
+        credential?: string;
+    }) => Promise<CustomGptProvisioningResult>;
+    finalizeRoleAuth: (input: {
+        carrierUrl: string;
+        credential: string;
+    }) => Promise<{
+        status: "AUTH_UPDATED";
+        gptId: string;
+        carrierUrl: string;
+    }>;
+    close: () => Promise<void>;
+}>>;
+export declare function createWorkspaceCustomGptProvisioningHost(input: {
+    workspaceRoot: string;
+    commandTimeoutMs?: number;
+    onlineTimeoutMs?: number;
+}): Promise<Readonly<{
+    endpoint: string;
+    status: () => {
+        online: boolean;
+        extensionInstanceId: string | null;
+        queuedCommands: number;
+        pendingCommands: number;
+        relayFiles: number;
+    };
+    provisionPackage: (input: {
+        packageRoot: string;
+        stagingRoot: string;
+        gatewayUrl: string;
+        material: CustomGptPackageProvisioningMaterial;
+        credential?: string;
+    }) => Promise<CustomGptProvisioningResult>;
+    finalizeRoleAuth: (input: {
+        carrierUrl: string;
+        credential: string;
+    }) => Promise<{
+        status: "AUTH_UPDATED";
+        gptId: string;
+        carrierUrl: string;
+    }>;
+    close: () => Promise<void>;
+}>>;

package/dist/src/custom-gpt-provisioner.js

@@ -0,0 +1,225 @@
+import { readFile, rm } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { readModuleSharedFacts } from "@tomflow/proflow-module-contract";
+import { materializeCustomGptKnowledgeBundle, } from "./custom-gpt-knowledge.js";
+import { createCustomGptProvisioningBridgeServer, } from "./provisioning-bridge.js";
+function packageAsset(packageRoot, asset, name) {
+    if (asset.length === 0 || isAbsolute(asset))
+        throw new Error(`${name}_INVALID`);
+    const root = resolve(packageRoot);
+    const path = resolve(root, asset);
+    const rel = relative(root, path);
+    if (rel === "" ||
+        rel === ".." ||
+        rel.startsWith(`..${sep}`) ||
+        isAbsolute(rel))
+        throw new Error(`${name}_OUTSIDE_PACKAGE`);
+    return path;
+}
+function publicGatewayUrl(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error("GATEWAY_URL_INVALID");
+    }
+    if (url.protocol !== "https:" ||
+        url.username !== "" ||
+        url.password !== "" ||
+        url.search !== "" ||
+        url.hash !== "")
+        throw new Error("GATEWAY_URL_INVALID");
+    return url.toString().replace(/\/$/, "");
+}
+function hydratedSchema(schema, gatewayUrl) {
+    const gateway = publicGatewayUrl(gatewayUrl);
+    if (schema.includes("https://GATEWAY_PUBLIC_HOST"))
+        return schema.replaceAll("https://GATEWAY_PUBLIC_HOST", gateway);
+    if (!schema.includes(gateway))
+        throw new Error("ACTION_SCHEMA_GATEWAY_MISMATCH");
+    return schema;
+}
+function fileEvidence(files) {
+    return files.map(({ name, mime, sizeBytes, sha256 }) => ({
+        name,
+        mime,
+        sizeBytes,
+        sha256,
+    }));
+}
+function liveResult(value, material) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("PROVISIONING_RESULT_INVALID");
+    const result = value;
+    if (result.status !== "LIVE_CREATED" ||
+        result.packageName !== material.packageName ||
+        result.version !== material.version ||
+        typeof result.gptId !== "string" ||
+        !/^g-[A-Za-z0-9_-]+$/.test(result.gptId) ||
+        typeof result.carrierUrl !== "string")
+        throw new Error("PROVISIONING_RESULT_INVALID");
+    const expected = `https://chatgpt.com/g/${result.gptId}`;
+    if (result.carrierUrl !== expected)
+        throw new Error("PROVISIONING_RESULT_INVALID");
+    return {
+        status: "LIVE_CREATED",
+        packageName: material.packageName,
+        version: material.version,
+        gptId: result.gptId,
+        carrierUrl: result.carrierUrl,
+    };
+}
+function carrierGptId(carrierUrl) {
+    const url = new URL(carrierUrl);
+    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("PROVISIONING_CARRIER_URL_INVALID");
+    return match[1];
+}
+function authResult(value, carrierUrl) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("PROVISIONING_AUTH_RESULT_INVALID");
+    const result = value;
+    const expectedGptId = carrierGptId(carrierUrl);
+    if (result.status !== "AUTH_UPDATED" || result.gptId !== expectedGptId)
+        throw new Error("PROVISIONING_AUTH_RESULT_INVALID");
+    return { status: "AUTH_UPDATED", gptId: expectedGptId, carrierUrl };
+}
+const sleep = (milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds));
+export async function createCustomGptProvisioningHost(options) {
+    const bridge = await createCustomGptProvisioningBridgeServer(options);
+    const onlineTimeoutMs = options.onlineTimeoutMs ?? 30_000;
+    async function waitUntilOnline() {
+        const deadline = Date.now() + onlineTimeoutMs;
+        while (Date.now() < deadline) {
+            if (bridge.status().online)
+                return;
+            await sleep(100);
+        }
+        throw new Error("PROVISIONING_EXTENSION_OFFLINE");
+    }
+    async function provisionPackage(input) {
+        await waitUntilOnline();
+        if (input.credential !== undefined && input.credential.length < 32)
+            throw new Error("PROVISIONING_ROLE_CREDENTIAL_INVALID");
+        const schemaPath = packageAsset(input.packageRoot, input.material.actionSchema, "ACTION_SCHEMA_PATH");
+        const bundlePath = packageAsset(input.packageRoot, input.material.knowledgeBundle, "KNOWLEDGE_BUNDLE_PATH");
+        const schema = hydratedSchema(await readFile(schemaPath, "utf8"), input.gatewayUrl);
+        const bundle = await materializeCustomGptKnowledgeBundle({
+            bundlePath,
+            stagingRoot: input.stagingRoot,
+        });
+        try {
+            const relayFiles = await bridge.provisioning.registerFiles(bundle.files.map((file) => ({
+                name: file.name,
+                path: file.path,
+                mime: file.mime,
+            })));
+            const request = {
+                ...input.material,
+                actionSchema: schema,
+                ...(input.credential === undefined
+                    ? {}
+                    : { bearerCredential: input.credential }),
+                knowledgeFiles: relayFiles.map(({ name, mime, sizeBytes, sha256, url }) => ({
+                    name,
+                    mime,
+                    sizeBytes,
+                    sha256,
+                    url,
+                })),
+            };
+            if (JSON.stringify(request).length >= 100_000)
+                throw new Error("PROVISIONING_REQUEST_BUDGET_EXCEEDED");
+            const value = await bridge.provisioning.request({
+                type: "PROVISION_CUSTOM_GPT",
+                request,
+            });
+            return {
+                ...liveResult(value, input.material),
+                knowledgeBundleSha256: bundle.bundleSha256,
+                knowledgeFiles: fileEvidence(bundle.files),
+            };
+        }
+        finally {
+            await rm(bundle.stagingDirectory, { recursive: true, force: true });
+        }
+    }
+    async function finalizeRoleAuth(input) {
+        await waitUntilOnline();
+        carrierGptId(input.carrierUrl);
+        if (input.credential.length < 32)
+            throw new Error("PROVISIONING_ROLE_CREDENTIAL_INVALID");
+        let credential = input.credential;
+        try {
+            const value = await bridge.provisioning.request({
+                type: "FINALIZE_CUSTOM_GPT_AUTH",
+                request: { carrierUrl: input.carrierUrl, credential },
+            });
+            return authResult(value, input.carrierUrl);
+        }
+        finally {
+            credential = "";
+        }
+    }
+    return Object.freeze({
+        endpoint: bridge.endpoint,
+        status: bridge.status,
+        provisionPackage,
+        finalizeRoleAuth,
+        close: bridge.close,
+    });
+}
+function sharedFactString(facts, name) {
+    const value = facts?.[name];
+    if (typeof value !== "string" || value.length === 0)
+        throw new Error(`PROVISIONING_SHARED_FACT_MISSING:${name}`);
+    return value;
+}
+export async function createWorkspaceCustomGptProvisioningHost(input) {
+    const moduleRef = "execution-browser-extension";
+    const facts = await readModuleSharedFacts({ workspaceRoot: input.workspaceRoot }, moduleRef);
+    const extensionId = sharedFactString(facts, "extensionId");
+    if (!/^[a-z]{32}$/.test(extensionId))
+        throw new Error("PROVISIONING_EXTENSION_ID_INVALID");
+    const tokenFile = sharedFactString(facts, "provisioningBridgeTokenFile");
+    const endpointText = sharedFactString(facts, "provisioningBridgeEndpoint");
+    let endpoint;
+    try {
+        endpoint = new URL(endpointText);
+    }
+    catch {
+        throw new Error("PROVISIONING_ENDPOINT_INVALID");
+    }
+    const port = Number(endpoint.port);
+    if (endpoint.protocol !== "http:" ||
+        endpoint.hostname !== "127.0.0.1" ||
+        endpoint.pathname !== "/" ||
+        endpoint.search !== "" ||
+        endpoint.hash !== "" ||
+        !Number.isInteger(port) ||
+        port <= 0 ||
+        port > 65_535)
+        throw new Error("PROVISIONING_ENDPOINT_INVALID");
+    const token = (await readFile(tokenFile, "utf8")).trim();
+    if (token.length < 32)
+        throw new Error("PROVISIONING_TOKEN_INVALID");
+    return createCustomGptProvisioningHost({
+        token,
+        extensionId,
+        host: "127.0.0.1",
+        port,
+        ...(input.commandTimeoutMs === undefined
+            ? {}
+            : { commandTimeoutMs: input.commandTimeoutMs }),
+        ...(input.onlineTimeoutMs === undefined
+            ? {}
+            : { onlineTimeoutMs: input.onlineTimeoutMs }),
+    });
+}