@quantiya/codevibe-codex-plugin 1.0.7 → 1.0.9

package/dist/session-id-cache.js

@@ -1,90 +0,0 @@
-"use strict";
-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.sessionIdCache = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const logger_1 = require("./logger");
-/**
- * Persists a mapping of Codex log filenames to backend session IDs.
- * This ensures resumes (which reuse the same log file) attach to the same backend session.
- */
-class SessionIdCache {
-    constructor() {
-        this.map = {};
-        const configDir = path.join(os.homedir(), '.codevibe-codex');
-        if (!fs.existsSync(configDir)) {
-            fs.mkdirSync(configDir, { recursive: true });
-        }
-        this.cachePath = path.join(configDir, 'session-id-map.json');
-        this.load();
-    }
-    load() {
-        try {
-            if (fs.existsSync(this.cachePath)) {
-                const raw = fs.readFileSync(this.cachePath, 'utf-8');
-                this.map = JSON.parse(raw);
-            }
-        }
-        catch (error) {
-            logger_1.logger.warn('Failed to load session ID cache', { cachePath: this.cachePath, error });
-            this.map = {};
-        }
-    }
-    save() {
-        try {
-            fs.writeFileSync(this.cachePath, JSON.stringify(this.map, null, 2), 'utf-8');
-        }
-        catch (error) {
-            logger_1.logger.warn('Failed to write session ID cache', { cachePath: this.cachePath, error });
-        }
-    }
-    get(logFilePath) {
-        if (!logFilePath)
-            return null;
-        const key = path.basename(logFilePath);
-        return this.map[key] || null;
-    }
-    set(logFilePath, sessionId) {
-        if (!logFilePath)
-            return;
-        const key = path.basename(logFilePath);
-        this.map[key] = sessionId;
-        this.save();
-    }
-}
-exports.sessionIdCache = new SessionIdCache();
-//# sourceMappingURL=session-id-cache.js.map

package/dist/session-log-watcher.js

@@ -1,372 +0,0 @@
-"use strict";
-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.SessionLogWatcher = void 0;
-const events_1 = require("events");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const readline = __importStar(require("readline"));
-const chokidar_1 = require("chokidar");
-const codevibe_core_1 = require("@quantiya/codevibe-core");
-const logger_1 = require("./logger");
-/**
- * Watches Codex CLI session log files for new entries
- *
- * Codex writes JSONL logs to: ~/.codex/sessions/YYYY/MM/DD/rollout-{timestamp}-{uuid}.jsonl
- *
- * Events emitted:
- * - 'session-started': New session detected (CodexSessionMeta)
- * - 'log-entry': New log entry (CodexLogEntry)
- * - 'error': Error occurred
- */
-class SessionLogWatcher extends events_1.EventEmitter {
-    constructor() {
-        super();
-        this.watcher = null;
-        this.filePositions = new Map();
-        this.activeLogFile = null;
-        this.sessionId = null;
-        this.isWatching = false;
-        this.startTime = 0; // Track when watcher started
-        this.sessionsDir = null;
-    }
-    /**
-     * Start watching for Codex session logs
-     */
-    start() {
-        if (this.isWatching) {
-            logger_1.logger.warn('Session log watcher already running');
-            return;
-        }
-        const sessionsDir = (0, codevibe_core_1.getConfig)().codex.sessionsDir;
-        this.sessionsDir = sessionsDir;
-        logger_1.logger.info('Starting Codex session log watcher', { sessionsDir });
-        // Ensure sessions directory exists
-        if (!fs.existsSync(sessionsDir)) {
-            logger_1.logger.info('Codex sessions directory does not exist yet, creating...', { sessionsDir });
-            fs.mkdirSync(sessionsDir, { recursive: true });
-        }
-        // Record start time to filter out pre-existing files
-        this.startTime = Date.now();
-        // Watch the entire sessions directory recursively
-        // Chokidar glob patterns don't work well on macOS, so watch the directory
-        // and filter for .jsonl files in the event handlers
-        // Use ignoreInitial: true to avoid processing old session files
-        this.watcher = (0, chokidar_1.watch)(sessionsDir, {
-            persistent: true,
-            ignoreInitial: true, // Only watch for NEW files, not existing ones
-            awaitWriteFinish: {
-                stabilityThreshold: 100,
-                pollInterval: 50,
-            },
-            depth: 4, // YYYY/MM/DD depth
-            ignored: (filePath) => {
-                // Only watch .jsonl files that match the rollout pattern
-                const basename = path.basename(filePath);
-                const isDir = fs.existsSync(filePath) && fs.statSync(filePath).isDirectory();
-                if (isDir)
-                    return false; // Don't ignore directories
-                return !basename.startsWith('rollout-') || !basename.endsWith('.jsonl');
-            },
-        });
-        this.watcher.on('add', (filePath) => {
-            if (filePath.endsWith('.jsonl')) {
-                this.onFileAdded(filePath);
-            }
-        });
-        this.watcher.on('change', (filePath) => {
-            if (filePath.endsWith('.jsonl')) {
-                this.onFileChanged(filePath);
-            }
-        });
-        this.watcher.on('error', (error) => {
-            logger_1.logger.error('Watcher error:', error);
-            this.emit('error', error);
-        });
-        this.watcher.on('ready', () => {
-            logger_1.logger.info('Session log watcher ready');
-            this.bindRecentSessionFile();
-        });
-        this.isWatching = true;
-        logger_1.logger.info('Session log watcher started');
-    }
-    /**
-     * Stop watching for session logs
-     */
-    stop() {
-        if (this.watcher) {
-            this.watcher.close();
-            this.watcher = null;
-        }
-        this.isWatching = false;
-        this.filePositions.clear();
-        this.activeLogFile = null;
-        this.sessionId = null;
-        this.sessionsDir = null;
-        logger_1.logger.info('Session log watcher stopped');
-    }
-    /**
-     * Get the current active session ID
-     */
-    getSessionId() {
-        return this.sessionId;
-    }
-    /**
-     * Get the current active log file
-     */
-    getActiveLogFile() {
-        return this.activeLogFile;
-    }
-    /**
-     * Handle new log file detected
-     */
-    onFileAdded(filePath) {
-        // Safety check: only process files created after watcher started
-        // This prevents processing old sessions if ignoreInitial doesn't work
-        try {
-            const stat = fs.statSync(filePath);
-            const fileCreatedAt = stat.birthtimeMs || stat.ctimeMs;
-            // Allow 5 second buffer for timing differences
-            if (fileCreatedAt < this.startTime - 5000) {
-                logger_1.logger.debug('Ignoring old session file', {
-                    filePath,
-                    fileCreatedAt: new Date(fileCreatedAt).toISOString(),
-                    startTime: new Date(this.startTime).toISOString()
-                });
-                return;
-            }
-        }
-        catch (error) {
-            logger_1.logger.warn('Could not check file creation time', { filePath, error });
-        }
-        if (this.activeLogFile) {
-            logger_1.logger.debug('Ignoring additional Codex session log for this server instance', {
-                activeLogFile: this.activeLogFile,
-                ignoredFile: filePath,
-            });
-            return;
-        }
-        logger_1.logger.info('New Codex session log detected', { filePath });
-        // This is now the active session
-        this.activeLogFile = filePath;
-        this.filePositions.set(filePath, 0);
-        // Read all existing content
-        this.readNewLines(filePath);
-    }
-    /**
-     * Handle log file changes
-     */
-    onFileChanged(filePath) {
-        // Each server instance must stay pinned to the first session log it binds to.
-        // Otherwise a second Codex session can hijack the first server instance.
-        if (this.activeLogFile && filePath !== this.activeLogFile) {
-            logger_1.logger.debug('Ignoring change for non-active session log', {
-                activeLogFile: this.activeLogFile,
-                ignoredFile: filePath,
-            });
-            return;
-        }
-        if (!this.activeLogFile) {
-            // Only bind to files created or modified after this watcher started.
-            // Without this check, a second server instance can accidentally bind to
-            // the first server's Codex log file when Codex 1 writes new content,
-            // causing Codex 2's events to be lost entirely.
-            try {
-                const stat = fs.statSync(filePath);
-                const fileCreatedAt = stat.birthtimeMs || stat.ctimeMs;
-                const fileModifiedAt = stat.mtimeMs;
-                // Allow files that were created recently OR modified recently (resumed sessions)
-                if (fileCreatedAt < this.startTime - 5000 && fileModifiedAt < this.startTime - 5000) {
-                    logger_1.logger.debug('Ignoring change for pre-existing session file', {
-                        filePath,
-                        fileCreatedAt: new Date(fileCreatedAt).toISOString(),
-                        fileModifiedAt: new Date(fileModifiedAt).toISOString(),
-                        startTime: new Date(this.startTime).toISOString(),
-                    });
-                    return;
-                }
-            }
-            catch (error) {
-                logger_1.logger.warn('Could not check file creation time during change event', { filePath, error });
-            }
-            this.activeLogFile = filePath;
-            this.filePositions.set(filePath, 0);
-        }
-        this.readNewLines(filePath);
-    }
-    /**
-     * Backfill any very recent session file that was created while chokidar was
-     * still performing its initial scan. This avoids missing the first log file
-     * for a newly started server instance.
-     */
-    bindRecentSessionFile() {
-        if (this.activeLogFile || !this.sessionsDir) {
-            return;
-        }
-        try {
-            const candidates = this.collectRecentSessionFiles(this.sessionsDir)
-                .sort((left, right) => right.modifiedAt - left.modifiedAt);
-            const recent = candidates[0];
-            if (!recent) {
-                return;
-            }
-            logger_1.logger.info('Binding recent session file missed during initial watch scan', {
-                filePath: recent.filePath,
-                fileCreatedAt: new Date(recent.createdAt).toISOString(),
-                fileModifiedAt: new Date(recent.modifiedAt).toISOString(),
-                watcherStartTime: new Date(this.startTime).toISOString(),
-            });
-            this.activeLogFile = recent.filePath;
-            this.filePositions.set(recent.filePath, 0);
-            this.readNewLines(recent.filePath);
-        }
-        catch (error) {
-            logger_1.logger.warn('Failed to backfill recent session file', { error });
-        }
-    }
-    collectRecentSessionFiles(rootDir) {
-        const results = [];
-        const stack = [rootDir];
-        while (stack.length > 0) {
-            const currentDir = stack.pop();
-            if (!currentDir) {
-                continue;
-            }
-            let entries;
-            try {
-                entries = fs.readdirSync(currentDir, { withFileTypes: true });
-            }
-            catch {
-                continue;
-            }
-            for (const entry of entries) {
-                const fullPath = path.join(currentDir, entry.name);
-                if (entry.isDirectory()) {
-                    stack.push(fullPath);
-                    continue;
-                }
-                if (!entry.isFile() || !entry.name.startsWith('rollout-') || !entry.name.endsWith('.jsonl')) {
-                    continue;
-                }
-                try {
-                    const stat = fs.statSync(fullPath);
-                    const createdAt = stat.birthtimeMs || stat.ctimeMs;
-                    const modifiedAt = stat.mtimeMs;
-                    // Include files that were created OR modified recently
-                    if (createdAt >= this.startTime || modifiedAt >= this.startTime - 5000) {
-                        results.push({ filePath: fullPath, createdAt, modifiedAt });
-                    }
-                }
-                catch {
-                    // Ignore files that disappear between readdir and stat
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Read new lines from the log file and emit events
-     */
-    async readNewLines(filePath) {
-        const position = this.filePositions.get(filePath) || 0;
-        try {
-            const stat = fs.statSync(filePath);
-            if (stat.size <= position) {
-                return; // No new content
-            }
-            // Create read stream starting from last position
-            const stream = fs.createReadStream(filePath, {
-                start: position,
-                encoding: 'utf-8',
-            });
-            const rl = readline.createInterface({
-                input: stream,
-                crlfDelay: Infinity,
-            });
-            let bytesRead = position;
-            for await (const line of rl) {
-                bytesRead += Buffer.byteLength(line, 'utf-8') + 1; // +1 for newline
-                if (!line.trim())
-                    continue;
-                try {
-                    const entry = JSON.parse(line);
-                    this.processLogEntry(entry);
-                }
-                catch (parseError) {
-                    logger_1.logger.warn('Failed to parse log line', {
-                        filePath,
-                        line: line.substring(0, 100),
-                        error: parseError
-                    });
-                }
-            }
-            // Update position
-            this.filePositions.set(filePath, bytesRead);
-        }
-        catch (error) {
-            logger_1.logger.error('Error reading log file', { filePath, error });
-            this.emit('error', error);
-        }
-    }
-    /**
-     * Process a single log entry
-     */
-    processLogEntry(entry) {
-        logger_1.logger.debug('Processing log entry', { type: entry.type });
-        // Handle session metadata (first entry in file)
-        if (entry.type === 'session_meta') {
-            const meta = entry.payload;
-            this.sessionId = meta.id;
-            logger_1.logger.info('Codex session started', {
-                sessionId: meta.id,
-                cwd: meta.cwd,
-                cliVersion: meta.cli_version,
-            });
-            this.emit('session-started', meta);
-            return;
-        }
-        // Emit all other entries
-        this.emit('log-entry', entry);
-        // Also emit specific events for convenience
-        if (entry.type === 'event_msg' && entry.payload?.type) {
-            this.emit(`event:${entry.payload.type}`, entry);
-        }
-        else if (entry.type === 'response_item' && entry.payload?.type) {
-            this.emit(`response:${entry.payload.type}`, entry);
-        }
-    }
-}
-exports.SessionLogWatcher = SessionLogWatcher;
-//# sourceMappingURL=session-log-watcher.js.map