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

package/dist/esm/613.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/esm/951.js

@@ -0,0 +1,44 @@
+import { STORE_TOKEN_ENDPOINT, ALLOWED_STORE_HOST_SUFFIX } from "./128.js";
+import { StoreError, credential_provider_StoreCredentialProvider, fetchStoreCredentials, SupabaseStoreTransport, createStore } from "./417.js";
+let runtimeDataPlane;
+function requireRuntimeEnv(name) {
+    const value = "u" < typeof process ? void 0 : process.env[name]?.trim();
+    if (!value) throw new StoreError("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_StoreCredentialProvider({
+        fetchCredentials: ()=>fetchStoreCredentials({
+                endpoint: STORE_TOKEN_ENDPOINT,
+                token,
+                isAllowedTokenEndpoint: (url)=>{
+                    const allowed = new URL(STORE_TOKEN_ENDPOINT);
+                    return url.origin === allowed.origin && url.pathname === allowed.pathname;
+                },
+                isAllowedHostname: (hostname)=>hostname.endsWith(ALLOWED_STORE_HOST_SUFFIX)
+            })
+    });
+    const transport = new SupabaseStoreTransport({
+        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 ??= createStore({
+        projectId,
+        transport: runtime.transport
+    });
+}
+function executeRuntimeStoreOperation(options) {
+    return resolveRuntimeDataPlane().transport.execute(options);
+}
+export { executeRuntimeStoreOperation, resolveRuntimeStore };

package/dist/esm/package.json

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

package/dist/esm/runtime.js

@@ -0,0 +1,39 @@
+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 module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+(()=>{
+    __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__.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
+        });
+    };
+})();
+export { __webpack_require__ };

package/dist/esm/sandbox/host.js

@@ -0,0 +1 @@
+export { IgaSandbox, SandboxApi, SupabaseSandboxBindingRepository, __clearSandboxCacheForTests, __getEntryForTests, attachSandbox, createDetachedSandbox, createRuntimeSandboxBindingRepository, createSandbox, createSandboxApi, isInstanceGoneResponse } from "../613.js";

package/dist/esm/sandbox/index.js

@@ -0,0 +1,183 @@
+import { DataPlaneCredentialProvider, DataPlaneError, CONTROL_PLANE_BASE_URL, fetchRuntimeDataPlaneCredentials } from "../128.js";
+import { SandboxError, SandboxAbortError } from "../341.js";
+import { createSandbox as iga_sandbox_createSandbox, createDetachedSandbox, attachSandbox, SupabaseSandboxBindingRepository } from "../613.js";
+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 SandboxError("conversationId must be a non-empty string.");
+    if (Buffer.byteLength(conversationId, "utf8") > 256) throw new SandboxError("conversationId must not exceed 256 UTF-8 bytes");
+    const config = resolveRuntimeConfig();
+    return createDeferredSandbox(config, {
+        conversationId
+    }, (projectId)=>iga_sandbox_createSandbox({
+            projectId,
+            conversationId,
+            apiBaseUrl: CONTROL_PLANE_BASE_URL,
+            apiToken: config.token,
+            bindingRepository: config.bindingRepository
+        }));
+}
+async function createSandbox() {
+    const config = resolveRuntimeConfig();
+    const instance = createDetachedSandbox({
+        projectId: await resolveProjectId(config),
+        apiBaseUrl: CONTROL_PLANE_BASE_URL,
+        apiToken: config.token
+    });
+    await instance.ensureReady();
+    return createPublicSandbox(instance);
+}
+function connectSandbox(sandboxId) {
+    if (!sandboxId || "string" != typeof sandboxId) throw new SandboxError("sandboxId is required.");
+    const config = resolveRuntimeConfig();
+    return createDeferredSandbox(config, {
+        sandboxId
+    }, (projectId)=>attachSandbox({
+            projectId,
+            sandboxId,
+            apiBaseUrl: CONTROL_PLANE_BASE_URL,
+            apiToken: config.token
+        }));
+}
+function requireRuntimeEnv(name) {
+    const value = "u" < typeof process ? void 0 : process.env[name]?.trim();
+    if (!value) throw new SandboxError("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 DataPlaneCredentialProvider({
+        fetchCredentials: ()=>fetchRuntimeDataPlaneCredentials({
+                token
+            })
+    });
+    runtimeConfig = {
+        provider,
+        token,
+        bindingRepository: new SupabaseSandboxBindingRepository({
+            credentialProvider: provider
+        })
+    };
+    return runtimeConfig;
+}
+async function resolveProjectId(config, signal) {
+    try {
+        return await config.provider.getProjectId(signal);
+    } catch (error) {
+        if (!(error instanceof DataPlaneError)) throw error;
+        const ErrorClass = "aborted" === error.code ? SandboxAbortError : SandboxError;
+        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 SandboxAbortError("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);
+}
+export { SandboxError, isAbortError } from "../341.js";
+export { connectSandbox, createSandbox, getConversationSandbox };

package/dist/esm/store/claude.js

@@ -0,0 +1,172 @@
+import { executeRuntimeStoreOperation } from "../951.js";
+import { StoreError, cloneJsonObject } from "../417.js";
+const CLAUDE_RPC_NAMES = {
+    append: "claude_session_append",
+    load: "claude_session_load",
+    listSessions: "claude_session_list_sessions",
+    delete: "claude_session_delete",
+    listSubkeys: "claude_session_list_subkeys"
+};
+function rpcOperation(name, params) {
+    return (client)=>client.rpc(name, params);
+}
+function keyParams(key) {
+    return {
+        p_project_key: key.projectKey,
+        p_session_id: key.sessionId,
+        p_subpath: key.subpath
+    };
+}
+function hasStableUuid(entry) {
+    return "string" == typeof entry.uuid && entry.uuid.length > 0;
+}
+class ClaudeSessionRepository {
+    async append(key, entries) {
+        await this.execute({
+            operationName: "store.claude.append",
+            retryOnUnauthorized: true,
+            retryOnNetworkError: entries.every(hasStableUuid),
+            operation: rpcOperation(CLAUDE_RPC_NAMES.append, {
+                ...keyParams(key),
+                p_entries: entries
+            })
+        });
+    }
+    async load(key) {
+        const result = await this.execute({
+            operationName: "store.claude.load",
+            retryOnUnauthorized: true,
+            retryOnNetworkError: true,
+            operation: rpcOperation(CLAUDE_RPC_NAMES.load, keyParams(key))
+        });
+        return result.data;
+    }
+    async listSessions(projectKey) {
+        const result = await this.execute({
+            operationName: "store.claude.listSessions",
+            retryOnUnauthorized: true,
+            retryOnNetworkError: true,
+            operation: rpcOperation(CLAUDE_RPC_NAMES.listSessions, {
+                p_project_key: projectKey
+            })
+        });
+        return result.data;
+    }
+    async delete(key) {
+        await this.execute({
+            operationName: "store.claude.delete",
+            retryOnUnauthorized: true,
+            retryOnNetworkError: true,
+            operation: rpcOperation(CLAUDE_RPC_NAMES.delete, keyParams(key))
+        });
+    }
+    async listSubkeys(input) {
+        const result = await this.execute({
+            operationName: "store.claude.listSubkeys",
+            retryOnUnauthorized: true,
+            retryOnNetworkError: true,
+            operation: rpcOperation(CLAUDE_RPC_NAMES.listSubkeys, {
+                p_project_key: input.projectKey,
+                p_session_id: input.sessionId
+            })
+        });
+        return result.data;
+    }
+    constructor(execute = executeRuntimeStoreOperation){
+        this.execute = execute;
+    }
+}
+const claudeSessionRepository = new ClaudeSessionRepository();
+function invalid(message) {
+    throw new StoreError("BadRequest", message);
+}
+function internal() {
+    throw new StoreError("UnknownError", "Store returned invalid data");
+}
+function requireInputString(value, field) {
+    if ("string" != typeof value || 0 === value.length) invalid(`${field} must be a non-empty string`);
+    return value;
+}
+function requireOutputString(value) {
+    if ("string" != typeof value || 0 === value.length) internal();
+    return value;
+}
+function materializeKey(key) {
+    if (null === key || "object" != typeof key) invalid("session key must be an object");
+    const projectKey = requireInputString(key.projectKey, "projectKey");
+    const sessionId = requireInputString(key.sessionId, "sessionId");
+    const subpath = void 0 === key.subpath ? null : requireInputString(key.subpath, "subpath");
+    return {
+        projectKey,
+        sessionId,
+        subpath
+    };
+}
+function materializeEntries(entries) {
+    if (!Array.isArray(entries)) invalid("entries must be an array");
+    return entries.map((entry, index)=>{
+        const cloned = cloneJsonObject(entry, `entries[${index}]`);
+        if ("string" != typeof cloned.type) invalid(`entries[${index}].type must be a string`);
+        return cloned;
+    });
+}
+function parseEntries(value) {
+    if (null === value) return null;
+    if (!Array.isArray(value)) internal();
+    return value.map((entry, index)=>{
+        let cloned;
+        try {
+            cloned = cloneJsonObject(entry, `store entries[${index}]`);
+        } catch  {
+            internal();
+        }
+        if ("string" != typeof cloned.type) internal();
+        return cloned;
+    });
+}
+function parseSessions(value) {
+    if (!Array.isArray(value)) internal();
+    return value.map((item)=>{
+        if (null === item || "object" != typeof item || Array.isArray(item)) internal();
+        const row = item;
+        const rawMtime = row.mtime;
+        const mtime = "number" == typeof rawMtime ? rawMtime : "string" == typeof rawMtime && /^\d+$/.test(rawMtime) ? Number(rawMtime) : NaN;
+        if (!Number.isSafeInteger(mtime) || mtime < 0) internal();
+        return {
+            sessionId: requireOutputString(row.session_id),
+            mtime
+        };
+    });
+}
+function parseSubkeys(value) {
+    if (!Array.isArray(value)) internal();
+    return value.map(requireOutputString);
+}
+class IgaClaudeSessionStore {
+    async append(key, entries) {
+        const materializedKey = materializeKey(key);
+        const materializedEntries = materializeEntries(entries);
+        if (0 === materializedEntries.length) return;
+        await claudeSessionRepository.append(materializedKey, materializedEntries);
+    }
+    async load(key) {
+        return parseEntries(await claudeSessionRepository.load(materializeKey(key)));
+    }
+    async listSessions(projectKey) {
+        return parseSessions(await claudeSessionRepository.listSessions(requireInputString(projectKey, "projectKey")));
+    }
+    async delete(key) {
+        await claudeSessionRepository["delete"](materializeKey(key));
+    }
+    async listSubkeys(key) {
+        if (null === key || "object" != typeof key) invalid("session key must be an object");
+        return parseSubkeys(await claudeSessionRepository.listSubkeys({
+            projectKey: requireInputString(key.projectKey, "projectKey"),
+            sessionId: requireInputString(key.sessionId, "sessionId")
+        }));
+    }
+}
+function createSessionStore() {
+    return new IgaClaudeSessionStore();
+}
+export { createSessionStore };

package/dist/esm/store/host.js

@@ -0,0 +1,46 @@
+import { SupabaseStoreTransport, StoreCredentialProviderCache, credential_provider_StoreCredentialProvider, createStore } from "../417.js";
+class StoreFactory {
+    create(scope) {
+        const credentialScope = {
+            environment: this.options.environment,
+            projectId: scope.projectId
+        };
+        const provider = this.credentials.get(credentialScope);
+        let transport = this.transports.get(provider);
+        if (!transport) {
+            transport = new SupabaseStoreTransport({
+                credentialProvider: provider,
+                fetch: this.options.fetch,
+                createClient: this.options.createClient
+            });
+            this.transports.set(provider, transport);
+        }
+        return createStore({
+            ...scope,
+            transport,
+            generateUuid: this.options.generateUuid,
+            rpcNames: this.options.rpcNames
+        });
+    }
+    clear(scope) {
+        this.credentials.clear(scope ? {
+            environment: this.options.environment,
+            projectId: scope.projectId
+        } : void 0);
+    }
+    constructor(options){
+        this.transports = new WeakMap();
+        this.options = options;
+        this.credentials = new StoreCredentialProviderCache({
+            createProvider: (scope)=>new credential_provider_StoreCredentialProvider({
+                    fetchCredentials: ()=>options.fetchCredentials(scope),
+                    now: options.now
+                })
+        });
+    }
+}
+function createStoreFactory(options) {
+    return new StoreFactory(options);
+}
+export { fetchStoreCredentials, validateStoreRootUrl } from "../417.js";
+export { StoreFactory, createStoreFactory };

package/dist/esm/store/index.js

@@ -0,0 +1,2 @@
+export { StoreError } from "../417.js";
+export { store } from "../261.js";