claude-session-continuity-mcp 1.15.1 → 1.16.0

package/README.md

@@ -81,6 +81,24 @@ If you want zero-config, offline, no-cost memory that just *happens* while you w
 
 ---
 
+## Works with Codex CLI too (v1.16.0+)
+
+Beyond Claude Code, this also supports **OpenAI Codex CLI**. If `~/.codex` exists,
+the installer registers the same hooks in `~/.codex/hooks.json` (SessionStart,
+UserPromptSubmit, PreCompact, Stop), and the hooks auto-detect the host and emit
+the right output format (Codex's `hookSpecificOutput.additionalContext`).
+
+The same local `sessions.db` is shared, so context carries across both agents:
+what you did in Codex is available in Claude Code and vice versa.
+
+**Scope:** session save + context injection work on both. Codex file-change
+tracking (PostToolUse) isn't wired yet — session save already covers most of it
+via transcript parsing. Codex's `transcript_path` is treated as an unstable
+interface (it can be null at startup), so host detection uses an installer-injected
+`--codex` marker rather than relying on the path.
+
+---
+
 ## Quick Start
 
 ### Recommended: Global Installation

package/dist/hooks/install.js

@@ -16,6 +16,9 @@ const CLAUDE_DIR = path.join(os.homedir(), '.claude');
 const SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.json');
 const LEGACY_SETTINGS_FILE = path.join(CLAUDE_DIR, 'settings.local.json');
 const MCP_CONFIG_FILE = path.join(os.homedir(), '.claude.json');
+// Codex CLI (2026-07-09): hooks register in ~/.codex/hooks.json (same JSON shape as Claude)
+const CODEX_DIR = path.join(os.homedir(), '.codex');
+const CODEX_HOOKS_FILE = path.join(CODEX_DIR, 'hooks.json');
 // 설치된 패키지 경로 찾기
 function getPackagePath() {
     // 1. 글로벌 설치 확인
@@ -123,6 +126,44 @@ function installMcpServer() {
         return false;
     }
 }
+/**
+ * Register the same hooks in ~/.codex/hooks.json for OpenAI Codex CLI (2026-07-09).
+ * Only runs if ~/.codex exists (Codex installed). Preserves user's existing hooks;
+ * replaces only ours (matched by the claude-hook- command prefix).
+ */
+function installCodexHooks() {
+    if (!fs.existsSync(CODEX_DIR))
+        return; // Codex not installed -> skip silently
+    const OUR_PREFIX = 'claude-hook-';
+    let hooksConfig = { hooks: {} };
+    if (fs.existsSync(CODEX_HOOKS_FILE)) {
+        try {
+            hooksConfig = JSON.parse(fs.readFileSync(CODEX_HOOKS_FILE, 'utf-8'));
+        }
+        catch {
+            hooksConfig = { hooks: {} };
+        }
+    }
+    const hooks = hooksConfig.hooks || {};
+    const merge = (event, ourEntries) => {
+        const existing = (hooks[event] || []);
+        const userEntries = existing.filter(e => !(e.hooks || []).some(h => h.command && h.command.includes(OUR_PREFIX)));
+        hooks[event] = [...userEntries, ...ourEntries];
+    };
+    // Codex uses the same event names as Claude (SessionStart/UserPromptSubmit/Stop...).
+    // Append "--codex" so hooks detect the host reliably: Codex passes transcript_path
+    // as null at SessionStart, so the argv marker is the only dependable signal.
+    merge('SessionStart', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-session-start --codex' }] }]);
+    merge('UserPromptSubmit', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-user-prompt --codex' }] }]);
+    merge('PreCompact', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-pre-compact --codex' }] }]);
+    merge('Stop', [{ hooks: [{ type: 'command', command: 'npm exec -- claude-hook-session-end --codex' }] }]);
+    hooksConfig.hooks = hooks;
+    try {
+        fs.writeFileSync(CODEX_HOOKS_FILE, JSON.stringify(hooksConfig, null, 2));
+        console.log('✅ Codex CLI hooks installed (~/.codex/hooks.json)');
+    }
+    catch { /* non-fatal: Codex hooks are optional */ }
+}
 function install() {
     console.log('');
     console.log('╔════════════════════════════════════════════════════════════╗');
@@ -170,6 +211,9 @@ function install() {
     ]);
     settings.hooks = hooks;
     saveSettings(settings);
+    // Codex CLI hooks (2026-07-09): register the same hooks in ~/.codex/hooks.json
+    // if Codex is present. Hooks auto-detect the host and emit the right output format.
+    installCodexHooks();
     console.log('✅ Hooks installed (npm exec mode - works with local or global install!)');
     console.log('   SessionStart: context auto-load');
     console.log('   UserPromptSubmit: relevant memory injection');
@@ -224,6 +268,24 @@ function uninstall() {
         settings.hooks = hooks;
     }
     saveSettings(settings);
+    // Also remove our hooks from Codex (2026-07-09), preserving user's hooks.
+    if (fs.existsSync(CODEX_HOOKS_FILE)) {
+        try {
+            const cfg = JSON.parse(fs.readFileSync(CODEX_HOOKS_FILE, 'utf-8'));
+            const ch = cfg.hooks || {};
+            for (const event of ['SessionStart', 'UserPromptSubmit', 'PreCompact', 'Stop']) {
+                const existing = (ch[event] || []);
+                const remaining = existing.filter(e => !(e.hooks || []).some(h => h.command && h.command.includes(OUR_PREFIX)));
+                if (remaining.length === 0)
+                    delete ch[event];
+                else
+                    ch[event] = remaining;
+            }
+            cfg.hooks = ch;
+            fs.writeFileSync(CODEX_HOOKS_FILE, JSON.stringify(cfg, null, 2));
+        }
+        catch { /* non-fatal */ }
+    }
     console.log('✅ Hooks removed successfully!');
 }
 function status() {

package/dist/hooks/session-end.js

@@ -14,7 +14,7 @@ import * as path from 'path';
 import * as readline from 'readline';
 import * as crypto from 'crypto';
 import Database from 'better-sqlite3';
-import { logHookError } from '../utils/logger.js';
+import { logHookError, isCodexHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -207,6 +207,8 @@ function parseUserText(entry) {
     }
     // system-reminder, local-command 태그 제거
     text = text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+    // Codex support (2026-07-09): Codex injects <environment_context> into the first user message -> strip it
+    text = text.replace(/<environment_context>[\s\S]*?<\/environment_context>/g, '').trim();
     text = text.replace(/<local-command-caveat>[\s\S]*?<\/local-command-caveat>/g, '').trim();
     text = text.replace(/<command-name>[\s\S]*?<\/command-name>/g, '').trim();
     text = text.replace(/<command-message>[\s\S]*?<\/command-message>/g, '').trim();
@@ -237,6 +239,64 @@ function extractTextFromContent(content) {
     }
     return '';
 }
+/**
+ * Codex support (2026-07-09): normalize a Codex CLI rollout JSONL line into the
+ * Claude transcript entry shape, so the rest of parseTranscriptSinglePass
+ * (role/content/timestamp/commit/user-request extraction) can be reused as-is.
+ *
+ * Codex format: {timestamp, type, payload}
+ *   - payload.type=message, role=user/assistant, content[].text (input_text/output_text)
+ *   - payload.type=function_call, arguments={command:["zsh","-lc","git commit..."]}
+ *   - payload.type=session_meta (first line, ignored)
+ *   - reasoning/token_count etc. are ignored
+ * Returns a Claude-shaped entry ({type, timestamp, message:{content:[...]}}) or null (skip).
+ */
+function normalizeCodexLine(codexEntry) {
+    const p = codexEntry.payload;
+    if (!p)
+        return null;
+    const ts = codexEntry.timestamp;
+    // 1. user/assistant message -> text block
+    if (p.type === 'message' && (p.role === 'user' || p.role === 'assistant')) {
+        const text = (p.content || [])
+            .filter(c => c.type === 'input_text' || c.type === 'output_text' || c.type === 'text')
+            .map(c => c.text || '')
+            .join('\n');
+        if (!text)
+            return null;
+        return {
+            type: p.role === 'user' ? 'user' : 'assistant',
+            timestamp: ts,
+            message: { content: [{ type: 'text', text }] },
+        };
+    }
+    // 2. function_call(shell) -> tool_use block (for git commit extraction).
+    //    Codex passes command as an argv array (["zsh","-lc","git commit -m ..."]).
+    if (p.type === 'function_call' && p.arguments) {
+        let cmd = '';
+        try {
+            const args = JSON.parse(p.arguments);
+            if (Array.isArray(args.command)) {
+                // Codex uses ["zsh","-lc","<actual cmd>"]. The commit regex requires
+                // "^git" or "&& git", so strip the shell wrapper (zsh/bash -lc/-c)
+                // and keep only the actual command.
+                const a = args.command;
+                cmd = (a.length >= 3 && /^(zsh|bash|sh)$/.test(a[0]) && /^-[lc]+$/.test(a[1]))
+                    ? a.slice(2).join(' ')
+                    : a.join(' ');
+            }
+        }
+        catch { /* arguments not JSON -> skip */ }
+        if (!cmd)
+            return null;
+        return {
+            type: 'assistant',
+            timestamp: ts,
+            message: { content: [{ type: 'tool_use', input: { command: cmd } }] },
+        };
+    }
+    return null; // skip reasoning/token_count/session_meta etc.
+}
 /**
  * Single-Pass Transcript Parser
  * JSONL을 1회 스트림으로 읽으며 모든 데이터를 동시 추출
@@ -254,6 +314,8 @@ async function parseTranscriptSinglePass(transcriptPath) {
     };
     if (!transcriptPath || !fs.existsSync(transcriptPath))
         return result;
+    // Host detection: Codex uses ~/.codex/sessions/...rollout-*.jsonl, Claude uses ~/.claude/projects/...
+    const isCodex = isCodexHost(transcriptPath); // shared detection (argv marker or path)
     // commit 추출용 패턴
     const commitPatterns = [
         /git commit.*?-m\s*"\$\(cat <<'?EOF'?\n(.+?)(?:\n\n|\nCo-Authored|\nEOF)/s,
@@ -277,7 +339,11 @@ async function parseTranscriptSinglePass(transcriptPath) {
             if (!line.trim())
                 continue;
             try {
-                const entry = JSON.parse(line);
+                const rawEntry = JSON.parse(line);
+                // For Codex, normalize the rollout line into a Claude entry shape. Skipped lines (reasoning etc.) return null.
+                const entry = isCodex ? normalizeCodexLine(rawEntry) : rawEntry;
+                if (!entry)
+                    continue;
                 const role = entry.type || entry.role || '';
                 const content = entry.message?.content;
                 // === 0. Timestamp 추출 (세션 duration 계산용) ===

package/dist/hooks/session-start.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
-import { logHookError } from '../utils/logger.js';
+import { logHookError, emitContext, isCodexHost } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -259,10 +259,13 @@ async function main() {
         const dbPath = path.join(workspaceRoot, '.claude', 'sessions.db');
         const context = loadContext(dbPath, project);
         if (context) {
-            console.log(`\n<session-context project="${project}">\n${context}\n</session-context>\n`);
+            emitContext(`\n<session-context project="${project}">\n${context}\n</session-context>\n`, 'SessionStart', input.transcript_path);
         }
         else {
-            console.log(`\n[Session] Project: ${project} (no context yet)\n`);
+            // Only Claude gets the "no context" placeholder; Codex would just get empty context.
+            if (!isCodexHost(input.transcript_path)) {
+                console.log(`\n[Session] Project: ${project} (no context yet)\n`);
+            }
         }
         process.exit(0);
     }

package/dist/hooks/user-prompt-submit.js

@@ -5,7 +5,7 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import Database from 'better-sqlite3';
-import { logHookError } from '../utils/logger.js';
+import { logHookError, emitContext } from '../utils/logger.js';
 function detectWorkspaceRoot(cwd) {
     let current = cwd;
     const root = path.parse(current).root;
@@ -482,7 +482,7 @@ async function main() {
                     const pastSection = formatPastWork(pastWork);
                     db.close();
                     if (pastSection) {
-                        console.log(`\n<past-context project="${project}">\n${pastSection}\n</past-context>\n`);
+                        emitContext(`\n<past-context project="${project}">\n${pastSection}\n</past-context>\n`, 'UserPromptSubmit', input.transcript_path);
                     }
                 }
                 catch { /* ignore */ }
@@ -503,7 +503,7 @@ async function main() {
                                 const content = m.content.length > 120 ? m.content.slice(0, 120) + '...' : m.content;
                                 lines.push(`- [${m.memory_type}] ${content}`);
                             }
-                            console.log(`\n<triggered-context project="${project ?? 'global'}" keywords="${triggerKws.join(',')}">\n${lines.join('\n')}\n</triggered-context>\n`);
+                            emitContext(`\n<triggered-context project="${project ?? 'global'}" keywords="${triggerKws.join(',')}">\n${lines.join('\n')}\n</triggered-context>\n`, 'UserPromptSubmit', input.transcript_path);
                         }
                     }
                 }

package/dist/utils/logger.d.ts

@@ -25,4 +25,21 @@ export declare const logger: Logger;
  * 로그 위치: $HOOK_ERROR_LOG > cwd/.claude/hook-errors.log > ~/.claude/hook-errors.log
  */
 export declare function logHookError(hook: string, err: unknown): void;
+/**
+ * Detect whether the hook is running under OpenAI Codex CLI (vs Claude Code).
+ *
+ * Two signals (either is sufficient):
+ *  1. A "--codex" argv marker injected by our installer into ~/.codex/hooks.json.
+ *     This is the reliable signal — Codex passes transcript_path as null at
+ *     SessionStart (fresh session, rollout not yet written), so path alone fails.
+ *  2. Transcript path under ~/.codex/sessions/...rollout-*.jsonl (fallback for
+ *     Stop/UserPromptSubmit where the rollout already exists).
+ */
+export declare function isCodexHost(transcriptPath?: string): boolean;
+/**
+ * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * - Claude Code injects raw stdout text directly.
+ * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ */
+export declare function emitContext(context: string, hookEventName: string, transcriptPath?: string): void;
 export {};

package/dist/utils/logger.js

@@ -138,3 +138,35 @@ export function logHookError(hook, err) {
     }
     catch { /* never throw from the error logger */ }
 }
+/**
+ * Detect whether the hook is running under OpenAI Codex CLI (vs Claude Code).
+ *
+ * Two signals (either is sufficient):
+ *  1. A "--codex" argv marker injected by our installer into ~/.codex/hooks.json.
+ *     This is the reliable signal — Codex passes transcript_path as null at
+ *     SessionStart (fresh session, rollout not yet written), so path alone fails.
+ *  2. Transcript path under ~/.codex/sessions/...rollout-*.jsonl (fallback for
+ *     Stop/UserPromptSubmit where the rollout already exists).
+ */
+export function isCodexHost(transcriptPath) {
+    if (process.argv.includes('--codex'))
+        return true;
+    if (!transcriptPath)
+        return false;
+    return transcriptPath.includes('/.codex/sessions/') || /rollout-.*\.jsonl$/.test(transcriptPath);
+}
+/**
+ * Emit context to stdout in the host's expected format (Codex support, 2026-07-09).
+ * - Claude Code injects raw stdout text directly.
+ * - Codex CLI expects {hookSpecificOutput:{hookEventName, additionalContext}}.
+ */
+export function emitContext(context, hookEventName, transcriptPath) {
+    if (isCodexHost(transcriptPath)) {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: { hookEventName, additionalContext: context },
+        }));
+    }
+    else {
+        console.log(context);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-session-continuity-mcp",
-  "version": "1.15.1",
+  "version": "1.16.0",
   "description": "Session Continuity for Claude Code - Never re-explain your project again",
   "type": "module",
   "main": "dist/index.js",