morpheus-cli 0.5.6 → 0.6.1

package/dist/runtime/chronos/repository.js

@@ -0,0 +1,244 @@
+import Database from 'better-sqlite3';
+import fs from 'fs-extra';
+import path from 'path';
+import { homedir } from 'os';
+import { randomUUID } from 'crypto';
+import { ConfigManager } from '../../config/manager.js';
+export class ChronosError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ChronosError';
+    }
+}
+export class ChronosRepository {
+    static instance = null;
+    db;
+    constructor() {
+        const dbPath = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+        fs.ensureDirSync(path.dirname(dbPath));
+        this.db = new Database(dbPath, { timeout: 5000 });
+        this.db.pragma('journal_mode = WAL');
+        this.db.pragma('foreign_keys = ON');
+        this.ensureTable();
+    }
+    static getInstance() {
+        if (!ChronosRepository.instance) {
+            ChronosRepository.instance = new ChronosRepository();
+        }
+        return ChronosRepository.instance;
+    }
+    ensureTable() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chronos_jobs (
+        id TEXT PRIMARY KEY
+      );
+    `);
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS chronos_executions (
+        id TEXT PRIMARY KEY
+      );
+    `);
+        this.migrateTable();
+        this.ensureIndexes();
+    }
+    migrateTable() {
+        const jobInfo = this.db.pragma('table_info(chronos_jobs)');
+        const jobCols = new Set(jobInfo.map((c) => c.name));
+        const addJobCol = (sql, col) => {
+            if (jobCols.has(col))
+                return;
+            this.db.exec(sql);
+            jobCols.add(col);
+        };
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN prompt TEXT NOT NULL DEFAULT ''`, 'prompt');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN schedule_type TEXT NOT NULL DEFAULT 'once'`, 'schedule_type');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN schedule_expression TEXT NOT NULL DEFAULT ''`, 'schedule_expression');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN cron_normalized TEXT`, 'cron_normalized');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN timezone TEXT NOT NULL DEFAULT 'UTC'`, 'timezone');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN next_run_at INTEGER`, 'next_run_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN last_run_at INTEGER`, 'last_run_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN enabled INTEGER NOT NULL DEFAULT 1`, 'enabled');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0`, 'created_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN updated_at INTEGER NOT NULL DEFAULT 0`, 'updated_at');
+        addJobCol(`ALTER TABLE chronos_jobs ADD COLUMN created_by TEXT NOT NULL DEFAULT 'api'`, 'created_by');
+        const execInfo = this.db.pragma('table_info(chronos_executions)');
+        const execCols = new Set(execInfo.map((c) => c.name));
+        const addExecCol = (sql, col) => {
+            if (execCols.has(col))
+                return;
+            this.db.exec(sql);
+            execCols.add(col);
+        };
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN job_id TEXT NOT NULL DEFAULT ''`, 'job_id');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN triggered_at INTEGER NOT NULL DEFAULT 0`, 'triggered_at');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN completed_at INTEGER`, 'completed_at');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN status TEXT NOT NULL DEFAULT 'running'`, 'status');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN error TEXT`, 'error');
+        addExecCol(`ALTER TABLE chronos_executions ADD COLUMN session_id TEXT NOT NULL DEFAULT ''`, 'session_id');
+    }
+    ensureIndexes() {
+        this.db.exec(`
+      CREATE INDEX IF NOT EXISTS idx_chronos_jobs_next_run
+        ON chronos_jobs (enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_chronos_jobs_created_by
+        ON chronos_jobs (created_by);
+      CREATE INDEX IF NOT EXISTS idx_chronos_executions_job
+        ON chronos_executions (job_id, triggered_at DESC);
+    `);
+    }
+    deserializeJob(row) {
+        return {
+            id: row.id,
+            prompt: row.prompt,
+            schedule_type: row.schedule_type,
+            schedule_expression: row.schedule_expression,
+            cron_normalized: row.cron_normalized ?? null,
+            timezone: row.timezone,
+            next_run_at: row.next_run_at ?? null,
+            last_run_at: row.last_run_at ?? null,
+            enabled: row.enabled === 1,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            created_by: row.created_by,
+        };
+    }
+    deserializeExecution(row) {
+        return {
+            id: row.id,
+            job_id: row.job_id,
+            triggered_at: row.triggered_at,
+            completed_at: row.completed_at ?? null,
+            status: row.status,
+            error: row.error ?? null,
+            session_id: row.session_id,
+        };
+    }
+    // ─── T036: max_active_jobs enforcement ────────────────────────────────────
+    createJob(input) {
+        const cfg = ConfigManager.getInstance().getChronosConfig();
+        const activeCount = this.db.prepare(`SELECT COUNT(*) as cnt FROM chronos_jobs WHERE enabled = 1`).get().cnt;
+        if (activeCount >= cfg.max_active_jobs) {
+            throw new ChronosError(`Maximum active jobs limit (${cfg.max_active_jobs}) reached. Disable or delete an existing job first.`);
+        }
+        const now = Date.now();
+        const id = randomUUID();
+        this.db.prepare(`
+      INSERT INTO chronos_jobs (
+        id, prompt, schedule_type, schedule_expression, cron_normalized,
+        timezone, next_run_at, last_run_at, enabled, created_at, updated_at, created_by
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, 1, ?, ?, ?)
+    `).run(id, input.prompt, input.schedule_type, input.schedule_expression, input.cron_normalized ?? null, input.timezone, input.next_run_at, now, now, input.created_by);
+        return this.getJob(id);
+    }
+    getJob(id) {
+        const row = this.db.prepare('SELECT * FROM chronos_jobs WHERE id = ?').get(id);
+        return row ? this.deserializeJob(row) : null;
+    }
+    listJobs(filters) {
+        const params = [];
+        let query = 'SELECT * FROM chronos_jobs WHERE 1=1';
+        if (filters?.enabled !== undefined) {
+            query += ' AND enabled = ?';
+            params.push(filters.enabled ? 1 : 0);
+        }
+        if (filters?.created_by) {
+            query += ' AND created_by = ?';
+            params.push(filters.created_by);
+        }
+        query += ' ORDER BY created_at DESC';
+        const rows = this.db.prepare(query).all(...params);
+        return rows.map((r) => this.deserializeJob(r));
+    }
+    updateJob(id, patch) {
+        const now = Date.now();
+        const sets = ['updated_at = ?'];
+        const params = [now];
+        if (patch.prompt !== undefined) {
+            sets.push('prompt = ?');
+            params.push(patch.prompt);
+        }
+        if (patch.schedule_expression !== undefined) {
+            sets.push('schedule_expression = ?');
+            params.push(patch.schedule_expression);
+        }
+        if ('cron_normalized' in patch) {
+            sets.push('cron_normalized = ?');
+            params.push(patch.cron_normalized ?? null);
+        }
+        if (patch.timezone !== undefined) {
+            sets.push('timezone = ?');
+            params.push(patch.timezone);
+        }
+        if ('next_run_at' in patch) {
+            sets.push('next_run_at = ?');
+            params.push(patch.next_run_at ?? null);
+        }
+        if ('last_run_at' in patch) {
+            sets.push('last_run_at = ?');
+            params.push(patch.last_run_at ?? null);
+        }
+        if (patch.enabled !== undefined) {
+            sets.push('enabled = ?');
+            params.push(patch.enabled ? 1 : 0);
+        }
+        params.push(id);
+        this.db.prepare(`UPDATE chronos_jobs SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+        return this.getJob(id);
+    }
+    deleteJob(id) {
+        const result = this.db.prepare('DELETE FROM chronos_jobs WHERE id = ?').run(id);
+        return result.changes > 0;
+    }
+    getDueJobs(nowMs) {
+        const rows = this.db.prepare(`
+      SELECT * FROM chronos_jobs
+      WHERE enabled = 1 AND next_run_at IS NOT NULL AND next_run_at <= ?
+      ORDER BY next_run_at ASC
+    `).all(nowMs);
+        return rows.map((r) => this.deserializeJob(r));
+    }
+    enableJob(id) {
+        const now = Date.now();
+        this.db.prepare(`UPDATE chronos_jobs SET enabled = 1, updated_at = ? WHERE id = ?`).run(now, id);
+        return this.getJob(id);
+    }
+    disableJob(id) {
+        const now = Date.now();
+        this.db.prepare(`UPDATE chronos_jobs SET enabled = 0, next_run_at = NULL, updated_at = ? WHERE id = ?`).run(now, id);
+        return this.getJob(id);
+    }
+    // ─── Executions ───────────────────────────────────────────────────────────
+    insertExecution(record) {
+        this.db.prepare(`
+      INSERT INTO chronos_executions (id, job_id, triggered_at, completed_at, status, error, session_id)
+      VALUES (?, ?, ?, NULL, ?, NULL, ?)
+    `).run(record.id, record.job_id, record.triggered_at, record.status, record.session_id);
+    }
+    completeExecution(id, status, error) {
+        const now = Date.now();
+        this.db.prepare(`
+      UPDATE chronos_executions SET status = ?, completed_at = ?, error = ? WHERE id = ?
+    `).run(status, now, error ?? null, id);
+    }
+    listExecutions(jobId, limit = 50) {
+        const rows = this.db.prepare(`
+      SELECT * FROM chronos_executions WHERE job_id = ?
+      ORDER BY triggered_at DESC LIMIT ?
+    `).all(jobId, Math.min(limit, 100));
+        return rows.map((r) => this.deserializeExecution(r));
+    }
+    pruneExecutions(jobId, keepCount) {
+        this.db.prepare(`
+      DELETE FROM chronos_executions
+      WHERE job_id = ? AND id NOT IN (
+        SELECT id FROM chronos_executions
+        WHERE job_id = ?
+        ORDER BY triggered_at DESC
+        LIMIT ?
+      )
+    `).run(jobId, jobId, keepCount);
+    }
+    close() {
+        this.db.close();
+    }
+}

package/dist/runtime/chronos/worker.js

@@ -0,0 +1,141 @@
+import { randomUUID } from 'crypto';
+import { ConfigManager } from '../../config/manager.js';
+import { DisplayManager } from '../display.js';
+import { parseNextRun } from './parser.js';
+export class ChronosWorker {
+    repo;
+    oracle;
+    static instance = null;
+    static notifyFn = null;
+    /**
+     * True while a Chronos job is being executed. Chronos management tools
+     * (chronos_cancel, chronos_schedule) check this flag and refuse to operate
+     * during execution to prevent the Oracle from self-deleting or re-scheduling
+     * the active job.
+     */
+    static isExecuting = false;
+    timer = null;
+    isRunning = false;
+    pollIntervalMs;
+    constructor(repo, oracle) {
+        this.repo = repo;
+        this.oracle = oracle;
+        this.pollIntervalMs = ConfigManager.getInstance().getChronosConfig().check_interval_ms;
+    }
+    static getInstance() {
+        return ChronosWorker.instance;
+    }
+    static setInstance(worker) {
+        ChronosWorker.instance = worker;
+    }
+    /** Register a function that will deliver Oracle responses to users (e.g. Telegram). */
+    static setNotifyFn(fn) {
+        ChronosWorker.notifyFn = fn;
+    }
+    start() {
+        if (this.timer)
+            return;
+        const display = DisplayManager.getInstance();
+        display.log(`Worker started (interval: ${this.pollIntervalMs}ms)`, { source: 'Chronos' });
+        this.timer = setInterval(() => void this.tick(), this.pollIntervalMs);
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        const display = DisplayManager.getInstance();
+        display.log('Worker stopped', { source: 'Chronos' });
+    }
+    /** Hot-reload poll interval without restarting the process */
+    updateInterval(newMs) {
+        if (newMs < 60000)
+            return;
+        this.pollIntervalMs = newMs;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = setInterval(() => void this.tick(), this.pollIntervalMs);
+        }
+        const display = DisplayManager.getInstance();
+        display.log(`Worker interval updated to ${newMs}ms`, { source: 'Chronos' });
+    }
+    async tick() {
+        if (this.isRunning)
+            return;
+        this.isRunning = true;
+        try {
+            const dueJobs = this.repo.getDueJobs(Date.now());
+            for (const job of dueJobs) {
+                void this.executeJob(job);
+            }
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    async executeJob(job) {
+        const display = DisplayManager.getInstance();
+        const execId = randomUUID();
+        display.log(`Job ${job.id} triggered — "${job.prompt.slice(0, 60)}"`, { source: 'Chronos' });
+        // Use the currently active Oracle session so Chronos executes in the
+        // user's conversation context — no session switching or isolation needed.
+        const activeSessionId = this.oracle.getCurrentSessionId() ?? 'default';
+        this.repo.insertExecution({
+            id: execId,
+            job_id: job.id,
+            triggered_at: Date.now(),
+            status: 'running',
+            session_id: activeSessionId,
+        });
+        try {
+            // Inject execution context as an AI message so it appears naturally in the
+            // conversation history without triggering an extra LLM response.
+            const contextMessage = `[CHRONOS EXECUTION — job_id: ${job.id}]\n` +
+                `Executing scheduled job. Do NOT call chronos_cancel, chronos_schedule, ` +
+                `or any Chronos management tools during this execution.`;
+            await this.oracle.injectAIMessage(contextMessage);
+            // If a Telegram notify function is registered, tag delegated tasks with
+            // origin_channel: 'telegram' so the TaskDispatcher broadcasts their result.
+            const taskContext = ChronosWorker.notifyFn
+                ? { origin_channel: 'telegram', session_id: activeSessionId }
+                : undefined;
+            // Hard-block Chronos management tools during execution.
+            ChronosWorker.isExecuting = true;
+            const response = await this.oracle.chat(job.prompt, undefined, false, taskContext);
+            this.repo.completeExecution(execId, 'success');
+            display.log(`Job ${job.id} completed — status: success`, { source: 'Chronos' });
+            // Deliver Oracle response to notification channels.
+            await this.notify(job, response);
+        }
+        catch (err) {
+            const errMsg = err?.message ?? String(err);
+            this.repo.completeExecution(execId, 'failed', errMsg);
+            display.log(`Job ${job.id} failed — ${errMsg}`, { source: 'Chronos', level: 'error' });
+        }
+        finally {
+            ChronosWorker.isExecuting = false;
+            if (job.schedule_type === 'once') {
+                this.repo.disableJob(job.id);
+                display.log(`Job ${job.id} auto-disabled (once-type)`, { source: 'Chronos' });
+            }
+            else if (job.cron_normalized) {
+                const nextRunAt = parseNextRun(job.cron_normalized, job.timezone);
+                this.repo.updateJob(job.id, { next_run_at: nextRunAt, last_run_at: Date.now() });
+                display.log(`Job ${job.id} rescheduled — next_run_at: ${new Date(nextRunAt).toISOString()}`, { source: 'Chronos' });
+            }
+            this.repo.pruneExecutions(job.id, 100);
+        }
+    }
+    async notify(job, response) {
+        if (!ChronosWorker.notifyFn)
+            return;
+        const display = DisplayManager.getInstance();
+        const header = `⏰ *Chronos* — _${job.prompt.slice(0, 80)}${job.prompt.length > 80 ? '…' : ''}_\n\n`;
+        try {
+            await ChronosWorker.notifyFn(header + response);
+        }
+        catch (err) {
+            display.log(`Job ${job.id} notification failed — ${err.message}`, { source: 'Chronos', level: 'error' });
+        }
+    }
+}

package/dist/runtime/chronos/worker.test.js

@@ -0,0 +1,120 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ChronosWorker } from './worker.js';
+// Mock ConfigManager and DisplayManager
+vi.mock('../../config/manager.js', () => ({
+    ConfigManager: {
+        getInstance: () => ({
+            getChronosConfig: () => ({ timezone: 'UTC', check_interval_ms: 60000, max_active_jobs: 100 }),
+        }),
+    },
+}));
+vi.mock('../display.js', () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        }),
+    },
+}));
+function makeJob(overrides = {}) {
+    return {
+        id: 'job-1',
+        prompt: 'Say hello',
+        schedule_type: 'once',
+        schedule_expression: 'in 1 hour',
+        cron_normalized: null,
+        timezone: 'UTC',
+        next_run_at: Date.now() - 1000,
+        last_run_at: null,
+        enabled: true,
+        created_at: Date.now() - 5000,
+        updated_at: Date.now() - 5000,
+        created_by: 'ui',
+        ...overrides,
+    };
+}
+function makeRepo(jobs = []) {
+    return {
+        getDueJobs: vi.fn().mockReturnValue(jobs),
+        insertExecution: vi.fn(),
+        completeExecution: vi.fn(),
+        disableJob: vi.fn(),
+        enableJob: vi.fn(),
+        updateJob: vi.fn(),
+        pruneExecutions: vi.fn(),
+        createJob: vi.fn(),
+        getJob: vi.fn(),
+        listJobs: vi.fn(),
+        deleteJob: vi.fn(),
+        listExecutions: vi.fn(),
+        close: vi.fn(),
+    };
+}
+function makeOracle() {
+    return {
+        chat: vi.fn().mockResolvedValue('Oracle response'),
+        setSessionId: vi.fn().mockResolvedValue(undefined),
+        getCurrentSessionId: vi.fn().mockReturnValue('user-session-1'),
+        initialize: vi.fn(),
+        getHistory: vi.fn(),
+        createNewSession: vi.fn(),
+        clearMemory: vi.fn(),
+        reloadTools: vi.fn(),
+    };
+}
+describe('ChronosWorker.tick()', () => {
+    it('isRunning guard prevents concurrent execution', async () => {
+        const repo = makeRepo([]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        // Set isRunning to true via tick (accessing private via casting)
+        worker.isRunning = true;
+        await worker.tick();
+        expect(repo.getDueJobs).not.toHaveBeenCalled();
+    });
+    it('calls getDueJobs with current timestamp', async () => {
+        const repo = makeRepo([]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        const before = Date.now();
+        await worker.tick();
+        const after = Date.now();
+        const [[ts]] = repo.getDueJobs.mock.calls;
+        expect(ts).toBeGreaterThanOrEqual(before);
+        expect(ts).toBeLessThanOrEqual(after);
+    });
+    it('triggers oracle.chat for a once-type due job then disables it', async () => {
+        const job = makeJob({ schedule_type: 'once' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        // Wait for fire-and-forget
+        await new Promise((r) => setTimeout(r, 50));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(repo.disableJob).toHaveBeenCalledWith(job.id);
+        expect(repo.updateJob).not.toHaveBeenCalled();
+    });
+    it('triggers oracle.chat for a recurring job then updates next_run_at', async () => {
+        const job = makeJob({ schedule_type: 'cron', cron_normalized: '0 9 * * *' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(oracle.chat).toHaveBeenCalledWith(expect.stringContaining(job.prompt));
+        expect(repo.disableJob).not.toHaveBeenCalled();
+        expect(repo.updateJob).toHaveBeenCalledWith(job.id, expect.objectContaining({ next_run_at: expect.any(Number) }));
+    });
+    it('sets execution status to failed when oracle.chat rejects', async () => {
+        const job = makeJob({ schedule_type: 'once' });
+        const repo = makeRepo([job]);
+        const oracle = makeOracle();
+        oracle.chat.mockRejectedValue(new Error('LLM error'));
+        const worker = new ChronosWorker(repo, oracle);
+        await worker.tick();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(repo.completeExecution).toHaveBeenCalledWith(expect.any(String), 'failed', 'LLM error');
+        // For once-type, still auto-disable even on failure
+        expect(repo.disableJob).toHaveBeenCalledWith(job.id);
+    });
+});

package/dist/runtime/display.js

@@ -98,6 +98,9 @@ export class DisplayManager {
             else if (options.source === 'Zaion') {
                 color = chalk.hex('#00c3ff');
             }
+            else if (options.source === 'Chronos') {
+                color = chalk.hex('#a855f7');
+            }
             prefix = color(`[${options.source}] `);
         }
         let formattedMessage = message;

package/dist/runtime/memory/sati/repository.js

@@ -208,7 +208,7 @@ export class SatiRepository {
     searchUnifiedVector(embedding, limit) {
         if (!this.db)
             return [];
-        const SIMILARITY_THRESHOLD = 0.8;
+        const SIMILARITY_THRESHOLD = 0.9;
         const stmt = this.db.prepare(`
     SELECT *
     FROM (