@byteplus-iga-pages/agent 0.0.0-stage → 1.0.4

package/dist/cjs/893.js.LICENSE.txt

@@ -0,0 +1,13 @@
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */

package/dist/cjs/951.js

@@ -0,0 +1,59 @@
+"use strict";
+exports.ids = [
+    "951"
+];
+exports.modules = {
+    "../store/src/runtime-data-plane.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            G: ()=>executeRuntimeStoreOperation,
+            y: ()=>resolveRuntimeStore
+        });
+        var _iga_pages_data_plane__rspack_import_0 = __webpack_require__("../data-plane/dist/esm/index.js");
+        var _credential_provider_js__rspack_import_2 = __webpack_require__("../store/src/credential-provider.ts");
+        var _errors_js__rspack_import_1 = __webpack_require__("../store/src/errors.ts");
+        var _store_js__rspack_import_5 = __webpack_require__("../store/src/store.ts");
+        var _supabase_transport_js__rspack_import_4 = __webpack_require__("../store/src/supabase-transport.ts");
+        var _token_client_js__rspack_import_3 = __webpack_require__("../store/src/token-client.ts");
+        let runtimeDataPlane;
+        function requireRuntimeEnv(name) {
+            const value = "u" < typeof process ? void 0 : process.env[name]?.trim();
+            if (!value) throw new _errors_js__rspack_import_1.A("ServiceUnavailable", "Store is only available in the IGA Pages server runtime.");
+            return value;
+        }
+        function resolveRuntimeDataPlane() {
+            if (runtimeDataPlane) return runtimeDataPlane;
+            const token = requireRuntimeEnv("IGA_AUTH_KEY");
+            const provider = new _credential_provider_js__rspack_import_2.q1({
+                fetchCredentials: ()=>(0, _token_client_js__rspack_import_3.o)({
+                        endpoint: _iga_pages_data_plane__rspack_import_0.KK,
+                        token,
+                        isAllowedTokenEndpoint: (url)=>{
+                            const allowed = new URL(_iga_pages_data_plane__rspack_import_0.KK);
+                            return url.origin === allowed.origin && url.pathname === allowed.pathname;
+                        },
+                        isAllowedHostname: (hostname)=>hostname.endsWith(_iga_pages_data_plane__rspack_import_0.I7)
+                    })
+            });
+            const transport = new _supabase_transport_js__rspack_import_4.H({
+                credentialProvider: provider
+            });
+            runtimeDataPlane = {
+                provider,
+                transport
+            };
+            return runtimeDataPlane;
+        }
+        async function resolveRuntimeStore() {
+            const runtime = resolveRuntimeDataPlane();
+            if (runtime.store) return runtime.store;
+            const projectId = await runtime.provider.getProjectId();
+            return runtime.store ??= (0, _store_js__rspack_import_5.y$)({
+                projectId,
+                transport: runtime.transport
+            });
+        }
+        function executeRuntimeStoreOperation(options) {
+            return resolveRuntimeDataPlane().transport.execute(options);
+        }
+    }
+};

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/runtime.js

@@ -0,0 +1,79 @@
+"use strict";
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId].call(module1.exports, module1, module1.exports, __webpack_require__);
+    return module1.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module1)=>{
+        var getter = module1 && module1.__esModule ? ()=>module1['default'] : ()=>module1;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.f = {};
+    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + chunkId + ".js";
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.X = (result, chunkIds, fn)=>{
+        var moduleId = chunkIds;
+        if (!fn) chunkIds = result, fn = ()=>__webpack_require__(__webpack_require__.s = moduleId);
+        chunkIds.map(__webpack_require__.e, __webpack_require__);
+        var r = fn();
+        return void 0 === r ? result : r;
+    };
+})();
+(()=>{
+    var installedChunks = {
+        146: 1
+    };
+    var installChunk = (chunk)=>{
+        var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
+        for(var moduleId in moreModules)if (__webpack_require__.o(moreModules, moduleId)) __webpack_require__.m[moduleId] = moreModules[moduleId];
+        if (runtime) runtime(__webpack_require__);
+        for(var i = 0; i < chunkIds.length; i++)installedChunks[chunkIds[i]] = 1;
+    };
+    __webpack_require__.f.require = (chunkId, promises)=>{
+        if (!installedChunks[chunkId]) if (146 != chunkId) installChunk(require("./" + __webpack_require__.u(chunkId)));
+        else installedChunks[chunkId] = 1;
+    };
+    module.exports = __webpack_require__;
+    __webpack_require__.C = installChunk;
+})();

package/dist/cjs/sandbox/host.js

@@ -0,0 +1,125 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "802"
+    ];
+    exports.modules = {
+        "../sandbox/src/host.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                IgaSandbox: ()=>_iga_sandbox_js__rspack_import_0.RN,
+                SandboxApi: ()=>_api_client_js__rspack_import_1.K,
+                SupabaseSandboxBindingRepository: ()=>_binding_repository_js__rspack_import_2.t,
+                __clearSandboxCacheForTests: ()=>_iga_sandbox_js__rspack_import_0.rG,
+                __getEntryForTests: ()=>_iga_sandbox_js__rspack_import_0.pf,
+                attachSandbox: ()=>_iga_sandbox_js__rspack_import_0.R9,
+                createDetachedSandbox: ()=>_iga_sandbox_js__rspack_import_0.CT,
+                createRuntimeSandboxBindingRepository: ()=>_binding_repository_js__rspack_import_2.P,
+                createSandbox: ()=>_iga_sandbox_js__rspack_import_0._i,
+                createSandboxApi: ()=>_api_client_js__rspack_import_1.SW,
+                isInstanceGoneResponse: ()=>_iga_sandbox_js__rspack_import_0.gk
+            });
+            var _iga_sandbox_js__rspack_import_0 = __webpack_require__("../sandbox/src/iga-sandbox.ts");
+            var _api_client_js__rspack_import_1 = __webpack_require__("../sandbox/src/api-client.ts");
+            var _binding_repository_js__rspack_import_2 = __webpack_require__("../sandbox/src/binding-repository.ts");
+        },
+        assert (module) {
+            module.exports = require("assert");
+        },
+        crypto (module) {
+            module.exports = require("crypto");
+        },
+        events (module) {
+            module.exports = require("events");
+        },
+        fs (module) {
+            module.exports = require("fs");
+        },
+        http (module) {
+            module.exports = require("http");
+        },
+        http2 (module) {
+            module.exports = require("http2");
+        },
+        https (module) {
+            module.exports = require("https");
+        },
+        net (module) {
+            module.exports = require("net");
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        },
+        "node:http" (module) {
+            module.exports = require("node:http");
+        },
+        "node:https" (module) {
+            module.exports = require("node:https");
+        },
+        os (module) {
+            module.exports = require("os");
+        },
+        path (module) {
+            module.exports = require("path");
+        },
+        stream (module) {
+            module.exports = require("stream");
+        },
+        tls (module) {
+            module.exports = require("tls");
+        },
+        tty (module) {
+            module.exports = require("tty");
+        },
+        url (module) {
+            module.exports = require("url");
+        },
+        util (module) {
+            module.exports = require("util");
+        },
+        zlib (module) {
+            module.exports = require("zlib");
+        }
+    };
+    var __webpack_require__ = require("../runtime.js");
+    __webpack_require__.C(exports);
+    var __webpack_exec__ = function(moduleId) {
+        return __webpack_require__(__webpack_require__.s = moduleId);
+    };
+    var __webpack_exports__ = __webpack_require__.X(0, [
+        "341",
+        "647",
+        "808",
+        "82",
+        "893"
+    ], function() {
+        return __webpack_exec__("../sandbox/src/host.ts");
+    });
+    exports.IgaSandbox = __webpack_exports__.IgaSandbox;
+    exports.SandboxApi = __webpack_exports__.SandboxApi;
+    exports.SupabaseSandboxBindingRepository = __webpack_exports__.SupabaseSandboxBindingRepository;
+    exports.__clearSandboxCacheForTests = __webpack_exports__.__clearSandboxCacheForTests;
+    exports.__getEntryForTests = __webpack_exports__.__getEntryForTests;
+    exports.attachSandbox = __webpack_exports__.attachSandbox;
+    exports.createDetachedSandbox = __webpack_exports__.createDetachedSandbox;
+    exports.createRuntimeSandboxBindingRepository = __webpack_exports__.createRuntimeSandboxBindingRepository;
+    exports.createSandbox = __webpack_exports__.createSandbox;
+    exports.createSandboxApi = __webpack_exports__.createSandboxApi;
+    exports.isInstanceGoneResponse = __webpack_exports__.isInstanceGoneResponse;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "IgaSandbox",
+        "SandboxApi",
+        "SupabaseSandboxBindingRepository",
+        "__clearSandboxCacheForTests",
+        "__getEntryForTests",
+        "attachSandbox",
+        "createDetachedSandbox",
+        "createRuntimeSandboxBindingRepository",
+        "createSandbox",
+        "createSandboxApi",
+        "isInstanceGoneResponse"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();

package/dist/cjs/sandbox/index.js

@@ -0,0 +1,286 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "14"
+    ];
+    exports.modules = {
+        "../sandbox/src/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                connectSandbox: ()=>connectSandbox,
+                createSandbox: ()=>createSandbox,
+                SandboxError: ()=>src_error.ES,
+                getConversationSandbox: ()=>getConversationSandbox,
+                isAbortError: ()=>src_error.zf
+            });
+            var esm = __webpack_require__("../data-plane/dist/esm/index.js");
+            var src_error = __webpack_require__("../sandbox/src/error.ts");
+            var binding_repository = __webpack_require__("../sandbox/src/binding-repository.ts");
+            var iga_sandbox = __webpack_require__("../sandbox/src/iga-sandbox.ts");
+            const PUBLIC_SANDBOX_METHODS = {
+                code: [
+                    "executeCode"
+                ],
+                shell: [
+                    "execCommand",
+                    "view",
+                    "waitForProcess",
+                    "killProcess"
+                ],
+                file: [
+                    "readFile",
+                    "writeFile",
+                    "replaceInFile",
+                    "searchInFile",
+                    "findFiles",
+                    "grepFiles",
+                    "listPath"
+                ],
+                browserPage: [
+                    "navigate",
+                    "back",
+                    "forward",
+                    "reload",
+                    "click",
+                    "fill",
+                    "typeText",
+                    "pressKey",
+                    "hotKey",
+                    "hover",
+                    "selectOption",
+                    "check",
+                    "uncheck",
+                    "uploadFile",
+                    "scroll",
+                    "scrollTo",
+                    "scrollToElement",
+                    "screenshot",
+                    "getHtml",
+                    "getText",
+                    "wait"
+                ]
+            };
+            const PUBLIC_SANDBOX_MODULES = Object.keys(PUBLIC_SANDBOX_METHODS);
+            function createPublicModules(invoke) {
+                const modules = Object.create(null);
+                for (const name of PUBLIC_SANDBOX_MODULES){
+                    const methods = Object.create(null);
+                    for (const method of PUBLIC_SANDBOX_METHODS[name])methods[method] = (...args)=>invoke(name, method, args);
+                    modules[name] = Object.freeze(methods);
+                }
+                return Object.freeze(modules);
+            }
+            const PUBLIC_METHODS = new Set([
+                "getInfo",
+                "extendTimeout",
+                "destroy"
+            ]);
+            let runtimeConfig;
+            function getConversationSandbox(conversationId) {
+                if ("string" != typeof conversationId || 0 === conversationId.length) throw new src_error.ES("conversationId must be a non-empty string.");
+                if (Buffer.byteLength(conversationId, "utf8") > 256) throw new src_error.ES("conversationId must not exceed 256 UTF-8 bytes");
+                const config = resolveRuntimeConfig();
+                return createDeferredSandbox(config, {
+                    conversationId
+                }, (projectId)=>(0, iga_sandbox._i)({
+                        projectId,
+                        conversationId,
+                        apiBaseUrl: esm.$Y,
+                        apiToken: config.token,
+                        bindingRepository: config.bindingRepository
+                    }));
+            }
+            async function createSandbox() {
+                const config = resolveRuntimeConfig();
+                const instance = (0, iga_sandbox.CT)({
+                    projectId: await resolveProjectId(config),
+                    apiBaseUrl: esm.$Y,
+                    apiToken: config.token
+                });
+                await instance.ensureReady();
+                return createPublicSandbox(instance);
+            }
+            function connectSandbox(sandboxId) {
+                if (!sandboxId || "string" != typeof sandboxId) throw new src_error.ES("sandboxId is required.");
+                const config = resolveRuntimeConfig();
+                return createDeferredSandbox(config, {
+                    sandboxId
+                }, (projectId)=>(0, iga_sandbox.R9)({
+                        projectId,
+                        sandboxId,
+                        apiBaseUrl: esm.$Y,
+                        apiToken: config.token
+                    }));
+            }
+            function requireRuntimeEnv(name) {
+                const value = "u" < typeof process ? void 0 : process.env[name]?.trim();
+                if (!value) throw new src_error.ES("Sandbox is only available in the IGA Pages server runtime.");
+                return value;
+            }
+            function resolveRuntimeConfig() {
+                if (runtimeConfig) return runtimeConfig;
+                const token = requireRuntimeEnv("IGA_AUTH_KEY");
+                const provider = new esm.ZQ({
+                    fetchCredentials: ()=>(0, esm.FM)({
+                            token
+                        })
+                });
+                runtimeConfig = {
+                    provider,
+                    token,
+                    bindingRepository: new binding_repository.t({
+                        credentialProvider: provider
+                    })
+                };
+                return runtimeConfig;
+            }
+            async function resolveProjectId(config, signal) {
+                try {
+                    return await config.provider.getProjectId(signal);
+                } catch (error) {
+                    if (!(error instanceof esm.d)) throw error;
+                    const ErrorClass = "aborted" === error.code ? src_error.sX : src_error.ES;
+                    throw new ErrorClass(error.message, {
+                        status: error.status
+                    });
+                }
+            }
+            function requestSignal(args) {
+                const last = args[args.length - 1];
+                if (!last || "object" != typeof last || !("abortSignal" in last)) return;
+                const signal = last.abortSignal;
+                return signal && "boolean" == typeof signal.aborted && "function" == typeof signal.addEventListener && "function" == typeof signal.removeEventListener ? signal : void 0;
+            }
+            function createDeferredSandbox(config, ids, create) {
+                let instance;
+                const resolve = async (args)=>{
+                    const signal = requestSignal(args);
+                    if (instance) return instance;
+                    const projectId = await resolveProjectId(config, signal);
+                    if (signal?.aborted) throw new src_error.sX("Sandbox request was cancelled.");
+                    return instance ??= create(projectId);
+                };
+                const target = Object.create(null);
+                for (const property of [
+                    "conversationId",
+                    "sandboxId"
+                ])Object.defineProperty(target, property, {
+                    enumerable: true,
+                    get: ()=>instance?.[property] ?? ids[property]
+                });
+                for (const method of PUBLIC_METHODS)target[method] = async (...args)=>{
+                    const current = await resolve(args);
+                    return Reflect.apply(Reflect.get(current, method), current, args);
+                };
+                Object.assign(target, createPublicModules(async (name, method, args)=>{
+                    const current = await resolve(args);
+                    const module = current[name];
+                    return Reflect.apply(Reflect.get(module, method), module, args);
+                }));
+                return Object.freeze(target);
+            }
+            function createPublicSandbox(instance) {
+                const target = Object.create(null);
+                for (const property of [
+                    "conversationId",
+                    "sandboxId"
+                ])Object.defineProperty(target, property, {
+                    enumerable: true,
+                    get: ()=>instance[property]
+                });
+                for (const method of PUBLIC_METHODS)target[method] = (...args)=>Reflect.apply(Reflect.get(instance, method), instance, args);
+                Object.assign(target, createPublicModules((name, method, args)=>{
+                    const module = instance[name];
+                    return Reflect.apply(Reflect.get(module, method), module, args);
+                }));
+                return Object.freeze(target);
+            }
+        },
+        assert (module) {
+            module.exports = require("assert");
+        },
+        crypto (module) {
+            module.exports = require("crypto");
+        },
+        events (module) {
+            module.exports = require("events");
+        },
+        fs (module) {
+            module.exports = require("fs");
+        },
+        http (module) {
+            module.exports = require("http");
+        },
+        http2 (module) {
+            module.exports = require("http2");
+        },
+        https (module) {
+            module.exports = require("https");
+        },
+        net (module) {
+            module.exports = require("net");
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        },
+        "node:http" (module) {
+            module.exports = require("node:http");
+        },
+        "node:https" (module) {
+            module.exports = require("node:https");
+        },
+        os (module) {
+            module.exports = require("os");
+        },
+        path (module) {
+            module.exports = require("path");
+        },
+        stream (module) {
+            module.exports = require("stream");
+        },
+        tls (module) {
+            module.exports = require("tls");
+        },
+        tty (module) {
+            module.exports = require("tty");
+        },
+        url (module) {
+            module.exports = require("url");
+        },
+        util (module) {
+            module.exports = require("util");
+        },
+        zlib (module) {
+            module.exports = require("zlib");
+        }
+    };
+    var __webpack_require__ = require("../runtime.js");
+    __webpack_require__.C(exports);
+    var __webpack_exec__ = function(moduleId) {
+        return __webpack_require__(__webpack_require__.s = moduleId);
+    };
+    var __webpack_exports__ = __webpack_require__.X(0, [
+        "341",
+        "647",
+        "808",
+        "82",
+        "893"
+    ], function() {
+        return __webpack_exec__("../sandbox/src/index.ts");
+    });
+    exports.SandboxError = __webpack_exports__.SandboxError;
+    exports.connectSandbox = __webpack_exports__.connectSandbox;
+    exports.createSandbox = __webpack_exports__.createSandbox;
+    exports.getConversationSandbox = __webpack_exports__.getConversationSandbox;
+    exports.isAbortError = __webpack_exports__.isAbortError;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "SandboxError",
+        "connectSandbox",
+        "createSandbox",
+        "getConversationSandbox",
+        "isAbortError"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();