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

package/dist/cjs/store/claude.js

@@ -0,0 +1,209 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "528"
+    ];
+    exports.modules = {
+        "../store/src/claude.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                createSessionStore: ()=>createSessionStore
+            });
+            var runtime_data_plane = __webpack_require__("../store/src/runtime-data-plane.ts");
+            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 = runtime_data_plane.G){
+                    this.execute = execute;
+                }
+            }
+            const claudeSessionRepository = new ClaudeSessionRepository();
+            var errors = __webpack_require__("../store/src/errors.ts");
+            var json = __webpack_require__("../store/src/json.ts");
+            function invalid(message) {
+                throw new errors.A("BadRequest", message);
+            }
+            function internal() {
+                throw new errors.A("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 = (0, json.P)(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 = (0, json.P)(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();
+            }
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        }
+    };
+    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, [
+        "504",
+        "808",
+        "82",
+        "951"
+    ], function() {
+        return __webpack_exec__("../store/src/claude.ts");
+    });
+    exports.createSessionStore = __webpack_exports__.createSessionStore;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "createSessionStore"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();

package/dist/cjs/store/host.js

@@ -0,0 +1,92 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "636"
+    ];
+    exports.modules = {
+        "../store/src/host.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                fetchStoreCredentials: ()=>token_client.o,
+                createStoreFactory: ()=>createStoreFactory,
+                validateStoreRootUrl: ()=>token_client.f,
+                StoreFactory: ()=>StoreFactory
+            });
+            var credential_provider = __webpack_require__("../store/src/credential-provider.ts");
+            var store = __webpack_require__("../store/src/store.ts");
+            var supabase_transport = __webpack_require__("../store/src/supabase-transport.ts");
+            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 supabase_transport.H({
+                            credentialProvider: provider,
+                            fetch: this.options.fetch,
+                            createClient: this.options.createClient
+                        });
+                        this.transports.set(provider, transport);
+                    }
+                    return (0, store.y$)({
+                        ...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 credential_provider.Up({
+                        createProvider: (scope)=>new credential_provider.q1({
+                                fetchCredentials: ()=>options.fetchCredentials(scope),
+                                now: options.now
+                            })
+                    });
+                }
+            }
+            function createStoreFactory(options) {
+                return new StoreFactory(options);
+            }
+            var token_client = __webpack_require__("../store/src/token-client.ts");
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        }
+    };
+    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, [
+        "504",
+        "808",
+        "82"
+    ], function() {
+        return __webpack_exec__("../store/src/host.ts");
+    });
+    exports.StoreFactory = __webpack_exports__.StoreFactory;
+    exports.createStoreFactory = __webpack_exports__.createStoreFactory;
+    exports.fetchStoreCredentials = __webpack_exports__.fetchStoreCredentials;
+    exports.validateStoreRootUrl = __webpack_exports__.validateStoreRootUrl;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "StoreFactory",
+        "createStoreFactory",
+        "fetchStoreCredentials",
+        "validateStoreRootUrl"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();

package/dist/cjs/store/index.js

@@ -0,0 +1,43 @@
+"use strict";
+(function() {
+    exports.ids = [
+        "320"
+    ];
+    exports.modules = {
+        "../store/src/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                StoreError: ()=>_errors_js__rspack_import_1.A,
+                store: ()=>_runtime_store_js__rspack_import_0.M
+            });
+            var _runtime_store_js__rspack_import_0 = __webpack_require__("../store/src/runtime-store.ts");
+            var _errors_js__rspack_import_1 = __webpack_require__("../store/src/errors.ts");
+        },
+        "node:crypto" (module) {
+            module.exports = require("node:crypto");
+        }
+    };
+    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, [
+        "261",
+        "504",
+        "808",
+        "82",
+        "951"
+    ], function() {
+        return __webpack_exec__("../store/src/index.ts");
+    });
+    exports.StoreError = __webpack_exports__.StoreError;
+    exports.store = __webpack_exports__.store;
+    for(var __rspack_i in __webpack_exports__)if (-1 === [
+        "StoreError",
+        "store"
+    ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+    Object.defineProperty(exports, '__esModule', {
+        value: true
+    });
+})();