@positronic/cloudflare 0.0.2 → 0.0.4

package/dist/src/brain-runner-do.js

@@ -0,0 +1,654 @@
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { DurableObject } from 'cloudflare:workers';
+import { BrainRunSQLiteAdapter } from './sqlite-adapter.js';
+import { CloudflareR2Loader } from './r2-loader.js';
+import { createResources } from '@positronic/core';
+var manifest = null;
+export function setManifest(generatedManifest) {
+    manifest = generatedManifest;
+}
+export function getManifest() {
+    return manifest;
+}
+var brainRunner = null;
+export function setBrainRunner(runner) {
+    brainRunner = runner;
+}
+var EventStreamAdapter = /*#__PURE__*/ function() {
+    "use strict";
+    function EventStreamAdapter() {
+        _class_call_check(this, EventStreamAdapter);
+        _define_property(this, "subscribers", new Set());
+        _define_property(this, "encoder", new TextEncoder());
+    }
+    _create_class(EventStreamAdapter, [
+        {
+            key: "subscribe",
+            value: function subscribe(controller) {
+                this.subscribers.add(controller);
+            }
+        },
+        {
+            key: "unsubscribe",
+            value: function unsubscribe(controller) {
+                this.subscribers.delete(controller);
+            }
+        },
+        {
+            key: "broadcast",
+            value: function broadcast(event) {
+                var _this = this;
+                var message = "data: ".concat(JSON.stringify(event), "\n\n");
+                var encodedMessage = this.encoder.encode(message);
+                this.subscribers.forEach(function(controller) {
+                    try {
+                        controller.enqueue(encodedMessage);
+                    } catch (e) {
+                        console.error('[DO_SSE_ADAPTER] Failed to send message to subscriber, removing.', e);
+                        _this.unsubscribe(controller);
+                    }
+                });
+            }
+        },
+        {
+            key: "dispatch",
+            value: function dispatch(event) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        try {
+                            this.broadcast(event);
+                        } catch (e) {
+                            console.error('[DO_SSE_ADAPTER] Error dispatching event:', e);
+                            throw e;
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return EventStreamAdapter;
+}();
+var MonitorAdapter = /*#__PURE__*/ function() {
+    "use strict";
+    function MonitorAdapter(monitorStub) {
+        _class_call_check(this, MonitorAdapter);
+        _define_property(this, "monitorStub", void 0);
+        this.monitorStub = monitorStub;
+    }
+    _create_class(MonitorAdapter, [
+        {
+            key: "dispatch",
+            value: function dispatch(event) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.monitorStub.handleBrainEvent(event)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return MonitorAdapter;
+}();
+var ScheduleAdapter = /*#__PURE__*/ function() {
+    "use strict";
+    function ScheduleAdapter(scheduleStub) {
+        _class_call_check(this, ScheduleAdapter);
+        _define_property(this, "scheduleStub", void 0);
+        this.scheduleStub = scheduleStub;
+    }
+    _create_class(ScheduleAdapter, [
+        {
+            key: "dispatch",
+            value: function dispatch(event) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.scheduleStub.handleBrainEvent(event)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return ScheduleAdapter;
+}();
+export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
+    "use strict";
+    _inherits(BrainRunnerDO, DurableObject);
+    function BrainRunnerDO(state, env) {
+        _class_call_check(this, BrainRunnerDO);
+        var _this;
+        _this = _call_super(this, BrainRunnerDO, [
+            state,
+            env
+        ]), _define_property(_this, "sql", void 0), _define_property(_this, "brainRunId", void 0), _define_property(_this, "eventStreamAdapter", new EventStreamAdapter());
+        _this.sql = state.storage.sql;
+        _this.brainRunId = state.id.toString();
+        _this.env = env;
+        return _this;
+    }
+    _create_class(BrainRunnerDO, [
+        {
+            key: "loadResourcesFromR2",
+            value: function loadResourcesFromR2() {
+                return _async_to_generator(function() {
+                    var bucket, listed, manifest, resourceCount, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, object, _r2Object_customMetadata, r2Object, keyParts, fileName, current, i, part, err, loader, resources;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                bucket = this.env.RESOURCES_BUCKET;
+                                return [
+                                    4,
+                                    bucket.list()
+                                ];
+                            case 1:
+                                listed = _state.sent();
+                                // Check if results are truncated
+                                if (listed.truncated) {
+                                    throw new Error("Too many resources in R2 bucket (more than 1000). " + "Resource pagination is not yet supported. " + "Please reduce the number of resources.");
+                                }
+                                if (listed.objects.length === 0) {
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                                // Build the manifest structure
+                                manifest = {};
+                                resourceCount = 0;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 2;
+                            case 2:
+                                _state.trys.push([
+                                    2,
+                                    7,
+                                    8,
+                                    9
+                                ]);
+                                _iterator = listed.objects[Symbol.iterator]();
+                                _state.label = 3;
+                            case 3:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    6
+                                ];
+                                object = _step.value;
+                                return [
+                                    4,
+                                    bucket.head(object.key)
+                                ];
+                            case 4:
+                                r2Object = _state.sent();
+                                if (!r2Object || !((_r2Object_customMetadata = r2Object.customMetadata) === null || _r2Object_customMetadata === void 0 ? void 0 : _r2Object_customMetadata.type)) {
+                                    console.warn("[DO ".concat(this.brainRunId, "] Skipping resource ").concat(object.key, " - ") + "missing metadata.type (found: ".concat(JSON.stringify((r2Object === null || r2Object === void 0 ? void 0 : r2Object.customMetadata) || {}), ")"));
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                }
+                                // Parse the key to create nested structure
+                                // e.g., "folder/file.txt" becomes manifest.folder["file.txt"]
+                                keyParts = object.key.split('/');
+                                // Get the file name (with extension preserved)
+                                fileName = keyParts[keyParts.length - 1];
+                                // Navigate/create nested structure
+                                current = manifest;
+                                for(i = 0; i < keyParts.length - 1; i++){
+                                    part = keyParts[i];
+                                    if (!current[part]) {
+                                        current[part] = {};
+                                    }
+                                    current = current[part];
+                                }
+                                // Add the resource entry with full filename
+                                current[fileName] = {
+                                    type: r2Object.customMetadata.type,
+                                    key: object.key,
+                                    path: r2Object.customMetadata.path || object.key
+                                };
+                                resourceCount++;
+                                _state.label = 5;
+                            case 5:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 6:
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 7:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    9
+                                ];
+                            case 8:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 9:
+                                if (resourceCount === 0) {
+                                    return [
+                                        2,
+                                        null
+                                    ];
+                                }
+                                // Create the loader and resources
+                                loader = new CloudflareR2Loader(bucket);
+                                resources = createResources(loader, manifest);
+                                return [
+                                    2,
+                                    resources
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "start",
+            value: function start(brainName, brainRunId, initialData) {
+                return _async_to_generator(function() {
+                    var sql, brainToRun, sqliteAdapter, eventStreamAdapter, monitorAdapter, scheduleAdapter, r2Resources, runnerWithResources;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                sql = this.sql;
+                                if (!manifest) {
+                                    throw new Error('Runtime manifest not initialized');
+                                }
+                                return [
+                                    4,
+                                    manifest.import(brainName)
+                                ];
+                            case 1:
+                                brainToRun = _state.sent();
+                                if (!brainToRun) {
+                                    console.error("[DO ".concat(brainRunId, "] Brain ").concat(brainName, " not found in manifest."));
+                                    console.error(JSON.stringify(manifest, null, 2));
+                                    throw new Error("Brain ".concat(brainName, " not found"));
+                                }
+                                sqliteAdapter = new BrainRunSQLiteAdapter(sql);
+                                eventStreamAdapter = this.eventStreamAdapter;
+                                monitorAdapter = new MonitorAdapter(this.env.MONITOR_DO.get(this.env.MONITOR_DO.idFromName('singleton')));
+                                scheduleAdapter = new ScheduleAdapter(this.env.SCHEDULE_DO.get(this.env.SCHEDULE_DO.idFromName('singleton')));
+                                if (!brainRunner) {
+                                    throw new Error('BrainRunner not initialized');
+                                }
+                                return [
+                                    4,
+                                    this.loadResourcesFromR2()
+                                ];
+                            case 2:
+                                r2Resources = _state.sent();
+                                // Create an enhanced runner with resources if available
+                                runnerWithResources = brainRunner;
+                                // Use R2 resources if available
+                                if (r2Resources) {
+                                    runnerWithResources = brainRunner.withResources(r2Resources);
+                                }
+                                runnerWithResources.withAdapters([
+                                    sqliteAdapter,
+                                    eventStreamAdapter,
+                                    monitorAdapter,
+                                    scheduleAdapter
+                                ]).run(brainToRun, {
+                                    initialState: initialData || {},
+                                    brainRunId: brainRunId
+                                }).catch(function(err) {
+                                    console.error("[DO ".concat(brainRunId, "] BrainRunner run failed:"), err);
+                                });
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "fetch",
+            value: function fetch(request) {
+                return _async_to_generator(function() {
+                    var _this, sql, eventStreamAdapter, brainRunId, url, encoder, sendEvent, streamController, stream;
+                    return _ts_generator(this, function(_state) {
+                        _this = this, sql = _this.sql, eventStreamAdapter = _this.eventStreamAdapter, brainRunId = _this.brainRunId;
+                        url = new URL(request.url);
+                        encoder = new TextEncoder();
+                        sendEvent = function(controller, data) {
+                            controller.enqueue(encoder.encode("data: ".concat(JSON.stringify(data), "\n\n")));
+                        };
+                        streamController = null;
+                        try {
+                            if (url.pathname === '/watch') {
+                                stream = new ReadableStream({
+                                    start: function start(controller) {
+                                        return _async_to_generator(function() {
+                                            var existingEventsSql, existingEventsResult, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, event;
+                                            return _ts_generator(this, function(_state) {
+                                                streamController = controller;
+                                                try {
+                                                    streamController = controller;
+                                                    existingEventsSql = "\n                SELECT serialized_event\n                FROM brain_events\n                ORDER BY event_id ASC;\n              ";
+                                                    existingEventsResult = sql.exec(existingEventsSql).toArray();
+                                                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                                    try {
+                                                        for(_iterator = existingEventsResult[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                                            row = _step.value;
+                                                            try {
+                                                                event = JSON.parse(row.serialized_event);
+                                                                sendEvent(controller, event);
+                                                            } catch (parseError) {
+                                                                console.error("[DO ".concat(brainRunId, " WATCH] Failed to parse historical event JSON: ").concat(row.serialized_event), parseError);
+                                                            }
+                                                        }
+                                                    } catch (err) {
+                                                        _didIteratorError = true;
+                                                        _iteratorError = err;
+                                                    } finally{
+                                                        try {
+                                                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                                _iterator.return();
+                                                            }
+                                                        } finally{
+                                                            if (_didIteratorError) {
+                                                                throw _iteratorError;
+                                                            }
+                                                        }
+                                                    }
+                                                    eventStreamAdapter.subscribe(controller);
+                                                } catch (err) {
+                                                    console.error("[DO ".concat(brainRunId, " WATCH] Error during stream start:"), err);
+                                                    controller.close();
+                                                    eventStreamAdapter.unsubscribe(streamController);
+                                                    throw err;
+                                                }
+                                                return [
+                                                    2
+                                                ];
+                                            });
+                                        })();
+                                    },
+                                    cancel: function cancel(reason) {
+                                        if (streamController) eventStreamAdapter.unsubscribe(streamController);
+                                    }
+                                });
+                                return [
+                                    2,
+                                    new Response(stream, {
+                                        headers: {
+                                            'Content-Type': 'text/event-stream',
+                                            'Cache-Control': 'no-cache',
+                                            Connection: 'keep-alive'
+                                        }
+                                    })
+                                ];
+                            }
+                            console.warn("[DO ".concat(brainRunId, "] fetch() called with unhandled path: ").concat(url.pathname));
+                            return [
+                                2,
+                                new Response('Not found', {
+                                    status: 404
+                                })
+                            ];
+                        } catch (error) {
+                            console.error("[DO ".concat(brainRunId, "] Error in fetch():"), error);
+                            return [
+                                2,
+                                new Response('Internal server error', {
+                                    status: 500
+                                })
+                            ];
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return BrainRunnerDO;
+}(DurableObject);