omnikey-cli 1.3.0 → 1.4.0

package/backend-dist/index.js

@@ -15,8 +15,8 @@ const logger_1 = require("./logger");
 const taskInstructionRoutes_1 = require("./taskInstructionRoutes");
 const scheduledJobRoutes_1 = require("./scheduledJobRoutes");
 const mcpServerRoutes_1 = require("./mcpServerRoutes");
-const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
-const sessionGrouping_1 = require("./agent/sessionGrouping");
+const spawn_1 = require("./workers/spawn");
+const scheduledJobWorkerClient_1 = require("./workers/scheduledJobWorkerClient");
 const config_1 = require("./config");
 const agentServer_1 = require("./agent/agentServer");
 // Importing AgentSession and ScheduledJob ensures the models are registered with Sequelize before initDatabase().
@@ -185,6 +185,7 @@ app.get('*', (_req, res) => {
     res.sendFile(path_1.default.join(process.cwd(), 'public', 'index.html'));
 });
 let server = null;
+const backgroundWorkers = [];
 async function start() {
     try {
         await (0, db_1.initDatabase)(logger_1.logger);
@@ -201,8 +202,15 @@ async function start() {
             (0, agentServer_1.attachAgentWebSocketServer)(server);
         }
         if (config_1.config.isSelfHosted) {
-            (0, scheduledJobExecutor_1.startScheduledJobExecutor)();
-            (0, sessionGrouping_1.startGroupingCronJob)();
+            // Run the schedulers in dedicated worker threads so their DB
+            // polling / cron ticks never block the HTTP event loop.
+            const scheduledJobWorker = (0, spawn_1.spawnWorker)('scheduledJobWorker');
+            backgroundWorkers.push(scheduledJobWorker);
+            backgroundWorkers.push((0, spawn_1.spawnWorker)('groupingWorker'));
+            // Expose the worker handle so HTTP routes (e.g. POST /:id/run-now)
+            // can dispatch immediate executions into the worker thread instead
+            // of running them in-process and blocking the event loop.
+            (0, scheduledJobWorkerClient_1.setScheduledJobWorker)(scheduledJobWorker);
         }
     }
     catch (err) {
@@ -211,21 +219,31 @@ async function start() {
     }
 }
 start();
+async function stopBackgroundWorkers() {
+    if (!backgroundWorkers.length)
+        return;
+    logger_1.logger.info('Stopping background workers...', { count: backgroundWorkers.length });
+    (0, scheduledJobWorkerClient_1.setScheduledJobWorker)(null);
+    await Promise.allSettled(backgroundWorkers.map((w) => w.stop()));
+}
 function gracefulShutdown(signal) {
     logger_1.logger.info(`Received ${signal}. Starting graceful shutdown...`);
+    const finish = (code) => {
+        void stopBackgroundWorkers().finally(() => process.exit(code));
+    };
     if (!server) {
         logger_1.logger.info('Server was not started or already closed. Exiting process.');
-        process.exit(0);
+        finish(0);
         return;
     }
     server.close((err) => {
         if (err) {
             logger_1.logger.error('Error during HTTP server shutdown.', { error: err });
-            process.exitCode = 1;
+            finish(1);
             return;
         }
         logger_1.logger.info('HTTP server closed. Exiting process.');
-        process.exit(0);
+        finish(0);
     });
 }
 process.on('SIGINT', () => gracefulShutdown('SIGINT'));

package/backend-dist/scheduledJobRoutes.js

@@ -9,6 +9,7 @@ const zod_1 = __importDefault(require("zod"));
 const authMiddleware_1 = require("./authMiddleware");
 const scheduledJob_1 = require("./models/scheduledJob");
 const scheduledJobExecutor_1 = require("./scheduledJobExecutor");
+const scheduledJobWorkerClient_1 = require("./workers/scheduledJobWorkerClient");
 const CRON_REGEX = /^(\S+\s){4}\S+$/;
 const jobSchema = zod_1.default.object({
     label: zod_1.default.string().min(1).max(200),
@@ -172,9 +173,19 @@ function scheduledJobRouter() {
             if (!job) {
                 return res.status(404).json({ error: 'Scheduled job not found.' });
             }
-            void (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
-                logger.error('run-now execution failed.', { jobId: job.id, error: err });
-            });
+            // Prefer the background worker (self-hosted) so the execution
+            // doesn't block this HTTP handler or any other request on the main
+            // event loop. Fall back to in-process execution when no worker is
+            // running (e.g. cloud deployments or during shutdown).
+            const dispatched = (0, scheduledJobWorkerClient_1.triggerJobInWorker)(job.id);
+            if (!dispatched) {
+                void (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
+                    logger.error('run-now execution failed.', { jobId: job.id, error: err });
+                });
+            }
+            else {
+                logger.info('run-now dispatched to scheduledJobWorker.', { jobId: job.id });
+            }
             res.json(formatJob(job));
         }
         catch (err) {

package/backend-dist/workers/groupingWorker.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const workerBootstrap_1 = require("./workerBootstrap");
+const sessionGrouping_1 = require("../agent/sessionGrouping");
+void (0, workerBootstrap_1.bootstrapWorker)('groupingWorker', () => {
+    (0, sessionGrouping_1.startGroupingCronJob)();
+});

package/backend-dist/workers/scheduledJobWorker.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const scheduledJob_1 = require("../models/scheduledJob");
+const scheduledJobExecutor_1 = require("../scheduledJobExecutor");
+const logger_1 = require("../logger");
+const workerBootstrap_1 = require("./workerBootstrap");
+void (0, workerBootstrap_1.bootstrapWorker)('scheduledJobWorker', () => {
+    (0, scheduledJobExecutor_1.startScheduledJobExecutor)();
+}, {
+    onMessage: async (msg) => {
+        if (msg.type !== 'runJob')
+            return;
+        const job = await scheduledJob_1.ScheduledJob.findByPk(msg.jobId);
+        if (!job) {
+            logger_1.logger.warn('runJob: scheduled job not found in worker.', { jobId: msg.jobId });
+            return;
+        }
+        logger_1.logger.info('runJob: executing scheduled job inside worker.', {
+            jobId: job.id,
+            label: job.label,
+        });
+        // executeJob already guards against concurrent runs of the same jobId
+        // (via RUNNING_JOB_IDS) and updates lastRunAt / nextRunAt itself, so we
+        // just fire-and-forget here and let errors surface through its own
+        // logger.error call.
+        await (0, scheduledJobExecutor_1.executeJob)(job).catch((err) => {
+            logger_1.logger.error('runJob: execution failed.', { jobId: job.id, error: err });
+        });
+    },
+});

package/backend-dist/workers/scheduledJobWorkerClient.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setScheduledJobWorker = setScheduledJobWorker;
+exports.triggerJobInWorker = triggerJobInWorker;
+let scheduledJobWorker = null;
+/**
+ * Register the scheduledJobWorker handle so HTTP routes can post messages to
+ * it. Called once from `index.ts` after the worker is spawned.
+ */
+function setScheduledJobWorker(worker) {
+    scheduledJobWorker = worker;
+}
+/**
+ * Ask the scheduledJobWorker to execute a job immediately. Returns true if
+ * the message was dispatched, false if no worker is currently running (e.g.
+ * non-self-hosted deployments where the executor still runs in-process). The
+ * caller is expected to fall back to an in-process `executeJob` when this
+ * returns false.
+ */
+function triggerJobInWorker(jobId) {
+    if (!scheduledJobWorker)
+        return false;
+    scheduledJobWorker.postMessage({ type: 'runJob', jobId });
+    return true;
+}

package/backend-dist/workers/spawn.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spawnWorker = spawnWorker;
+const path_1 = __importDefault(require("path"));
+const worker_threads_1 = require("worker_threads");
+const logger_1 = require("../logger");
+// Distance (ms) between auto-restart attempts after an unexpected exit.
+// Keeps a crashed worker from spinning a tight restart loop while still
+// recovering quickly from transient errors.
+const RESTART_DELAY_MS = 5000;
+/**
+ * Resolve the on-disk path to a worker entry file.
+ *
+ * - Production / `yarn start`: the project is compiled to `dist/` and the
+ *   running file's extension is `.js`. The compiled worker lives next to
+ *   this file at `dist/workers/<name>.js`.
+ * - Development / `yarn dev`: ts-node-dev runs the original `.ts` sources.
+ *   `__filename` ends with `.ts`, so we point the worker at the matching
+ *   `.ts` file and rely on `ts-node/register` (loaded via `execArgv`) to
+ *   transpile it on the fly inside the worker thread.
+ */
+function resolveWorkerEntry(workerName) {
+    const isTs = __filename.endsWith('.ts');
+    const ext = isTs ? '.ts' : '.js';
+    const entry = path_1.default.join(__dirname, `${workerName}${ext}`);
+    return { entry, isTs };
+}
+/**
+ * Spawn a worker thread and automatically restart it if it exits unexpectedly.
+ *
+ * The returned handle exposes a `postMessage()` method for typed RPC and a
+ * `stop()` method that disables auto-restart before terminating the worker.
+ */
+function spawnWorker(workerName) {
+    let stopped = false;
+    let restartTimer = null;
+    const handle = {
+        name: workerName,
+        // Replaced by start(); seeded with a placeholder so TS is happy.
+        worker: null,
+        postMessage: (msg) => {
+            const w = handle.worker;
+            if (!w) {
+                logger_1.logger.warn('Dropping message to worker that has not started yet.', {
+                    workerName,
+                    messageType: msg.type,
+                });
+                return;
+            }
+            try {
+                w.postMessage(msg);
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to post message to worker.', {
+                    workerName,
+                    messageType: msg.type,
+                    error: err,
+                });
+            }
+        },
+        stop: async () => {
+            stopped = true;
+            if (restartTimer) {
+                clearTimeout(restartTimer);
+                restartTimer = null;
+            }
+            const w = handle.worker;
+            if (!w)
+                return;
+            try {
+                await w.terminate();
+            }
+            catch (err) {
+                logger_1.logger.error('Failed to terminate worker.', { workerName, error: err });
+            }
+        },
+    };
+    const start = () => {
+        const { entry, isTs } = resolveWorkerEntry(workerName);
+        const execArgv = isTs ? ['-r', 'ts-node/register/transpile-only'] : [];
+        logger_1.logger.info('Spawning background worker.', { workerName, entry });
+        const worker = new worker_threads_1.Worker(entry, {
+            execArgv,
+            // Forward stdout/stderr through the parent so worker logs surface in the
+            // same console / log aggregator as the main process.
+            stdout: false,
+            stderr: false,
+        });
+        handle.worker = worker;
+        worker.on('error', (err) => {
+            logger_1.logger.error('Worker emitted error.', { workerName, error: err });
+        });
+        worker.on('exit', (code) => {
+            if (stopped) {
+                logger_1.logger.info('Worker exited after stop.', { workerName, code });
+                return;
+            }
+            logger_1.logger.error('Worker exited unexpectedly; scheduling restart.', {
+                workerName,
+                code,
+                restartDelayMs: RESTART_DELAY_MS,
+            });
+            restartTimer = setTimeout(() => {
+                restartTimer = null;
+                if (!stopped)
+                    start();
+            }, RESTART_DELAY_MS);
+        });
+    };
+    start();
+    return handle;
+}

package/backend-dist/workers/workerBootstrap.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootstrapWorker = bootstrapWorker;
+const worker_threads_1 = require("worker_threads");
+const db_1 = require("../db");
+const logger_1 = require("../logger");
+// Importing the models registers them with Sequelize before initDatabase()
+// runs inside the worker. Workers share the same model definitions as the
+// main process but each owns its own Sequelize connection.
+require("../models/agentSession");
+require("../models/scheduledJob");
+require("../models/mcpServer");
+/**
+ * Initialize a background worker thread.
+ *
+ * Each worker owns its own Sequelize connection (db.ts is evaluated fresh in
+ * the worker's V8 isolate), so DB calls performed here do not contend with
+ * the main process's connection pool or block the HTTP event loop.
+ *
+ * The `run` callback receives the initialized logger and should kick off any
+ * long-running schedulers. It must never throw — uncaught errors crash the
+ * worker, and the parent will auto-restart it after a short delay.
+ */
+async function bootstrapWorker(workerName, run, options = {}) {
+    try {
+        await (0, db_1.initDatabase)(logger_1.logger);
+        logger_1.logger.info('Worker database connection ready.', { workerName });
+        await run();
+        logger_1.logger.info('Worker entry returned; scheduler is now active.', { workerName });
+    }
+    catch (err) {
+        logger_1.logger.error('Worker bootstrap failed.', { workerName, error: err });
+        // Exit non-zero so the parent's `exit` handler treats this as a crash
+        // and schedules a restart instead of silently leaving the worker dead.
+        process.exit(1);
+    }
+    worker_threads_1.parentPort?.on('message', (raw) => {
+        // Defensive: messages can technically be any structured-clone-safe value.
+        const msg = raw;
+        if (!msg || typeof msg !== 'object' || typeof msg.type !== 'string') {
+            logger_1.logger.warn('Worker received malformed message; ignoring.', { workerName, raw });
+            return;
+        }
+        if (msg.type === 'shutdown') {
+            logger_1.logger.info('Worker received shutdown signal; exiting.', { workerName });
+            process.exit(0);
+        }
+        if (options.onMessage) {
+            void (async () => {
+                try {
+                    await options.onMessage(msg);
+                }
+                catch (err) {
+                    logger_1.logger.error('Worker message handler threw.', {
+                        workerName,
+                        messageType: msg.type,
+                        error: err,
+                    });
+                }
+            })();
+        }
+    });
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",