@positronic/cli 0.0.2

package/dist/src/test/test-dev-server.js

@@ -0,0 +1,1376 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+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 _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 _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+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 nock from 'nock';
+import { parse } from 'dotenv';
+import fs from 'fs';
+/**
+ * Mock implementation of TestServerHandle for testing
+ * Since we're using nock, there's no real process to manage
+ */ var MockServerHandle = /*#__PURE__*/ function() {
+    "use strict";
+    function MockServerHandle(stopFn, getLogsFn, clearLogsFn, port) {
+        _class_call_check(this, MockServerHandle);
+        _define_property(this, "stopFn", void 0);
+        _define_property(this, "getLogsFn", void 0);
+        _define_property(this, "clearLogsFn", void 0);
+        _define_property(this, "port", void 0);
+        _define_property(this, "_killed", void 0);
+        _define_property(this, "_errorCallback", void 0);
+        _define_property(this, "_closeCallback", void 0);
+        this.stopFn = stopFn;
+        this.getLogsFn = getLogsFn;
+        this.clearLogsFn = clearLogsFn;
+        this.port = port;
+        this._killed = false;
+    }
+    _create_class(MockServerHandle, [
+        {
+            key: "onClose",
+            value: function onClose(callback) {
+                this._closeCallback = callback;
+            }
+        },
+        {
+            key: "onError",
+            value: function onError(callback) {
+                this._errorCallback = callback;
+            }
+        },
+        {
+            key: "kill",
+            value: function kill(signal) {
+                if (!this._killed) {
+                    this.stopFn();
+                    this._killed = true;
+                    return true;
+                }
+                return false;
+            }
+        },
+        {
+            key: "killed",
+            get: function get() {
+                return this._killed;
+            }
+        },
+        {
+            key: "waitUntilReady",
+            value: function waitUntilReady(maxWaitMs) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        // Test server with nock is always ready immediately
+                        return [
+                            2,
+                            true
+                        ];
+                    });
+                })();
+            }
+        },
+        {
+            key: "getLogs",
+            value: function getLogs() {
+                return this.getLogsFn();
+            }
+        },
+        {
+            key: "clearLogs",
+            value: function clearLogs() {
+                this.clearLogsFn();
+            }
+        }
+    ]);
+    return MockServerHandle;
+}();
+export var TestDevServer = /*#__PURE__*/ function() {
+    "use strict";
+    function TestDevServer() {
+        var projectRootDir = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '';
+        _class_call_check(this, TestDevServer);
+        _define_property(this, "projectRootDir", void 0);
+        _define_property(this, "resources", void 0);
+        _define_property(this, "schedules", void 0);
+        _define_property(this, "scheduleRuns", void 0);
+        _define_property(this, "brains", void 0);
+        _define_property(this, "brainRuns", void 0);
+        _define_property(this, "secrets", void 0);
+        _define_property(this, "port", void 0);
+        _define_property(this, "callLog", void 0);
+        _define_property(this, "nockScope", void 0);
+        _define_property(this, "logCallbacks", void 0);
+        _define_property(this, "errorCallbacks", void 0);
+        _define_property(this, "warningCallbacks", void 0);
+        this.projectRootDir = projectRootDir;
+        this.resources = new Map();
+        this.schedules = new Map();
+        this.scheduleRuns = [];
+        this.brains = new Map();
+        this.brainRuns = [];
+        this.secrets = new Map();
+        this.port = 0;
+        this.callLog = [];
+        this.nockScope = null;
+        this.logCallbacks = [];
+        this.errorCallbacks = [];
+        this.warningCallbacks = [];
+    }
+    _create_class(TestDevServer, [
+        {
+            key: "logCall",
+            value: function logCall(method, args) {
+                var call = {
+                    method: method,
+                    args: args,
+                    timestamp: Date.now()
+                };
+                this.callLog.push(call);
+            }
+        },
+        {
+            key: "deploy",
+            value: function deploy(config) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('deploy', [
+                            this.projectRootDir,
+                            config
+                        ]);
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "setup",
+            value: function setup(force) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('setup', [
+                            force
+                        ]);
+                        return [
+                            2
+                        ];
+                    });
+                // For tests, we don't need to set up .positronic directory
+                // Just ensure we're ready to serve
+                }).call(this);
+            }
+        },
+        {
+            key: "getLogs",
+            value: function getLogs() {
+                return this.callLog;
+            }
+        },
+        {
+            key: "start",
+            value: function start(port) {
+                return _async_to_generator(function() {
+                    var _this, nockInstance;
+                    return _ts_generator(this, function(_state) {
+                        _this = this;
+                        this.logCall('start', [
+                            port
+                        ]);
+                        this.port = port || 9000 + Math.floor(Math.random() * 1000);
+                        process.env.POSITRONIC_PORT = this.port.toString();
+                        // Set up nock interceptors for all endpoints
+                        nockInstance = nock("http://localhost:".concat(this.port)).persist();
+                        // GET /resources
+                        nockInstance.get('/resources').reply(200, function() {
+                            // Return the current in-memory resource list (populated by uploads)
+                            var resources = Array.from(_this.resources.values());
+                            return {
+                                resources: resources,
+                                truncated: false,
+                                count: resources.length
+                            };
+                        });
+                        // POST /resources
+                        nockInstance.post('/resources').reply(201, function(uri, requestBody) {
+                            // Convert request body to string using latin1 encoding to preserve binary data
+                            var bodyString = Buffer.isBuffer(requestBody) ? requestBody.toString('latin1') : typeof requestBody === 'string' ? requestBody : JSON.stringify(requestBody);
+                            // Check if the body string appears to be hex-encoded (all characters are hex)
+                            var isHexEncoded = /^[0-9a-fA-F]+$/.test(bodyString);
+                            if (isHexEncoded) {
+                                // Convert hex string back to buffer and then to latin1 string
+                                var hexBuffer = Buffer.from(bodyString, 'hex');
+                                bodyString = hexBuffer.toString('latin1');
+                            }
+                            // Attempt to extract the "key" (resource path) and "type" fields from the multipart data
+                            var keyMatch = bodyString.match(/name="key"\s*\r?\n\r?\n([^\r\n]+)/);
+                            var typeMatch = bodyString.match(/name="type"\s*\r?\n\r?\n([^\r\n]+)/);
+                            var key = keyMatch ? keyMatch[1] : undefined;
+                            var type = typeMatch ? typeMatch[1] : 'text';
+                            if (key) {
+                                _this.resources.set(key, {
+                                    key: key,
+                                    type: type,
+                                    size: 0,
+                                    lastModified: new Date().toISOString()
+                                });
+                            }
+                            // Log the upload so tests can verify resource sync behavior
+                            _this.logCall('upload', [
+                                bodyString
+                            ]);
+                            // Success response
+                            return '';
+                        });
+                        // DELETE /resources (bulk delete all)
+                        nockInstance.delete('/resources').reply(204, function() {
+                            _this.resources.clear();
+                            _this.logCall('deleteAllResources', []);
+                            return '';
+                        });
+                        // DELETE /resources/:key
+                        nockInstance.delete(/^\/resources\/(.+)$/).reply(function(uri) {
+                            var match = uri.match(/^\/resources\/(.+)$/);
+                            if (match) {
+                                var key = decodeURIComponent(match[1]);
+                                if (_this.resources.has(key)) {
+                                    _this.resources.delete(key);
+                                    _this.logCall('deleteResource', [
+                                        key
+                                    ]);
+                                    return [
+                                        204,
+                                        ''
+                                    ];
+                                } else {
+                                    // Check if it was already deleted (idempotent delete)
+                                    var wasDeleted = _this.callLog.some(function(call) {
+                                        return call.method === 'deleteResource' && call.args[0] === key;
+                                    });
+                                    if (wasDeleted) {
+                                        // Return success for idempotent delete
+                                        return [
+                                            204,
+                                            ''
+                                        ];
+                                    }
+                                    return [
+                                        404,
+                                        JSON.stringify({
+                                            error: 'Resource "'.concat(key, '" not found')
+                                        })
+                                    ];
+                                }
+                            }
+                            return [
+                                404,
+                                'Not Found'
+                            ];
+                        });
+                        // POST /brains/runs
+                        nockInstance.post('/brains/runs').reply(function(uri, requestBody) {
+                            var body = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+                            // Check if brain exists (for testing brain not found scenario)
+                            if (body.brainName === 'non-existent-brain') {
+                                _this.logCall('createBrainRun', [
+                                    body.brainName
+                                ]);
+                                return [
+                                    404,
+                                    {
+                                        error: "Brain '".concat(body.brainName, "' not found")
+                                    }
+                                ];
+                            }
+                            var brainRunId = "run-".concat(Date.now());
+                            // Return specific runIds for specific test scenarios
+                            if (body.brainName === 'error-brain') {
+                                brainRunId = 'test-error-brain';
+                            } else if (body.brainName === 'restart-brain') {
+                                brainRunId = 'test-restart-brain';
+                            } else if (body.brainName === 'multi-status-brain') {
+                                brainRunId = 'test-multi-status';
+                            }
+                            _this.logCall('createBrainRun', [
+                                brainRunId
+                            ]);
+                            return [
+                                201,
+                                {
+                                    brainRunId: brainRunId
+                                }
+                            ];
+                        });
+                        // POST /brains/runs/rerun
+                        nockInstance.post('/brains/runs/rerun').reply(function(uri, requestBody) {
+                            var body = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+                            // Check if brain exists
+                            if (body.brainName === 'non-existent-brain') {
+                                _this.logCall('rerunBrain', [
+                                    body.brainName,
+                                    body.runId,
+                                    body.startsAt,
+                                    body.stopsAfter
+                                ]);
+                                return [
+                                    404,
+                                    {
+                                        error: "Brain '".concat(body.brainName, "' not found")
+                                    }
+                                ];
+                            }
+                            // Check if run ID exists (if provided)
+                            if (body.runId === 'non-existent-run') {
+                                _this.logCall('rerunBrain', [
+                                    body.brainName,
+                                    body.runId,
+                                    body.startsAt,
+                                    body.stopsAfter
+                                ]);
+                                return [
+                                    404,
+                                    {
+                                        error: "Brain run '".concat(body.runId, "' not found")
+                                    }
+                                ];
+                            }
+                            var newBrainRunId = "rerun-".concat(Date.now());
+                            _this.logCall('rerunBrain', [
+                                body.brainName,
+                                body.runId,
+                                body.startsAt,
+                                body.stopsAfter
+                            ]);
+                            return [
+                                201,
+                                {
+                                    brainRunId: newBrainRunId
+                                }
+                            ];
+                        });
+                        // GET /brains/runs/:runId/watch (SSE endpoint)
+                        nockInstance.get(/^\/brains\/runs\/(.+)\/watch$/).reply(200, function(uri) {
+                            var match = uri.match(/^\/brains\/runs\/(.+)\/watch$/);
+                            if (match) {
+                                var runId = match[1];
+                                // Different scenarios based on runId
+                                if (runId === 'test-error-brain') {
+                                    // Error scenario
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'Error Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:error',
+                                            brainRunId: runId,
+                                            brainTitle: 'Error Brain',
+                                            options: {},
+                                            status: 'error',
+                                            error: {
+                                                name: 'TestError',
+                                                message: 'Something went wrong in the brain',
+                                                stack: 'Error: Something went wrong\n    at test.js:1:1'
+                                            }
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-restart-brain') {
+                                    // Restart scenario
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:restart',
+                                            brainTitle: 'Restarted Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'step:status',
+                                            brainRunId: runId,
+                                            options: {},
+                                            steps: [
+                                                {
+                                                    id: 'restart-step-1',
+                                                    title: 'Restart Step',
+                                                    status: 'pending'
+                                                }
+                                            ]
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-multi-status') {
+                                    // Multiple step statuses
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'Multi Status Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'step:status',
+                                            brainRunId: runId,
+                                            options: {},
+                                            steps: [
+                                                {
+                                                    id: 'step-1',
+                                                    title: 'Complete Step',
+                                                    status: 'complete'
+                                                },
+                                                {
+                                                    id: 'step-2',
+                                                    title: 'Error Step',
+                                                    status: 'error'
+                                                },
+                                                {
+                                                    id: 'step-3',
+                                                    title: 'Running Step',
+                                                    status: 'running'
+                                                },
+                                                {
+                                                    id: 'step-4',
+                                                    title: 'Pending Step',
+                                                    status: 'pending'
+                                                }
+                                            ]
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-complete-flow') {
+                                    // Full flow from start to complete
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'Complete Flow Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'step:status',
+                                            brainRunId: runId,
+                                            options: {},
+                                            steps: [
+                                                {
+                                                    id: 'step-1',
+                                                    title: 'First Step',
+                                                    status: 'complete'
+                                                },
+                                                {
+                                                    id: 'step-2',
+                                                    title: 'Second Step',
+                                                    status: 'complete'
+                                                }
+                                            ]
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:complete',
+                                            brainRunId: runId,
+                                            brainTitle: 'Complete Flow Brain',
+                                            options: {},
+                                            status: 'complete'
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-brain-error') {
+                                    // Brain error scenario
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'Error Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:error',
+                                            brainRunId: runId,
+                                            brainTitle: 'Error Brain',
+                                            error: {
+                                                name: 'BrainExecutionError',
+                                                message: 'Something went wrong during brain execution',
+                                                stack: 'Error: Something went wrong during brain execution\n    at BrainRunner.run'
+                                            }
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-malformed-event') {
+                                    // Send malformed JSON
+                                    return 'data: {invalid json here}\n\n';
+                                } else if (runId === 'test-no-steps') {
+                                    // Brain with no steps initially
+                                    return [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'No Steps Brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'step:status',
+                                            brainRunId: runId,
+                                            options: {},
+                                            steps: []
+                                        }), "\n\n")
+                                    ].join('');
+                                } else if (runId === 'test-connection-error') {
+                                    // Simulate connection error by returning error
+                                    throw new Error('ECONNREFUSED');
+                                } else {
+                                    // Default scenario
+                                    var mockEvents = [
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:start',
+                                            brainTitle: 'test-brain',
+                                            brainRunId: runId,
+                                            options: {},
+                                            status: 'running',
+                                            initialState: {}
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'step:status',
+                                            brainRunId: runId,
+                                            options: {},
+                                            steps: [
+                                                {
+                                                    id: 'step-1',
+                                                    title: 'Test Step 1',
+                                                    status: 'running'
+                                                }
+                                            ]
+                                        }), "\n\n"),
+                                        "data: ".concat(JSON.stringify({
+                                            type: 'brain:complete',
+                                            brainRunId: runId,
+                                            brainTitle: 'test-brain',
+                                            options: {},
+                                            status: 'complete'
+                                        }), "\n\n")
+                                    ];
+                                    return mockEvents.join('');
+                                }
+                            }
+                            return 'data: {"type":"ERROR","error":{"message":"Invalid run ID"}}\n\n';
+                        }, {
+                            'Content-Type': 'text/event-stream',
+                            'Cache-Control': 'no-cache',
+                            Connection: 'keep-alive'
+                        });
+                        // GET /brains
+                        nockInstance.get('/brains').reply(200, function() {
+                            var brains = Array.from(_this.brains.values());
+                            _this.logCall('getBrains', []);
+                            return {
+                                brains: brains,
+                                count: brains.length
+                            };
+                        });
+                        // GET /brains/schedules
+                        nockInstance.get('/brains/schedules').reply(200, function() {
+                            var schedules = Array.from(_this.schedules.values());
+                            _this.logCall('getSchedules', []);
+                            return {
+                                schedules: schedules,
+                                count: schedules.length
+                            };
+                        });
+                        // POST /brains/schedules
+                        nockInstance.post('/brains/schedules').reply(201, function(uri, requestBody) {
+                            var body = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+                            var scheduleId = "schedule-".concat(Date.now());
+                            var schedule = {
+                                id: scheduleId,
+                                brainName: body.brainName,
+                                cronExpression: body.cronExpression,
+                                enabled: true,
+                                createdAt: Date.now(),
+                                nextRunAt: Date.now() + 3600000
+                            };
+                            _this.schedules.set(scheduleId, schedule);
+                            _this.logCall('createSchedule', [
+                                body
+                            ]);
+                            return schedule;
+                        });
+                        // GET /brains/schedules/runs
+                        nockInstance.get('/brains/schedules/runs').query(true).reply(function(uri) {
+                            var url = new URL(uri, 'http://example.com');
+                            var scheduleId = url.searchParams.get('scheduleId');
+                            var limit = parseInt(url.searchParams.get('limit') || '100', 10);
+                            _this.logCall('getScheduleRuns', [
+                                uri
+                            ]);
+                            var runs = _this.scheduleRuns;
+                            // Filter by scheduleId if provided
+                            if (scheduleId) {
+                                runs = runs.filter(function(run) {
+                                    return run.scheduleId === scheduleId;
+                                });
+                            }
+                            // Sort by ranAt descending (newest first)
+                            runs = runs.sort(function(a, b) {
+                                return b.ranAt - a.ranAt;
+                            });
+                            // Apply limit
+                            runs = runs.slice(0, limit);
+                            return [
+                                200,
+                                {
+                                    runs: runs,
+                                    count: runs.length
+                                }
+                            ];
+                        });
+                        // DELETE /brains/schedules/:id
+                        nockInstance.delete(/^\/brains\/schedules\/(.+)$/).reply(function(uri) {
+                            var match = uri.match(/^\/brains\/schedules\/(.+)$/);
+                            if (match) {
+                                var scheduleId = decodeURIComponent(match[1]);
+                                if (_this.schedules.has(scheduleId)) {
+                                    _this.schedules.delete(scheduleId);
+                                    _this.logCall('deleteSchedule', [
+                                        scheduleId
+                                    ]);
+                                    return [
+                                        204,
+                                        ''
+                                    ];
+                                } else {
+                                    return [
+                                        404,
+                                        JSON.stringify({
+                                            error: 'Schedule "'.concat(scheduleId, '" not found')
+                                        })
+                                    ];
+                                }
+                            }
+                            return [
+                                404,
+                                'Not Found'
+                            ];
+                        });
+                        // GET /brains/:brainName/history
+                        nockInstance.get(/^\/brains\/(.+)\/history$/).query(true).reply(function(uri) {
+                            var parts = uri.split('/');
+                            var brainName = decodeURIComponent(parts[2]);
+                            var url = new URL(uri, 'http://example.com');
+                            var limit = parseInt(url.searchParams.get('limit') || '10', 10);
+                            _this.logCall('getBrainHistory', [
+                                brainName,
+                                limit
+                            ]);
+                            // Filter runs by brain title
+                            var runs = _this.brainRuns.filter(function(run) {
+                                return run.brainTitle.toLowerCase() === brainName.toLowerCase().replace(/-/g, ' ');
+                            }).sort(function(a, b) {
+                                return b.createdAt - a.createdAt;
+                            }).slice(0, limit);
+                            return [
+                                200,
+                                {
+                                    runs: runs
+                                }
+                            ];
+                        });
+                        // GET /brains/:brainName/active-runs
+                        nockInstance.get(/^\/brains\/(.+)\/active-runs$/).reply(function(uri) {
+                            var parts = uri.split('/');
+                            var brainName = decodeURIComponent(parts[2]);
+                            _this.logCall('getBrainActiveRuns', [
+                                brainName
+                            ]);
+                            // Filter brain runs by brain title and status RUNNING
+                            var activeRuns = _this.brainRuns.filter(function(run) {
+                                return run.brainTitle.toLowerCase() === brainName.toLowerCase().replace(/-/g, ' ') && run.status === 'RUNNING';
+                            }).sort(function(a, b) {
+                                return b.createdAt - a.createdAt;
+                            });
+                            return [
+                                200,
+                                {
+                                    runs: activeRuns
+                                }
+                            ];
+                        });
+                        // GET /brains/:brainName
+                        nockInstance.get(/^\/brains\/(.+)$/).reply(function(uri) {
+                            var brainName = decodeURIComponent(uri.split('/')[2]);
+                            var brain = _this.brains.get(brainName);
+                            _this.logCall('getBrain', [
+                                brainName
+                            ]);
+                            if (!brain) {
+                                return [
+                                    404,
+                                    {
+                                        error: "Brain '".concat(brainName, "' not found")
+                                    }
+                                ];
+                            }
+                            return [
+                                200,
+                                {
+                                    name: brain.name,
+                                    title: brain.title,
+                                    description: brain.description || "".concat(brain.title, " brain"),
+                                    steps: brain.steps || []
+                                }
+                            ];
+                        });
+                        // Secret Management Endpoints
+                        // POST /secrets
+                        nockInstance.post('/secrets').reply(201, function(uri, requestBody) {
+                            var body = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+                            var now = new Date().toISOString();
+                            var secret = {
+                                name: body.name,
+                                value: body.value,
+                                createdAt: now,
+                                updatedAt: now
+                            };
+                            _this.secrets.set(body.name, secret);
+                            _this.logCall('createSecret', [
+                                body.name
+                            ]);
+                            // Return without the value for security
+                            return {
+                                name: secret.name,
+                                createdAt: secret.createdAt,
+                                updatedAt: secret.updatedAt
+                            };
+                        });
+                        // GET /secrets
+                        nockInstance.get('/secrets').reply(200, function() {
+                            _this.logCall('listSecrets', []);
+                            // Return secrets without values
+                            var secrets = Array.from(_this.secrets.values()).map(function(secret) {
+                                return {
+                                    name: secret.name,
+                                    createdAt: secret.createdAt,
+                                    updatedAt: secret.updatedAt
+                                };
+                            });
+                            return {
+                                secrets: secrets,
+                                count: secrets.length
+                            };
+                        });
+                        // DELETE /secrets/:name
+                        nockInstance.delete(/^\/secrets\/(.+)$/).reply(function(uri) {
+                            var match = uri.match(/^\/secrets\/(.+)$/);
+                            if (match) {
+                                var secretName = decodeURIComponent(match[1]);
+                                if (_this.secrets.has(secretName)) {
+                                    _this.secrets.delete(secretName);
+                                    _this.logCall('deleteSecret', [
+                                        secretName
+                                    ]);
+                                    return [
+                                        204,
+                                        ''
+                                    ];
+                                } else {
+                                    return [
+                                        404,
+                                        {
+                                            error: 'Secret "'.concat(secretName, '" not found')
+                                        }
+                                    ];
+                                }
+                            }
+                            return [
+                                404,
+                                'Not Found'
+                            ];
+                        });
+                        // GET /secrets/:name/exists
+                        nockInstance.get(/^\/secrets\/(.+)\/exists$/).reply(function(uri) {
+                            var match = uri.match(/^\/secrets\/(.+)\/exists$/);
+                            if (match) {
+                                var secretName = decodeURIComponent(match[1]);
+                                var exists = _this.secrets.has(secretName);
+                                _this.logCall('secretExists', [
+                                    secretName
+                                ]);
+                                return [
+                                    200,
+                                    {
+                                        exists: exists
+                                    }
+                                ];
+                            }
+                            return [
+                                404,
+                                'Not Found'
+                            ];
+                        });
+                        // POST /secrets/bulk
+                        nockInstance.post('/secrets/bulk').reply(201, function(uri, requestBody) {
+                            var body = typeof requestBody === 'string' ? JSON.parse(requestBody) : requestBody;
+                            var created = 0;
+                            var updated = 0;
+                            var now = new Date().toISOString();
+                            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(var _iterator = body.secrets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    var secretData = _step.value;
+                                    var existing = _this.secrets.has(secretData.name);
+                                    var secret = {
+                                        name: secretData.name,
+                                        value: secretData.value,
+                                        createdAt: existing ? _this.secrets.get(secretData.name).createdAt : now,
+                                        updatedAt: now
+                                    };
+                                    _this.secrets.set(secretData.name, secret);
+                                    if (existing) {
+                                        updated++;
+                                    } else {
+                                        created++;
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                            _this.logCall('bulkCreateSecrets', [
+                                body.secrets.length
+                            ]);
+                            return {
+                                created: created,
+                                updated: updated
+                            };
+                        });
+                        this.nockScope = nockInstance;
+                        // Simulate some initial log output after server starts
+                        setTimeout(function() {
+                            _this.logCallbacks.forEach(function(cb) {
+                                return cb('✅ Synced 3 resources (0 up to date, 0 deleted)\n');
+                            });
+                            _this.logCallbacks.forEach(function(cb) {
+                                return cb('🚀 Server started on port ' + _this.port + '\n');
+                            });
+                        }, 100);
+                        return [
+                            2,
+                            new MockServerHandle(function() {
+                                _this.stop();
+                            }, function() {
+                                return _this.callLog;
+                            }, function() {
+                                _this.callLog = [];
+                            }, this.port)
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "watch",
+            value: // Add watch method to track calls
+            function watch(event) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('watch', [
+                            this.projectRootDir,
+                            event
+                        ]);
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            // Helper methods for tests to manipulate the server state
+            key: "addResource",
+            value: function addResource(resource) {
+                this.resources.set(resource.key, resource);
+            }
+        },
+        {
+            key: "clearResources",
+            value: function clearResources() {
+                this.resources.clear();
+            }
+        },
+        {
+            key: "getResources",
+            value: function getResources() {
+                return Array.from(this.resources.values());
+            }
+        },
+        {
+            // Schedule helper methods
+            key: "addSchedule",
+            value: function addSchedule(schedule) {
+                this.schedules.set(schedule.id, schedule);
+            }
+        },
+        {
+            key: "clearSchedules",
+            value: function clearSchedules() {
+                this.schedules.clear();
+            }
+        },
+        {
+            key: "addScheduleRun",
+            value: function addScheduleRun(run) {
+                this.scheduleRuns.push(run);
+            }
+        },
+        {
+            key: "clearScheduleRuns",
+            value: function clearScheduleRuns() {
+                this.scheduleRuns = [];
+            }
+        },
+        {
+            key: "getSchedules",
+            value: function getSchedules() {
+                return Array.from(this.schedules.values());
+            }
+        },
+        {
+            // Secret helper methods
+            key: "addSecret",
+            value: function addSecret(name, value) {
+                var now = new Date().toISOString();
+                this.secrets.set(name, {
+                    name: name,
+                    value: value,
+                    createdAt: now,
+                    updatedAt: now
+                });
+            }
+        },
+        {
+            key: "clearSecrets",
+            value: function clearSecrets() {
+                this.secrets.clear();
+            }
+        },
+        {
+            key: "getSecrets",
+            value: function getSecrets() {
+                return Array.from(this.secrets.values());
+            }
+        },
+        {
+            key: "getSecret",
+            value: function getSecret(name) {
+                return this.secrets.get(name);
+            }
+        },
+        {
+            // Brain helper methods
+            key: "addBrain",
+            value: function addBrain(brain) {
+                this.brains.set(brain.name, brain);
+            }
+        },
+        {
+            key: "addBrainRun",
+            value: function addBrainRun(run) {
+                this.brainRuns.push(run);
+            }
+        },
+        {
+            key: "clearBrainRuns",
+            value: function clearBrainRuns() {
+                this.brainRuns = [];
+            }
+        },
+        {
+            key: "clearBrains",
+            value: function clearBrains() {
+                this.brains.clear();
+            }
+        },
+        {
+            key: "getBrains",
+            value: function getBrains() {
+                return Array.from(this.brains.values());
+            }
+        },
+        {
+            key: "stop",
+            value: function stop() {
+                if (this.nockScope) {
+                    // Clean up all nock interceptors
+                    nock.cleanAll();
+                    this.nockScope = null;
+                }
+            }
+        },
+        {
+            key: "onLog",
+            value: function onLog(callback) {
+                this.logCall('onLog', [
+                    'callback registered'
+                ]);
+                this.logCallbacks.push(callback);
+            }
+        },
+        {
+            key: "onError",
+            value: function onError(callback) {
+                this.logCall('onError', [
+                    'callback registered'
+                ]);
+                this.errorCallbacks.push(callback);
+            }
+        },
+        {
+            key: "onWarning",
+            value: function onWarning(callback) {
+                this.logCall('onWarning', [
+                    'callback registered'
+                ]);
+                this.warningCallbacks.push(callback);
+            }
+        },
+        {
+            key: "listSecrets",
+            value: function listSecrets() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('listSecrets', []);
+                        return [
+                            2,
+                            Array.from(this.secrets.values()).map(function(secret) {
+                                return {
+                                    name: secret.name,
+                                    createdAt: new Date(secret.createdAt),
+                                    updatedAt: new Date(secret.updatedAt)
+                                };
+                            })
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "setSecret",
+            value: function setSecret(name, value) {
+                return _async_to_generator(function() {
+                    var now, existing;
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('setSecret', [
+                            name,
+                            value
+                        ]);
+                        now = new Date().toISOString();
+                        existing = this.secrets.get(name);
+                        this.secrets.set(name, {
+                            name: name,
+                            value: value,
+                            createdAt: (existing === null || existing === void 0 ? void 0 : existing.createdAt) || now,
+                            updatedAt: now
+                        });
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "deleteSecret",
+            value: function deleteSecret(name) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('deleteSecret', [
+                            name
+                        ]);
+                        if (this.secrets.has(name)) {
+                            this.secrets.delete(name);
+                            return [
+                                2,
+                                true
+                            ];
+                        }
+                        return [
+                            2,
+                            false
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "bulkSecrets",
+            value: function bulkSecrets(filePath) {
+                return _async_to_generator(function() {
+                    var envContent, secrets, secretsArray, now, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _step_value, name, value, existing;
+                    return _ts_generator(this, function(_state) {
+                        this.logCall('bulkSecrets', [
+                            filePath
+                        ]);
+                        try {
+                            // Read and parse the .env file
+                            if (!fs.existsSync(filePath)) {
+                                throw new Error("File not found: ".concat(filePath));
+                            }
+                            envContent = fs.readFileSync(filePath, 'utf8');
+                            secrets = parse(envContent);
+                            secretsArray = Object.entries(secrets);
+                            if (secretsArray.length === 0) {
+                                throw new Error('No secrets found in the .env file');
+                            }
+                            // Simulate the bulk upload - just store them
+                            now = new Date().toISOString();
+                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(_iterator = secretsArray[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    _step_value = _sliced_to_array(_step.value, 2), name = _step_value[0], value = _step_value[1];
+                                    existing = this.secrets.has(name);
+                                    this.secrets.set(name, {
+                                        name: name,
+                                        value: value,
+                                        createdAt: existing ? this.secrets.get(name).createdAt : now,
+                                        updatedAt: now
+                                    });
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                            // Simulate console output
+                            this.logCallbacks.forEach(function(cb) {
+                                return cb("✨ Successfully uploaded ".concat(secretsArray.length, " secrets\n"));
+                            });
+                        } catch (error) {
+                            throw error;
+                        }
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return TestDevServer;
+}();