genesis-ai-cli 7.4.5

package/dist/src/daemon/process.js

@@ -0,0 +1,442 @@
+"use strict";
+/**
+ * Genesis 6.0 - Daemon Process Manager
+ *
+ * Handles background process spawning, PID management, and IPC.
+ *
+ * Architecture:
+ * - Parent process spawns detached child
+ * - Child creates Unix socket for IPC
+ * - CLI commands communicate via socket
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LOG_FILE = exports.SOCKET_PATH = exports.PID_FILE = exports.DATA_DIR = exports.DaemonProcessManager = void 0;
+exports.getProcessManager = getProcessManager;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const net = __importStar(require("net"));
+const child_process_1 = require("child_process");
+const index_js_1 = require("./index.js");
+// ============================================================================
+// Constants
+// ============================================================================
+const DATA_DIR = path.join(process.env.HOME || '/tmp', '.genesis');
+exports.DATA_DIR = DATA_DIR;
+const PID_FILE = path.join(DATA_DIR, 'daemon.pid');
+exports.PID_FILE = PID_FILE;
+const SOCKET_PATH = path.join(DATA_DIR, 'daemon.sock');
+exports.SOCKET_PATH = SOCKET_PATH;
+const LOG_FILE = path.join(DATA_DIR, 'daemon.log');
+exports.LOG_FILE = LOG_FILE;
+// ============================================================================
+// Process Manager
+// ============================================================================
+class DaemonProcessManager {
+    daemon = null;
+    server = null;
+    logStream = null;
+    constructor() {
+        this.ensureDataDir();
+    }
+    // ============================================================================
+    // Data Directory
+    // ============================================================================
+    ensureDataDir() {
+        if (!fs.existsSync(DATA_DIR)) {
+            fs.mkdirSync(DATA_DIR, { recursive: true });
+        }
+    }
+    // ============================================================================
+    // PID Management
+    // ============================================================================
+    writePid() {
+        fs.writeFileSync(PID_FILE, String(process.pid));
+    }
+    readPid() {
+        try {
+            const pid = parseInt(fs.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+            return isNaN(pid) ? null : pid;
+        }
+        catch {
+            return null;
+        }
+    }
+    removePid() {
+        try {
+            fs.unlinkSync(PID_FILE);
+        }
+        catch {
+            // Ignore
+        }
+    }
+    isProcessRunning(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ============================================================================
+    // Socket Management
+    // ============================================================================
+    cleanupSocket() {
+        try {
+            if (fs.existsSync(SOCKET_PATH)) {
+                fs.unlinkSync(SOCKET_PATH);
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    // ============================================================================
+    // Logging
+    // ============================================================================
+    initLogging() {
+        this.logStream = fs.createWriteStream(LOG_FILE, { flags: 'a' });
+        // Redirect console to log file
+        const originalLog = console.log;
+        const originalError = console.error;
+        const stream = this.logStream;
+        console.log = (...args) => {
+            const msg = `[${new Date().toISOString()}] ${args.join(' ')}\n`;
+            stream.write(msg);
+        };
+        console.error = (...args) => {
+            const msg = `[${new Date().toISOString()}] ERROR: ${args.join(' ')}\n`;
+            stream.write(msg);
+        };
+    }
+    closeLogging() {
+        if (this.logStream) {
+            this.logStream.end();
+            this.logStream = null;
+        }
+    }
+    // ============================================================================
+    // IPC Server
+    // ============================================================================
+    startIPCServer() {
+        this.cleanupSocket();
+        this.server = net.createServer((socket) => {
+            let buffer = '';
+            socket.on('data', (data) => {
+                buffer += data.toString();
+                // Process complete messages (newline-delimited JSON)
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (line.trim()) {
+                        this.handleIPCRequest(socket, line.trim());
+                    }
+                }
+            });
+            socket.on('error', (err) => {
+                console.error('IPC socket error:', err.message);
+            });
+        });
+        this.server.listen(SOCKET_PATH, () => {
+            console.log(`IPC server listening on ${SOCKET_PATH}`);
+        });
+        this.server.on('error', (err) => {
+            console.error('IPC server error:', err);
+        });
+    }
+    handleIPCRequest(socket, data) {
+        let request;
+        try {
+            request = JSON.parse(data);
+        }
+        catch {
+            this.sendResponse(socket, { id: 'unknown', success: false, error: 'Invalid JSON' });
+            return;
+        }
+        const respond = (success, data, error) => {
+            this.sendResponse(socket, { id: request.id, success, data, error });
+        };
+        try {
+            switch (request.method) {
+                case 'ping':
+                    respond(true, { pong: true });
+                    break;
+                case 'status':
+                    if (this.daemon) {
+                        respond(true, this.daemon.status());
+                    }
+                    else {
+                        respond(false, null, 'Daemon not initialized');
+                    }
+                    break;
+                case 'stop':
+                    respond(true, { stopping: true });
+                    // Schedule stop after response is sent
+                    setImmediate(() => this.stopDaemon());
+                    break;
+                case 'dream':
+                    if (this.daemon) {
+                        this.daemon.dream(request.params || {})
+                            .then((results) => respond(true, results))
+                            .catch((err) => respond(false, null, err.message));
+                    }
+                    else {
+                        respond(false, null, 'Daemon not initialized');
+                    }
+                    break;
+                case 'maintenance':
+                    if (this.daemon) {
+                        this.daemon.runMaintenance()
+                            .then((report) => respond(true, report))
+                            .catch((err) => respond(false, null, err.message));
+                    }
+                    else {
+                        respond(false, null, 'Daemon not initialized');
+                    }
+                    break;
+                case 'tasks':
+                    if (this.daemon) {
+                        const tasks = this.daemon.getTasks().map((t) => ({
+                            id: t.id,
+                            name: t.name,
+                            schedule: t.schedule,
+                            state: t.state,
+                            lastRun: t.lastRun,
+                            nextRun: t.nextRun,
+                        }));
+                        respond(true, { tasks });
+                    }
+                    else {
+                        respond(false, null, 'Daemon not initialized');
+                    }
+                    break;
+                default:
+                    respond(false, null, `Unknown method: ${request.method}`);
+            }
+        }
+        catch (err) {
+            respond(false, null, err instanceof Error ? err.message : String(err));
+        }
+    }
+    sendResponse(socket, response) {
+        try {
+            socket.write(JSON.stringify(response) + '\n');
+        }
+        catch {
+            // Socket may be closed
+        }
+    }
+    stopIPCServer() {
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        this.cleanupSocket();
+    }
+    // ============================================================================
+    // Daemon Lifecycle
+    // ============================================================================
+    /**
+     * Start daemon in current process (for background mode)
+     */
+    startDaemon() {
+        console.log('Starting Genesis daemon...');
+        // Write PID
+        this.writePid();
+        // Initialize logging
+        this.initLogging();
+        // Create daemon
+        this.daemon = (0, index_js_1.createDaemon)({
+            log: (msg, level) => console.log(`[${level?.toUpperCase() || 'INFO'}] ${msg}`),
+        }, {
+            logLevel: 'info',
+        });
+        // Start IPC server
+        this.startIPCServer();
+        // Start daemon
+        this.daemon.start();
+        // Handle shutdown signals
+        process.on('SIGTERM', () => this.stopDaemon());
+        process.on('SIGINT', () => this.stopDaemon());
+        process.on('SIGHUP', () => this.stopDaemon());
+        console.log(`Daemon started (PID: ${process.pid})`);
+    }
+    /**
+     * Stop daemon
+     */
+    stopDaemon() {
+        console.log('Stopping Genesis daemon...');
+        if (this.daemon) {
+            this.daemon.stop();
+            this.daemon = null;
+        }
+        this.stopIPCServer();
+        this.removePid();
+        this.closeLogging();
+        console.log('Daemon stopped');
+        process.exit(0);
+    }
+    // ============================================================================
+    // CLI Interface
+    // ============================================================================
+    /**
+     * Check if daemon is running
+     */
+    getInfo() {
+        const pid = this.readPid();
+        const running = pid !== null && this.isProcessRunning(pid);
+        // Clean up stale PID file
+        if (!running && pid !== null) {
+            this.removePid();
+        }
+        return {
+            running,
+            pid: running ? pid : null,
+            uptime: null, // Would need to query via IPC
+            socketPath: SOCKET_PATH,
+        };
+    }
+    /**
+     * Spawn daemon as background process
+     */
+    async spawn() {
+        const info = this.getInfo();
+        if (info.running) {
+            return { success: false, error: `Daemon already running (PID: ${info.pid})` };
+        }
+        // Find the entry point
+        const entryPoint = process.argv[1];
+        const args = ['daemon', 'run'];
+        // Spawn detached child
+        const child = (0, child_process_1.spawn)(process.execPath, [entryPoint, ...args], {
+            detached: true,
+            stdio: ['ignore', 'ignore', 'ignore'],
+            env: { ...process.env, GENESIS_DAEMON_MODE: 'background' },
+        });
+        child.unref();
+        // Wait a moment for the daemon to start
+        await new Promise((r) => setTimeout(r, 1000));
+        // Verify it started
+        const newInfo = this.getInfo();
+        if (newInfo.running) {
+            return { success: true, pid: newInfo.pid };
+        }
+        else {
+            return { success: false, error: 'Daemon failed to start' };
+        }
+    }
+    /**
+     * Stop running daemon via IPC
+     */
+    async kill() {
+        const info = this.getInfo();
+        if (!info.running) {
+            return { success: false, error: 'Daemon is not running' };
+        }
+        try {
+            // Try IPC first
+            const response = await this.ipcCall('stop');
+            if (response.success) {
+                // Wait for process to exit
+                await new Promise((r) => setTimeout(r, 1000));
+                return { success: true };
+            }
+        }
+        catch {
+            // IPC failed, try SIGTERM
+        }
+        // Fallback to SIGTERM
+        if (info.pid) {
+            try {
+                process.kill(info.pid, 'SIGTERM');
+                await new Promise((r) => setTimeout(r, 1000));
+                return { success: true };
+            }
+            catch {
+                return { success: false, error: 'Failed to kill process' };
+            }
+        }
+        return { success: false, error: 'Unknown error' };
+    }
+    /**
+     * Send IPC command to daemon
+     */
+    async ipcCall(method, params) {
+        const info = this.getInfo();
+        if (!info.running) {
+            throw new Error('Daemon is not running');
+        }
+        return new Promise((resolve, reject) => {
+            const socket = net.createConnection(SOCKET_PATH);
+            const id = Math.random().toString(36).slice(2);
+            let timeout;
+            socket.on('connect', () => {
+                const request = { id, method, params };
+                socket.write(JSON.stringify(request) + '\n');
+                timeout = setTimeout(() => {
+                    socket.destroy();
+                    reject(new Error('IPC timeout'));
+                }, 10000);
+            });
+            socket.on('data', (data) => {
+                clearTimeout(timeout);
+                try {
+                    const response = JSON.parse(data.toString().trim());
+                    resolve(response);
+                }
+                catch {
+                    reject(new Error('Invalid response'));
+                }
+                socket.end();
+            });
+            socket.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+}
+exports.DaemonProcessManager = DaemonProcessManager;
+// ============================================================================
+// Singleton
+// ============================================================================
+let processManager = null;
+function getProcessManager() {
+    if (!processManager) {
+        processManager = new DaemonProcessManager();
+    }
+    return processManager;
+}

package/dist/src/daemon/scheduler.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Genesis 6.0 - Task Scheduler
+ *
+ * Background task scheduling with priorities, retries, and monitoring.
+ *
+ * Features:
+ * - Priority-based execution queue
+ * - Interval and cron scheduling
+ * - Automatic retries with backoff
+ * - Task timeout handling
+ * - Concurrent execution limits
+ *
+ * Usage:
+ * ```typescript
+ * import { createScheduler } from './daemon/scheduler.js';
+ *
+ * const scheduler = createScheduler({ maxConcurrentTasks: 5 });
+ *
+ * // Schedule a recurring task
+ * scheduler.schedule({
+ *   name: 'health-check',
+ *   schedule: { type: 'interval', intervalMs: 60000 },
+ *   handler: async (ctx) => {
+ *     ctx.logger.info('Running health check');
+ *     return { success: true, duration: 50 };
+ *   },
+ * });
+ *
+ * // Start the scheduler
+ * scheduler.start();
+ * ```
+ */
+import { ScheduledTask, CreateTaskOptions } from './types.js';
+export interface SchedulerConfig {
+    maxConcurrentTasks: number;
+    defaultTimeout: number;
+    defaultRetries: number;
+    defaultRetryDelay: number;
+    tickIntervalMs: number;
+}
+export declare const DEFAULT_SCHEDULER_CONFIG: SchedulerConfig;
+export type SchedulerEventType = 'started' | 'stopped' | 'task_scheduled' | 'task_started' | 'task_completed' | 'task_failed' | 'task_cancelled';
+export type SchedulerEventHandler = (event: {
+    type: SchedulerEventType;
+    task?: ScheduledTask;
+    error?: Error;
+}) => void;
+export declare class Scheduler {
+    private tasks;
+    private running;
+    private tickTimer;
+    private config;
+    private started;
+    private eventHandlers;
+    constructor(config?: Partial<SchedulerConfig>);
+    start(): void;
+    stop(): void;
+    isRunning(): boolean;
+    schedule(options: CreateTaskOptions): ScheduledTask;
+    cancel(taskId: string): boolean;
+    remove(taskId: string): boolean;
+    pause(taskId: string): boolean;
+    resume(taskId: string): boolean;
+    trigger(taskId: string): boolean;
+    get(taskId: string): ScheduledTask | undefined;
+    getByName(name: string): ScheduledTask | undefined;
+    getAll(): ScheduledTask[];
+    getPending(): ScheduledTask[];
+    getRunning(): ScheduledTask[];
+    getByTag(tag: string): ScheduledTask[];
+    stats(): {
+        total: number;
+        pending: number;
+        scheduled: number;
+        running: number;
+        completed: number;
+        failed: number;
+        cancelled: number;
+        paused: number;
+    };
+    on(handler: SchedulerEventHandler): () => void;
+    private emit;
+    private tick;
+    private getDueTasks;
+    private executeTask;
+    private runWithTimeout;
+    private calculateNextRun;
+    private sleep;
+}
+export declare function createScheduler(config?: Partial<SchedulerConfig>): Scheduler;