@hotmeshio/long-tail 0.2.3 → 0.2.5

package/build/lib/db/migrate.js

@@ -43,27 +43,39 @@ const logger_1 = require("../logger");
 const SCHEMAS_DIR = path.join(__dirname, 'schemas');
 async function migrate() {
     const pool = (0, index_1.getPool)();
-    // ensure migration tracking table
-    await pool.query(`
-    CREATE TABLE IF NOT EXISTS lt_migrations (
-      id SERIAL PRIMARY KEY,
-      name TEXT NOT NULL UNIQUE,
-      applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
-    );
-  `);
-    // find and sort migration files
-    const files = fs.readdirSync(SCHEMAS_DIR)
-        .filter(f => f.endsWith('.sql'))
-        .sort();
-    for (const file of files) {
-        const { rows } = await pool.query('SELECT 1 FROM lt_migrations WHERE name = $1', [file]);
-        if (rows.length === 0) {
-            const sql = fs.readFileSync(path.join(SCHEMAS_DIR, file), 'utf-8');
-            await pool.query(sql);
-            await pool.query('INSERT INTO lt_migrations (name) VALUES ($1)', [file]);
-            logger_1.loggerRegistry.info(`[migrate] applied: ${file}`);
+    // Advisory lock prevents concurrent containers from racing on migrations.
+    // Uses a dedicated client so the lock is held for the entire sequence.
+    const client = await pool.connect();
+    try {
+        await client.query('SELECT pg_advisory_lock(8675309)');
+        // ensure migration tracking table
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS lt_migrations (
+        id SERIAL PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `);
+        // find and sort migration files
+        const files = fs.readdirSync(SCHEMAS_DIR)
+            .filter(f => f.endsWith('.sql'))
+            .sort();
+        for (const file of files) {
+            const { rows } = await client.query('SELECT 1 FROM lt_migrations WHERE name = $1', [file]);
+            if (rows.length === 0) {
+                const sql = fs.readFileSync(path.join(SCHEMAS_DIR, file), 'utf-8');
+                await client.query(sql);
+                await client.query('INSERT INTO lt_migrations (name) VALUES ($1)', [file]);
+                logger_1.loggerRegistry.info(`[migrate] applied: ${file}`);
+            }
         }
     }
+    finally {
+        // Advisory lock released when client is released (session-scoped),
+        // but release explicitly for clarity
+        await client.query('SELECT pg_advisory_unlock(8675309)').catch(() => { });
+        client.release();
+    }
 }
 // run directly: npx ts-node lib/db/migrate.ts
 if (require.main === module) {

package/build/services/cron/index.d.ts

@@ -69,7 +69,13 @@ declare class LTCronRegistry {
      */
     connectAgentCrons(): Promise<void>;
     /**
-     * Stop all active crons. Call during graceful shutdown.
+     * Disconnect on graceful shutdown. Clears the local registry so this
+     * container stops consuming cron streams. Does NOT call Virtual.interrupt()
+     * — cron jobs are durable rows shared across the fleet. Another container
+     * (or this one on restart) will continue servicing them.
+     *
+     * Use stopCron/stopAgentCrons/stopYamlCron for intentional permanent kills
+     * (e.g. user deletes an agent or changes a schedule via the dashboard).
      */
     disconnect(): Promise<void>;
     /**

package/build/services/cron/index.js

@@ -444,21 +444,16 @@ class LTCronRegistry {
         logger_1.loggerRegistry.info(`[lt-cron] ${armed} agent schedule(s) armed`);
     }
     /**
-     * Stop all active crons. Call during graceful shutdown.
+     * Disconnect on graceful shutdown. Clears the local registry so this
+     * container stops consuming cron streams. Does NOT call Virtual.interrupt()
+     * — cron jobs are durable rows shared across the fleet. Another container
+     * (or this one on restart) will continue servicing them.
+     *
+     * Use stopCron/stopAgentCrons/stopYamlCron for intentional permanent kills
+     * (e.g. user deletes an agent or changes a schedule via the dashboard).
      */
     async disconnect() {
-        for (const key of [...this.activeCrons.keys()]) {
-            if (key.startsWith('agent:')) {
-                const agentId = key.split(':')[1].split('-')[0];
-                await this.stopAgentCrons(agentId);
-            }
-            else if (key.startsWith('yaml:')) {
-                await this.stopYamlCron(key.replace('yaml:', ''));
-            }
-            else {
-                await this.stopCron(key);
-            }
-        }
+        this.activeCrons.clear();
         this.connected = false;
     }
     /**

package/build/services/iam/bots.js

@@ -132,13 +132,24 @@ async function ensureSystemBot() {
     const { rows } = await pool.query(sql_1.GET_USER_BY_EXTERNAL_ID, [SYSTEM_BOT_NAME]);
     if (rows.length > 0)
         return rows[0].id;
-    const bot = await createBot({
-        name: SYSTEM_BOT_NAME,
-        display_name: 'System',
-        description: 'System bot for cron and system-initiated workflows',
-        roles: [{ role: 'system', type: 'superadmin' }],
-    });
-    return bot.id;
+    try {
+        const bot = await createBot({
+            name: SYSTEM_BOT_NAME,
+            display_name: 'System',
+            description: 'System bot for cron and system-initiated workflows',
+            roles: [{ role: 'system', type: 'superadmin' }],
+        });
+        return bot.id;
+    }
+    catch (err) {
+        // Concurrent container already created it — re-read
+        if (err.code === '23505') {
+            const { rows: retry } = await pool.query(sql_1.GET_USER_BY_EXTERNAL_ID, [SYSTEM_BOT_NAME]);
+            if (retry.length > 0)
+                return retry[0].id;
+        }
+        throw err;
+    }
 }
 // ── Helpers ────────────────────────────────────────────────────────────────
 function toBotRecord(user, description, createdBy) {

package/build/services/maintenance/index.d.ts

@@ -22,7 +22,9 @@ declare class LTMaintenanceRegistry {
      */
     connect(): Promise<void>;
     /**
-     * Interrupt the running cron. Call during graceful shutdown.
+     * Disconnect on graceful shutdown. Stops consuming but leaves the cron
+     * row alive — it's a durable job shared across the fleet. Another
+     * container (or this one on restart) will continue servicing it.
      */
     disconnect(): Promise<void>;
     /**

package/build/services/maintenance/index.js

@@ -140,22 +140,11 @@ class LTMaintenanceRegistry {
         logger_1.loggerRegistry.info(`[lt-maintenance] cron started (schedule: ${schedule})`);
     }
     /**
-     * Interrupt the running cron. Call during graceful shutdown.
+     * Disconnect on graceful shutdown. Stops consuming but leaves the cron
+     * row alive — it's a durable job shared across the fleet. Another
+     * container (or this one on restart) will continue servicing it.
      */
     async disconnect() {
-        if (!this.connected)
-            return;
-        try {
-            const connection = (0, db_1.getConnection)();
-            await hotmesh_1.Virtual.interrupt({
-                topic: CRON_TOPIC,
-                connection,
-                options: { id: CRON_ID },
-            });
-        }
-        catch (err) {
-            logger_1.loggerRegistry.warn(`[lt-maintenance] interrupt failed (may not be running): ${err?.message}`);
-        }
         this.connected = false;
     }
     /**

package/build/start/workers.js

@@ -103,6 +103,10 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
     logger_1.loggerRegistry.info('[long-tail] running migrations...');
     await (0, migrate_1.migrate)();
     const connection = buildConnection();
+    // Readonly mode: all user-provided workers are observers — skip crons, triggers, and agent seeding.
+    // System workers (mcpQuery, etc.) are always added by collectWorkers, so check the original config.
+    const userWorkers = startConfig.workers ?? [];
+    const isReadonly = userWorkers.length > 0 && userWorkers.every((w) => w.connection?.readonly);
     if (workers.length) {
         // Connect telemetry before HotMesh starts
         if (telemetry_1.telemetryRegistry.hasAdapter) {
@@ -165,13 +169,15 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
             }
             ltConfig.invalidate();
         }
-        // Start maintenance cron
-        if (maintenance_1.maintenanceRegistry.hasConfig) {
+        // Start maintenance cron (skip in readonly/API mode)
+        if (maintenance_1.maintenanceRegistry.hasConfig && !isReadonly) {
             await maintenance_1.maintenanceRegistry.connect();
             logger_1.loggerRegistry.info('[long-tail] maintenance cron started');
         }
-        // Start workflow cron schedules
-        await cron_1.cronRegistry.connect();
+        // Start workflow cron schedules (skip in readonly/API mode)
+        if (!isReadonly) {
+            await cron_1.cronRegistry.connect();
+        }
         // Connect MCP adapter
         if (mcp_1.mcpRegistry.hasAdapter) {
             await mcp_1.mcpRegistry.connect();
@@ -281,19 +287,20 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
         await events_1.eventRegistry.connect();
         logger_1.loggerRegistry.info('[long-tail] event adapters connected');
     }
-    // Arm agent event subscriptions (after event adapters are connected)
-    try {
-        await agentTriggerRegistry.connect(callbackAdapter);
-    }
-    catch (err) {
-        logger_1.loggerRegistry.warn(`[long-tail] agent trigger registry: ${err.message}`);
-    }
-    // Arm agent cron schedules
-    try {
-        await cron_1.cronRegistry.connectAgentCrons();
-    }
-    catch (err) {
-        logger_1.loggerRegistry.warn(`[long-tail] agent cron schedules: ${err.message}`);
+    // Arm agent event subscriptions and crons (skip in readonly/API mode)
+    if (!isReadonly) {
+        try {
+            await agentTriggerRegistry.connect(callbackAdapter);
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[long-tail] agent trigger registry: ${err.message}`);
+        }
+        try {
+            await cron_1.cronRegistry.connectAgentCrons();
+        }
+        catch (err) {
+            logger_1.loggerRegistry.warn(`[long-tail] agent cron schedules: ${err.message}`);
+        }
     }
     // Ensure system bot account exists for cron/system-initiated workflows
     const { ensureSystemBot } = await Promise.resolve().then(() => __importStar(require('../services/iam/bots')));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/long-tail",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Long Tail Workflows — Durable AI workflows with human-in-the-loop escalation. Powered by PostgreSQL.",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",