oh-my-codex 0.2.0 → 0.2.2

package/scripts/notify-fallback-watcher.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'fs';
+import { appendFile, mkdir, readFile, readdir, stat, writeFile } from 'fs/promises';
+import { spawnSync } from 'child_process';
+import { dirname, join, resolve } from 'path';
+import { homedir } from 'os';
+
+function argValue(name, fallback = '') {
+  const idx = process.argv.indexOf(name);
+  if (idx < 0 || idx + 1 >= process.argv.length) return fallback;
+  return process.argv[idx + 1];
+}
+
+const cwd = resolve(argValue('--cwd', process.cwd()));
+const notifyScript = resolve(argValue('--notify-script', join(cwd, 'scripts', 'notify-hook.js')));
+const pollMs = Number(argValue('--poll-ms', '700')) || 700;
+const runOnce = process.argv.includes('--once');
+const startedAt = Date.now();
+const fileWindowMs = runOnce ? 15000 : 30000;
+
+const omxDir = join(cwd, '.omx');
+const logsDir = join(omxDir, 'logs');
+const stateDir = join(omxDir, 'state');
+const statePath = join(stateDir, 'notify-fallback-state.json');
+const logPath = join(logsDir, `notify-fallback-${new Date().toISOString().split('T')[0]}.jsonl`);
+
+const fileState = new Map();
+const seenTurnKeys = new Set();
+let stopping = false;
+
+function safeString(v) {
+  return typeof v === 'string' ? v : '';
+}
+
+function eventLog(event) {
+  return appendFile(logPath, `${JSON.stringify({ timestamp: new Date().toISOString(), ...event })}\n`).catch(() => {});
+}
+
+function sessionDirs() {
+  const now = new Date();
+  const today = join(
+    homedir(),
+    '.codex',
+    'sessions',
+    String(now.getUTCFullYear()),
+    String(now.getUTCMonth() + 1).padStart(2, '0'),
+    String(now.getUTCDate()).padStart(2, '0')
+  );
+  const yesterdayDate = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+  const yesterday = join(
+    homedir(),
+    '.codex',
+    'sessions',
+    String(yesterdayDate.getUTCFullYear()),
+    String(yesterdayDate.getUTCMonth() + 1).padStart(2, '0'),
+    String(yesterdayDate.getUTCDate()).padStart(2, '0')
+  );
+  return Array.from(new Set([today, yesterday]));
+}
+
+async function readFirstLine(path) {
+  const content = await readFile(path, 'utf-8');
+  const idx = content.indexOf('\n');
+  return idx >= 0 ? content.slice(0, idx) : content;
+}
+
+function shouldTrackSessionMeta(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!parsed || parsed.type !== 'session_meta' || !parsed.payload) return null;
+  const payload = parsed.payload;
+  if (safeString(payload.cwd) !== cwd) return null;
+  const threadId = safeString(payload.id);
+  return threadId || null;
+}
+
+async function discoverRolloutFiles() {
+  const discovered = [];
+  for (const dir of sessionDirs()) {
+    if (!existsSync(dir)) continue;
+    const names = await readdir(dir).catch(() => []);
+    for (const name of names) {
+      if (!name.startsWith('rollout-') || !name.endsWith('.jsonl')) continue;
+      const path = join(dir, name);
+      const st = await stat(path).catch(() => null);
+      if (!st) continue;
+      if (st.mtimeMs < startedAt - fileWindowMs) continue;
+      discovered.push(path);
+    }
+  }
+  discovered.sort();
+  return discovered;
+}
+
+function turnKey(threadId, turnId) {
+  return `${threadId || 'no-thread'}|${turnId || 'no-turn'}`;
+}
+
+function buildNotifyPayload(threadId, turnId, lastMessage) {
+  return {
+    type: 'agent-turn-complete',
+    cwd,
+    'thread-id': threadId,
+    'turn-id': turnId,
+    'input-messages': ['[notify-fallback] synthesized from rollout task_complete'],
+    'last-assistant-message': lastMessage || '',
+    source: 'notify-fallback-watcher',
+  };
+}
+
+async function invokeNotifyHook(payload, filePath) {
+  const result = spawnSync(process.execPath, [notifyScript, JSON.stringify(payload)], {
+    cwd,
+    encoding: 'utf-8',
+  });
+  const ok = result.status === 0;
+  await eventLog({
+    type: 'fallback_notify',
+    ok,
+    thread_id: payload['thread-id'],
+    turn_id: payload['turn-id'],
+    file: filePath,
+    reason: ok ? 'sent' : 'notify_hook_failed',
+    error: ok ? undefined : (result.stderr || result.stdout || '').trim().slice(0, 240),
+  });
+}
+
+async function processLine(meta, line, filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (!parsed || parsed.type !== 'event_msg' || !parsed.payload) return;
+  if (parsed.payload.type !== 'task_complete') return;
+
+  const turnId = safeString(parsed.payload.turn_id);
+  if (!turnId) return;
+
+  const evtTs = Date.parse(safeString(parsed.timestamp));
+  if (Number.isFinite(evtTs) && evtTs < startedAt - 3000) return;
+
+  const key = turnKey(meta.threadId, turnId);
+  if (seenTurnKeys.has(key)) return;
+  seenTurnKeys.add(key);
+
+  const payload = buildNotifyPayload(
+    meta.threadId,
+    turnId,
+    safeString(parsed.payload.last_agent_message)
+  );
+  await invokeNotifyHook(payload, filePath);
+}
+
+async function ensureTrackedFiles() {
+  const files = await discoverRolloutFiles();
+  for (const path of files) {
+    if (fileState.has(path)) continue;
+    const line = await readFirstLine(path).catch(() => '');
+    const threadId = shouldTrackSessionMeta(line);
+    if (!threadId) continue;
+    const size = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    // In streaming mode, tail from current EOF to avoid replaying old events.
+    // In one-shot mode, read from start to catch just-finished turns.
+    const offset = runOnce ? 0 : size;
+    fileState.set(path, { threadId, offset, size, partial: '' });
+  }
+}
+
+async function pollFiles() {
+  for (const [path, meta] of fileState.entries()) {
+    const currentSize = (await stat(path).catch(() => ({ size: 0 }))).size || 0;
+    if (currentSize <= meta.offset) continue;
+    const content = await readFile(path, 'utf-8').catch(() => '');
+    if (!content) continue;
+    const delta = content.slice(meta.offset);
+    meta.offset = currentSize;
+    const merged = meta.partial + delta;
+    const lines = merged.split('\n');
+    meta.partial = lines.pop() || '';
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      await processLine(meta, line, path);
+    }
+  }
+}
+
+async function writeState() {
+  await mkdir(stateDir, { recursive: true }).catch(() => {});
+  const state = {
+    pid: process.pid,
+    started_at: new Date(startedAt).toISOString(),
+    cwd,
+    notify_script: notifyScript,
+    poll_ms: pollMs,
+    tracked_files: fileState.size,
+    seen_turns: seenTurnKeys.size,
+  };
+  await writeFile(statePath, JSON.stringify(state, null, 2)).catch(() => {});
+}
+
+async function tick() {
+  if (stopping) return;
+  await ensureTrackedFiles();
+  await pollFiles();
+  await writeState();
+  setTimeout(tick, pollMs);
+}
+
+function shutdown(signal) {
+  stopping = true;
+  eventLog({ type: 'watcher_stop', signal }).finally(() => process.exit(0));
+}
+
+async function main() {
+  await mkdir(logsDir, { recursive: true }).catch(() => {});
+  await mkdir(stateDir, { recursive: true }).catch(() => {});
+  if (!existsSync(notifyScript)) {
+    await eventLog({ type: 'watcher_error', reason: 'notify_script_missing', notify_script: notifyScript });
+    process.exit(1);
+  }
+
+  await eventLog({
+    type: 'watcher_start',
+    cwd,
+    notify_script: notifyScript,
+    poll_ms: pollMs,
+    once: runOnce,
+  });
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+  process.on('SIGHUP', () => shutdown('SIGHUP'));
+
+  if (runOnce) {
+    await ensureTrackedFiles();
+    await pollFiles();
+    await writeState();
+    await eventLog({ type: 'watcher_once_complete', seen_turns: seenTurnKeys.size });
+    process.exit(0);
+  }
+
+  await tick();
+}
+
+main().catch(async (err) => {
+  await mkdir(dirname(logPath), { recursive: true }).catch(() => {});
+  await eventLog({
+    type: 'watcher_error',
+    reason: 'fatal',
+    error: err instanceof Error ? err.message : safeString(err),
+  });
+  process.exit(1);
+});

package/scripts/notify-hook.js

@@ -13,7 +13,7 @@
  */
 
 import { writeFile, appendFile, mkdir, readFile } from 'fs/promises';
-import { join } from 'path';
+import { join, resolve as resolvePath } from 'path';
 import { existsSync } from 'fs';
 import { spawn } from 'child_process';
 import {
@@ -173,6 +173,7 @@ function normalizeTmuxState(raw) {
   if (!raw || typeof raw !== 'object') {
     return {
       total_injections: 0,
+      pane_counts: {},
       session_counts: {},
       recent_keys: {},
       last_injection_ts: 0,
@@ -182,6 +183,7 @@ function normalizeTmuxState(raw) {
   }
   return {
     total_injections: asNumber(raw.total_injections) ?? 0,
+    pane_counts: raw.pane_counts && typeof raw.pane_counts === 'object' ? raw.pane_counts : {},
     session_counts: raw.session_counts && typeof raw.session_counts === 'object' ? raw.session_counts : {},
     recent_keys: raw.recent_keys && typeof raw.recent_keys === 'object' ? raw.recent_keys : {},
     last_injection_ts: asNumber(raw.last_injection_ts) ?? 0,
@@ -190,6 +192,30 @@ function normalizeTmuxState(raw) {
   };
 }
 
+function normalizeNotifyState(raw) {
+  if (!raw || typeof raw !== 'object') {
+    return {
+      recent_turns: {},
+      last_event_at: '',
+    };
+  }
+  return {
+    recent_turns: raw.recent_turns && typeof raw.recent_turns === 'object' ? raw.recent_turns : {},
+    last_event_at: safeString(raw.last_event_at),
+  };
+}
+
+function pruneRecentTurns(recentTurns, now) {
+  const pruned = {};
+  const minTs = now - (24 * 60 * 60 * 1000);
+  const entries = Object.entries(recentTurns || {}).slice(-2000);
+  for (const [key, value] of entries) {
+    const ts = asNumber(value);
+    if (ts !== null && ts >= minTs) pruned[key] = ts;
+  }
+  return pruned;
+}
+
 function pruneRecentKeys(recentKeys, now) {
   const pruned = {};
   const minTs = now - (24 * 60 * 60 * 1000);
@@ -246,22 +272,140 @@ function runProcess(command, args, timeoutMs = 3000) {
   });
 }
 
-async function resolvePaneTarget(target) {
-  if (!target) return null;
-  if (target.type === 'pane') return target.value;
+async function resolveSessionToPane(sessionName) {
+  const result = await runProcess('tmux', ['list-panes', '-t', sessionName, '-F', '#{pane_id} #{pane_active}']);
+  const lines = result.stdout
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean);
+  if (lines.length === 0) return null;
+  const active = lines.find(line => line.endsWith(' 1')) || lines[0];
+  const paneId = active.split(' ')[0];
+  return paneId || null;
+}
+
+async function resolvePaneByCwd(expectedCwd) {
+  if (!expectedCwd) return null;
+  const result = await runProcess('tmux', ['list-panes', '-a', '-F', '#{pane_id}\t#{pane_current_path}\t#{pane_active}\t#{session_name}']);
+  const lines = result.stdout
+    .split('\n')
+    .map(line => line.trim())
+    .filter(Boolean);
+
+  const expected = resolvePath(expectedCwd);
+  const candidates = [];
+  for (const line of lines) {
+    const parts = line.split('\t');
+    if (parts.length < 4) continue;
+    const [paneId, paneCwd, activeRaw, sessionName] = parts;
+    if (!paneId || !paneCwd) continue;
+    if (resolvePath(paneCwd) !== expected) continue;
+    const active = activeRaw === '1';
+    candidates.push({ paneId, paneCwd, active, sessionName: sessionName || null });
+  }
+  if (candidates.length === 0) return null;
+
+  const pick = candidates.find(c => c.active) || candidates[0];
+  return pick;
+}
+
+async function resolvePaneTarget(target, fallbackPane, expectedCwd, modePane) {
+  if (modePane) {
+    try {
+      const modePaneResult = await runProcess('tmux', ['display-message', '-p', '-t', modePane, '#{pane_id}']);
+      const paneId = safeString(modePaneResult.stdout).trim();
+      if (paneId) {
+        if (expectedCwd) {
+          const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
+          const paneCwd = safeString(paneCwdResult.stdout).trim();
+          if (!paneCwd || resolvePath(paneCwd) === resolvePath(expectedCwd)) {
+            const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
+            const sessionName = safeString(currentSession.stdout).trim();
+            return {
+              paneTarget: paneId,
+              reason: 'fallback_mode_state_pane',
+              matched_session: sessionName || null,
+            };
+          }
+        } else {
+          const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
+          const sessionName = safeString(currentSession.stdout).trim();
+          return {
+            paneTarget: paneId,
+            reason: 'fallback_mode_state_pane',
+            matched_session: sessionName || null,
+          };
+        }
+      }
+    } catch {
+      // Fall through to config/fallback probes
+    }
+  }
+
+  if (!target) return { paneTarget: null, reason: 'invalid_target' };
+
+  if (target.type === 'pane') {
+    try {
+      const result = await runProcess('tmux', ['display-message', '-p', '-t', target.value, '#{pane_id}']);
+      const paneId = safeString(result.stdout).trim();
+      if (paneId) return { paneTarget: paneId, reason: 'ok' };
+    } catch {
+      // Fall through to fallback probe
+    }
+  } else {
+    try {
+      const paneId = await resolveSessionToPane(target.value);
+      if (paneId) return { paneTarget: paneId, reason: 'ok' };
+    } catch {
+      // Fall through to fallback probe
+    }
+  }
+
+  if (fallbackPane) {
+    try {
+      const currentPane = await runProcess('tmux', ['display-message', '-p', '-t', fallbackPane, '#{pane_id}']);
+      const paneId = safeString(currentPane.stdout).trim();
+      if (paneId) {
+        if (expectedCwd) {
+          const paneCwdResult = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#{pane_current_path}']);
+          const paneCwd = safeString(paneCwdResult.stdout).trim();
+          if (paneCwd && resolvePath(paneCwd) !== resolvePath(expectedCwd)) {
+            return {
+              paneTarget: null,
+              reason: 'pane_cwd_mismatch',
+              pane_cwd: paneCwd,
+              expected_cwd: expectedCwd,
+            };
+          }
+        }
+
+        const currentSession = await runProcess('tmux', ['display-message', '-p', '-t', paneId, '#S']);
+        const sessionName = safeString(currentSession.stdout).trim();
+        return {
+          paneTarget: paneId,
+          reason: 'fallback_current_pane',
+          matched_session: sessionName || null,
+        };
+      }
+    } catch {
+      // Fall through
+    }
+  }
+
   try {
-    const result = await runProcess('tmux', ['list-panes', '-t', target.value, '-F', '#{pane_id} #{pane_active}']);
-    const lines = result.stdout
-      .split('\n')
-      .map(line => line.trim())
-      .filter(Boolean);
-    if (lines.length === 0) return null;
-    const active = lines.find(line => line.endsWith(' 1')) || lines[0];
-    const paneId = active.split(' ')[0];
-    return paneId || null;
+    const match = await resolvePaneByCwd(expectedCwd);
+    if (match && match.paneId) {
+      return {
+        paneTarget: match.paneId,
+        reason: 'fallback_pane_by_cwd',
+        matched_session: match.sessionName,
+      };
+    }
   } catch {
-    return null;
+    // Fall through
   }
+
+  return { paneTarget: null, reason: 'target_not_found' };
 }
 
 async function logTmuxHookEvent(logsDir, event) {
@@ -310,6 +454,7 @@ async function handleTmuxInjection({
   state.recent_keys = pruneRecentKeys(state.recent_keys, now);
 
   const activeModes = [];
+  const activeModeStates = {};
   try {
     const scopedDirs = await getScopedStateDirsForCurrentSession(stateDir);
     for (const scopedDir of scopedDirs) {
@@ -319,7 +464,9 @@ async function handleTmuxInjection({
         const path = join(scopedDir, file);
         const parsed = JSON.parse(await readFile(path, 'utf-8'));
         if (parsed && parsed.active) {
-          activeModes.push(file.replace('-state.json', ''));
+          const modeName = file.replace('-state.json', '');
+          activeModes.push(modeName);
+          activeModeStates[modeName] = parsed;
         }
       }
     }
@@ -328,7 +475,9 @@ async function handleTmuxInjection({
   }
 
   const mode = pickActiveMode(activeModes, config.allowed_modes);
-  const guard = evaluateInjectionGuards({
+  const modeState = mode ? (activeModeStates[mode] || {}) : {};
+  const modePane = safeString(modeState.tmux_pane_id || '');
+  const preGuard = evaluateInjectionGuards({
     config,
     mode,
     sourceText,
@@ -336,6 +485,7 @@ async function handleTmuxInjection({
     threadId,
     turnId,
     sessionKey,
+    skipQuotaChecks: true,
     now,
     state,
   });
@@ -344,7 +494,7 @@ async function handleTmuxInjection({
     timestamp: nowIso,
     type: 'tmux_hook',
     mode,
-    reason: guard.reason,
+    reason: preGuard.reason,
     turn_id: turnId,
     thread_id: threadId,
     target: config.target,
@@ -352,8 +502,8 @@ async function handleTmuxInjection({
     sent: false,
   };
 
-  if (!guard.allow) {
-    state.last_reason = guard.reason;
+  if (!preGuard.allow) {
+    state.last_reason = preGuard.reason;
     state.last_event_at = nowIso;
     await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
     if (config.enabled || config.log_level === 'debug') {
@@ -368,15 +518,65 @@ async function handleTmuxInjection({
     turnId,
     timestamp: nowIso,
   });
-  const paneTarget = await resolvePaneTarget(config.target);
-  if (!paneTarget) {
-    state.last_reason = 'target_not_found';
+  const fallbackPane = safeString(process.env.TMUX_PANE || '');
+  const resolution = await resolvePaneTarget(config.target, fallbackPane, cwd, modePane);
+  if (!resolution.paneTarget) {
+    state.last_reason = resolution.reason;
+    state.last_event_at = nowIso;
+    await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
+    await logTmuxHookEvent(logsDir, {
+      ...baseLog,
+      event: 'injection_skipped',
+      reason: resolution.reason,
+      pane_cwd: resolution.pane_cwd,
+      expected_cwd: resolution.expected_cwd,
+    });
+    return;
+  }
+  const paneTarget = resolution.paneTarget;
+
+  // Final guard phase: pane is canonical identity for quota/cooldown.
+  const guard = evaluateInjectionGuards({
+    config,
+    mode,
+    sourceText,
+    assistantMessage,
+    threadId,
+    turnId,
+    paneKey: paneTarget,
+    sessionKey,
+    now,
+    state,
+  });
+  if (!guard.allow) {
+    state.last_reason = guard.reason;
     state.last_event_at = nowIso;
     await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
-    await logTmuxHookEvent(logsDir, { ...baseLog, event: 'injection_skipped', reason: 'target_not_found' });
+    await logTmuxHookEvent(logsDir, { ...baseLog, event: 'injection_skipped', reason: guard.reason });
     return;
   }
 
+  // Pane-canonical healing: persist resolved pane target so routing stops depending on session names.
+  // Legacy configs with target.type="session" remain accepted but are auto-migrated on success.
+  if (config.target && config.target.type !== 'pane') {
+    try {
+      const healed = {
+        ...(rawConfig && typeof rawConfig === 'object' ? rawConfig : {}),
+        target: { type: 'pane', value: paneTarget },
+      };
+      await writeFile(configPath, JSON.stringify(healed, null, 2) + '\n');
+      await logTmuxHookEvent(logsDir, {
+        ...baseLog,
+        event: 'target_healed',
+        reason: 'migrated_to_pane_target',
+        previous_target: config.target.value,
+        healed_target: paneTarget,
+      });
+    } catch {
+      // Non-fatal
+    }
+  }
+
   const argv = buildSendKeysArgv({
     paneTarget,
     prompt,
@@ -390,7 +590,8 @@ async function handleTmuxInjection({
     if (success) {
       state.last_injection_ts = now;
       state.total_injections = (asNumber(state.total_injections) ?? 0) + 1;
-      state.session_counts[sessionKey] = (asNumber(state.session_counts[sessionKey]) ?? 0) + 1;
+      state.pane_counts = state.pane_counts && typeof state.pane_counts === 'object' ? state.pane_counts : {};
+      state.pane_counts[paneTarget] = (asNumber(state.pane_counts[paneTarget]) ?? 0) + 1;
       state.last_target = paneTarget;
       state.last_prompt_preview = prompt.slice(0, 120);
     }
@@ -410,7 +611,12 @@ async function handleTmuxInjection({
   }
 
   try {
-    await runProcess('tmux', argv, 3000);
+    await runProcess('tmux', argv.typeArgv, 3000);
+    for (const submit of argv.submitArgv) {
+      await runProcess('tmux', submit, 3000);
+      // Give the pane a moment to process the keypress; avoids occasional missed submits.
+      await new Promise(r => setTimeout(r, 25));
+    }
     updateStateForAttempt(true, 'injection_sent');
     await writeFile(hookStatePath, JSON.stringify(state, null, 2)).catch(() => {});
     await logTmuxHookEvent(logsDir, {
@@ -419,6 +625,7 @@ async function handleTmuxInjection({
       reason: 'ok',
       pane_target: paneTarget,
       sent: true,
+      argv,
     });
   } catch (err) {
     updateStateForAttempt(false, 'send_failed');
@@ -518,6 +725,29 @@ async function main() {
   await mkdir(logsDir, { recursive: true }).catch(() => {});
   await mkdir(stateDir, { recursive: true }).catch(() => {});
 
+  // Turn-level dedupe prevents double-processing when native notify and fallback
+  // watcher both emit the same completed turn.
+  try {
+    const turnId = safeString(payload['turn-id'] || payload.turn_id || '');
+    if (turnId) {
+      const now = Date.now();
+      const threadId = safeString(payload['thread-id'] || payload.thread_id || '');
+      const eventType = safeString(payload.type || 'agent-turn-complete');
+      const key = `${threadId || 'no-thread'}|${turnId}|${eventType}`;
+      const dedupeStatePath = join(stateDir, 'notify-hook-state.json');
+      const dedupeState = normalizeNotifyState(await readJsonIfExists(dedupeStatePath, null));
+      dedupeState.recent_turns = pruneRecentTurns(dedupeState.recent_turns, now);
+      if (dedupeState.recent_turns[key]) {
+        process.exit(0);
+      }
+      dedupeState.recent_turns[key] = now;
+      dedupeState.last_event_at = new Date().toISOString();
+      await writeFile(dedupeStatePath, JSON.stringify(dedupeState, null, 2)).catch(() => {});
+    }
+  } catch {
+    // Non-critical
+  }
+
   // 1. Log the turn
   const logEntry = {
     timestamp: new Date().toISOString(),