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

package/dist/src/configure-args.d.ts

@@ -0,0 +1,3 @@
+export declare function parseBrowserExtensionSetupArgs(args: readonly string[], cwd: string): {
+    workspaceRoot: string;
+};

package/dist/src/configure-args.js

@@ -0,0 +1,23 @@
+import { resolve } from "node:path";
+export function parseBrowserExtensionSetupArgs(args, cwd) {
+    if (args[0] !== "setup")
+        throw new Error("SETUP_COMMAND_REQUIRED");
+    let workspaceRoot = resolve(cwd);
+    for (let index = 1; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--workspace") {
+            const workspace = args[index + 1];
+            if (!workspace || workspace.startsWith("--")) {
+                throw new Error("MISSING_WORKSPACE_VALUE");
+            }
+            workspaceRoot = resolve(workspace);
+            index += 1;
+            continue;
+        }
+        if (value?.startsWith("--")) {
+            throw new Error(`UNSUPPORTED_SETUP_OPTION:${value}`);
+        }
+        throw new Error(`UNSUPPORTED_SETUP_STEP:${value}`);
+    }
+    return { workspaceRoot };
+}

package/dist/src/configure.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { spawn, spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { createInterface } from "node:readline/promises";
 import { behaviorAdapter, materializeProductionConfig, } from "../deployment/adapter.js";
+import { parseBrowserExtensionSetupArgs } from "./configure-args.js";
+import { browserExtensionSetupFailureMessage, browserExtensionSetupSuccessMessage, runInteractiveBrowserExtensionSetup, } from "./install-workflow.js";
 function reportFatal(error) {
-    process.stderr.write(`✕ 配置失败\n  ${error instanceof Error ? error.message : String(error)}\n`);
+    process.stderr.write(browserExtensionSetupFailureMessage(error));
     process.exitCode = 1;
 }
 process.on("uncaughtException", reportFatal);
@@ -41,21 +41,6 @@ export async function materializeBrowserExtensionConfig(workspaceRoot) {
         workspaceRoot,
     });
 }
-function openChromeExtensions() {
-    const url = "chrome://extensions";
-    const command = process.platform === "darwin"
-        ? "open"
-        : process.platform === "win32"
-            ? "cmd"
-            : "xdg-open";
-    const parameters = process.platform === "darwin"
-        ? ["-a", "Google Chrome", url]
-        : process.platform === "win32"
-            ? ["/c", "start", "", url]
-            : [url];
-    const child = spawn(command, parameters, { detached: true, stdio: "ignore" });
-    child.unref();
-}
 async function main() {
     const args = process.argv.slice(2);
     if (args.includes("--json"))
@@ -68,60 +53,12 @@ async function main() {
         ? resolve(option("--workspace"))
         : process.cwd();
     if (args[0] === "setup") {
-        const step = args[1]?.startsWith("--") ? undefined : args[1];
-        if (step === "01") {
-            const prepared = await behaviorAdapter.install({ workspaceRoot });
-            const loadDir = String(prepared.result.data.loadDir);
-            const command = process.platform === "darwin"
-                ? "pbcopy"
-                : process.platform === "win32"
-                    ? "clip"
-                    : "xclip";
-            const parameters = process.platform === "linux" ? ["-selection", "clipboard"] : [];
-            spawnSync(command, parameters, { input: loadDir, encoding: "utf8" });
-            openChromeExtensions();
-            process.stdout.write(`\n✓ 扩展目录已准备并复制到剪贴板\n  ${loadDir}\n  启用开发者模式并加载该目录，然后运行 setup 02。\n`);
-            return;
-        }
-        if (step === "03") {
-            const result = await behaviorAdapter.status({ workspaceRoot });
-            process.stdout.write(result.result.data.setupStatus === "READY"
-                ? "✓ Service Worker 与 Bridge 验证通过\n"
-                : "✕ 扩展尚未就绪，请检查 Reload 和后台错误\n");
-            if (result.result.data.setupStatus !== "READY")
-                process.exitCode = 1;
-            return;
-        }
-        if (step !== undefined && step !== "02")
-            throw new Error(`UNSUPPORTED_SETUP_STEP:${step}`);
-        let extensionId = option("--extension-id");
-        if (!extensionId && !process.stdin.isTTY)
-            throw new Error("非交互环境必须提供 --extension-id");
-        if (!extensionId) {
-            const prepared = await behaviorAdapter.install({ workspaceRoot });
-            const loadDir = String(prepared.result.data.loadDir);
-            const prompt = createInterface({
-                input: process.stdin,
-                output: process.stdout,
-            });
-            try {
-                process.stdout.write(`\nChrome 扩展配置\n\n  1. 已准备扩展目录：${loadDir}\n  2. 在 Chrome 打开“扩展程序”，启用“开发者模式”。\n  3. 点击“加载已解压的扩展程序”，选择上面的目录。\n  4. 确认 Service Worker（后台服务）显示正常，再复制扩展 ID。\n\n`);
-                openChromeExtensions();
-                extensionId = await prompt.question("◆ Chrome Extension ID（32 位小写字母）\n> ");
-            }
-            finally {
-                prompt.close();
-            }
-        }
-        const result = await behaviorAdapter.setup({
-            workspaceRoot,
-            input: { extensionId, serviceWorker: "RUNNING" },
+        const setup = parseBrowserExtensionSetupArgs(args, process.cwd());
+        await runInteractiveBrowserExtensionSetup({
+            workspaceRoot: setup.workspaceRoot,
+            timeoutMs: 120_000,
         });
-        process.stdout.write(result.result.status === "SUCCEEDED"
-            ? "\n✓ Extension ID 已保存\n✓ Service Worker 运行证据已记录\n"
-            : "\n✕ 浏览器扩展尚未就绪，请检查扩展错误后重试。\n");
-        if (result.result.status === "FAILED")
-            process.exitCode = 1;
+        process.stdout.write(browserExtensionSetupSuccessMessage());
         return;
     }
     if (args[0] === "verify") {

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>;
+}>>;