clideck 1.26.3 → 1.27.1

package/server.js

@@ -88,6 +88,65 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  // Codex notify hook endpoint — deterministic turn-complete signal
+  if (req.method === 'POST' && req.url === '/hook/codex/stop') {
+    let body = '';
+    req.on('data', chunk => { body += chunk; if (body.length > 1e5) req.destroy(); });
+    req.on('end', () => {
+      try {
+        const payload = JSON.parse(body);
+        const threadId = payload['thread-id'];
+        // console.log(`[codex] hook received thread=${threadId ? threadId.slice(0,8) : 'none'}`);
+        if (threadId) {
+          const allSessions = sessions.getSessions();
+          for (const [id, s] of allSessions) {
+            if (s.sessionToken === threadId) {
+              // console.log(`[codex] hook stop session=${id.slice(0,8)} thread=${threadId.slice(0,8)}`);
+              sessions.broadcast({ type: 'session.status', id, working: false, source: 'hook' });
+              break;
+            }
+          }
+          // if (!matched) console.log(`[codex] hook no session match for thread=${threadId.slice(0,8)}`);
+        }
+      } catch {}
+      res.writeHead(200).end('{}');
+    });
+    return;
+  }
+
+  // Claude Code hook endpoints — deterministic start/stop/idle signals
+  if (req.method === 'POST' && req.url.startsWith('/hook/claude/')) {
+    let body = '';
+    req.on('data', chunk => { body += chunk; if (body.length > 1e5) req.destroy(); });
+    req.on('end', () => {
+      try {
+        const payload = JSON.parse(body);
+        const route = req.url.slice('/hook/claude/'.length);
+        const sessionId = payload.session_id;
+        // console.log(`[claude] hook ${route} session=${sessionId?.slice(0,8) || '?'}`);
+        if (sessionId) {
+          const allSessions = sessions.getSessions();
+          let clideckId = null;
+          for (const [id, s] of allSessions) {
+            if (s.sessionToken === sessionId) { clideckId = id; break; }
+          }
+          if (clideckId) {
+            if (route === 'start') {
+              sessions.broadcast({ type: 'session.status', id: clideckId, working: true, source: 'hook' });
+            } else if (route === 'stop' || route === 'idle') {
+              sessions.broadcast({ type: 'session.status', id: clideckId, working: false, source: 'hook' });
+            } else if (route === 'menu') {
+              // PreToolUse: trigger screen capture — detectMenu will set idle if a choice menu is visible
+              setTimeout(() => sessions.broadcast({ type: 'screen.capture', id: clideckId }), 500);
+            }
+          }
+        }
+      } catch {}
+      res.writeHead(200).end('{}');
+    });
+    return;
+  }
+
   // OpenCode plugin bridge events
   if (req.method === 'POST' && req.url === '/opencode-events') {
     let body = '';
@@ -125,7 +184,18 @@ const server = http.createServer((req, res) => {
   } catch { res.writeHead(500).end(); }
 });
 
-const wss = new WebSocketServer({ server });
+const allowedOrigins = new Set([
+  `http://localhost:${PORT}`, `http://127.0.0.1:${PORT}`,
+  `http://[::1]:${PORT}`, `http://${HOST}:${PORT}`,
+]);
+const wss = new WebSocketServer({
+  server,
+  verifyClient: ({ req }) => {
+    const origin = req.headers.origin;
+    if (!origin) return true;            // non-browser clients (curl, etc.)
+    return allowedOrigins.has(origin);
+  },
+});
 wss.on('connection', onConnection);
 
 const activity = require('./activity');

package/sessions.js

@@ -277,10 +277,16 @@ function input(msg) {
   activity.trackIn(msg.id, data.length);
   transcript.trackInput(msg.id, data);
   sessions.get(msg.id)?.pty.write(data);
-  if (data === '\x1b') {
-    const s = sessions.get(msg.id);
-    // console.log(`[esc] session=${msg.id.slice(0,8)} working=${s?.working}`);
-    if (s?.working) telemetry.startEscIdle(msg.id);
+  const s = sessions.get(msg.id);
+  if (!s) return;
+  // Menu choice selected → back to working (Enter or digit keys only)
+  if (s._menuKey && !s.working && (data === '\r' || /^[1-9]$/.test(data))) {
+    s._menuKey = '';
+    broadcast({ type: 'session.menu', id: msg.id, choices: [] });
+    broadcast({ type: 'session.status', id: msg.id, working: true, source: 'menu-input' });
+  }
+  if (data === '\x1b' && s.working) {
+    telemetry.startEscIdle(msg.id);
   }
 }
 function resize(msg) { sessions.get(msg.id)?.pty.resize(msg.cols, msg.rows); }
@@ -315,15 +321,14 @@ function close(msg, cfg) {
 // Uses resume command if available, otherwise re-launches the original command.
 function restart(msg, ws, cfg) {
   const id = msg.id;
-  console.log('[restart] received', { id, themeId: msg.themeId });
+  // console.log('[restart] received', { id, themeId: msg.themeId });
   const s = sessions.get(id);
-  if (!s) { console.log('[restart] FAIL: session not found'); ws.send(JSON.stringify({ type: 'session.restarted', id, error: 'not found' })); return; }
+  if (!s) { ws.send(JSON.stringify({ type: 'session.restarted', id, error: 'not found' })); return; }
   const cmd = cfg.commands.find(c => c.id === s.commandId);
-  if (!cmd) { console.log('[restart] FAIL: command not found, commandId=', s.commandId); ws.send(JSON.stringify({ type: 'session.restarted', id, error: 'command missing' })); return; }
+  if (!cmd) { ws.send(JSON.stringify({ type: 'session.restarted', id, error: 'command missing' })); return; }
 
   const themeId = msg.themeId || s.themeId;
   const canResume = cmd.canResume && cmd.resumeCommand && s.sessionToken;
-  console.log('[restart] canResume=', canResume, 'token=', s.sessionToken?.slice(0,12), 'cmd=', cmd.command);
 
   let parts;
   if (canResume) {
@@ -331,7 +336,6 @@ function restart(msg, ws, cfg) {
   } else {
     parts = parseCommand(cmd.command);
   }
-  console.log('[restart] parts=', parts);
 
   const savedToken = s.sessionToken;
   const { name, cwd, commandId, projectId } = s;
@@ -341,19 +345,16 @@ function restart(msg, ws, cfg) {
   opencodeBridge.clear(id);
   transcript.clear(id);
 
-  console.log('[restart] killing old pty');
   s.pty.kill();
   sessions.delete(id);
 
-  console.log('[restart] spawning new pty, themeId=', themeId, 'cwd=', cwd);
   const err = spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken, projectId, msg.cols, msg.rows);
   if (err) {
-    console.error('[restart] FAIL spawn:', err.message);
+    console.error('[restart] spawn failed:', err.message);
     broadcast({ type: 'session.restarted', id, error: err.message });
     return;
   }
 
-  console.log('[restart] SUCCESS, broadcasting session.restarted');
   broadcast({ type: 'session.restarted', id, resumed: !!canResume });
 }
 

package/telemetry-receiver.js

@@ -4,8 +4,10 @@
 
 const ioActivity = require('./activity');
 const activity = new Map(); // sessionId → has received events
+const lastEvent = new Map(); // sessionId → last OTEL event name (+ kind)
 const pendingSetup = new Map(); // sessionId → timer (waiting for first event)
 const pendingIdle = new Map(); // sessionId → timer (PTY silence → idle)
+const codexMenuPoll = new Map(); // sessionId → interval (polling for menu after response.completed)
 const escPendingIdle = new Map(); // sessionId → timer (Esc interrupt → confirm idle after output silence)
 const escSuppressUntil = new Map(); // sessionId → ts (briefly ignore telemetry reassertions after Esc)
 let broadcastFn = null;
@@ -74,18 +76,40 @@ function handleLogs(req, res) {
 
         // Debug telemetry logs — uncomment as needed, do not delete
         // if (serviceName === 'claude-code' && eventName) console.log(`[telemetry:claude] ${eventName}`);
-        // if (serviceName === 'codex_cli_rs' && eventName) console.log(`[telemetry:codex] ${eventName} session=${resolvedId.slice(0,8)} working=${sessionsFn?.()?.get(resolvedId)?.working}`);
+        // if (serviceName === 'codex_cli_rs' && eventName) console.log(`[telemetry:codex] ${eventName} ${attrs['event.kind'] ? 'kind=' + attrs['event.kind'] : ''} ${attrs['tool'] ? 'tool=' + attrs['tool'] : ''} session=${resolvedId.slice(0,8)}`);
         // if (serviceName === 'gemini-cli' && eventName) console.log(`[telemetry:gemini] ${eventName}`);
 
-        // Status: user_prompt → working + start PTY silence monitor for idle
-        const startEvents = new Set(['user_prompt', 'gemini_cli.user_prompt', 'codex.user_prompt']);
+        // Track last event per session (used by menu detection validation)
+        if (eventName) lastEvent.set(resolvedId, eventName + (attrs['event.kind'] ? ':' + attrs['event.kind'] : ''));
+
+        // Status: user_prompt → working
+        // Claude uses hooks; Codex uses notify hook; Gemini uses PTY heuristic
+        const startEvents = new Set(['gemini_cli.user_prompt', 'codex.user_prompt']);
         if (startEvents.has(eventName)) {
           cancelPendingIdle(resolvedId);
           broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
-          startPendingIdle(resolvedId, serviceName);
+          // Gemini uses PTY silence heuristic for idle; Codex idle comes from notify hook
+          if (serviceName !== 'codex_cli_rs') startPendingIdle(resolvedId, serviceName);
+        }
+
+        // Codex: response.completed → poll for menu until found or timeout
+        if (eventName === 'codex.sse_event' && attrs['event.kind'] === 'response.completed') {
+          startCodexMenuPoll(resolvedId);
+        }
+        // Codex: tool_decision → user approved, cancel menu poll, back to working
+        if (eventName === 'codex.tool_decision') {
+          cancelCodexMenuPoll(resolvedId);
+          broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
+        }
+        // Codex: user_prompt or next sse_event cancels menu poll
+        if ((eventName === 'codex.user_prompt' || (eventName === 'codex.sse_event' && attrs['event.kind'] !== 'response.completed'))) {
+          cancelCodexMenuPoll(resolvedId);
         }
 
-        const agentSessionId = attrs['session.id'] || attrs['conversation.id'];
+        // Codex: use conversation.id (maps to thread-id in notify hook)
+        const agentSessionId = serviceName === 'codex_cli_rs'
+          ? attrs['conversation.id']
+          : (attrs['session.id'] || attrs['conversation.id']);
         if (agentSessionId && sess) {
           // Prefer interactive session ID (Gemini sends non-interactive init events first)
           const dominated = sess.sessionToken && attrs['interactive'] === true;
@@ -124,16 +148,12 @@ function cancelPendingSetup(sessionId) {
 }
 
 // PTY activity monitor: 2s silent → idle, 2s active or user_prompt → working.
+// Used by Gemini only — Claude uses hooks, Codex uses sse_event completion.
 // Agent working indicators in PTY output.
-const CLAUDE_WORKING_RE = /[✳✽✢✻·]|Working…|thinking/;
-const CODEX_WORKING_RE = /Working|•/;
 const GEMINI_WORKING_RE = /[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/;
 
 function startPendingIdle(id, agent) {
   if (pendingIdle.has(id)) return; // already monitoring
-  const isClaude = agent === 'claude-code';
-  const isCodex = agent === 'codex_cli_rs';
-  const isGemini = agent === 'gemini-cli';
   let isIdle = false;
   let activeStart = 0;
   const check = setInterval(() => {
@@ -145,9 +165,7 @@ function startPendingIdle(id, agent) {
     // Agent override: if recent output has spinner/working chars, not silent
     if (silent && (Date.now() - lastOut) < 2000) {
       const chunk = ioActivity.lastChunk(id);
-      if (isClaude && CLAUDE_WORKING_RE.test(chunk)) silent = false;
-      if (isCodex && CODEX_WORKING_RE.test(chunk)) silent = false;
-      if (isGemini && GEMINI_WORKING_RE.test(chunk)) silent = false;
+      if (GEMINI_WORKING_RE.test(chunk)) silent = false;
     }
     if (silent && !isIdle) {
       isIdle = true;
@@ -171,6 +189,22 @@ function cancelPendingIdle(id) {
   if (timer) { clearInterval(timer); pendingIdle.delete(id); }
 }
 
+// Codex: after response.completed, poll screen capture every 500ms for up to 3s
+function startCodexMenuPoll(id) {
+  cancelCodexMenuPoll(id);
+  const started = Date.now();
+  const poll = setInterval(() => {
+    if (Date.now() - started > 3000) { cancelCodexMenuPoll(id); return; }
+    broadcastFn?.({ type: 'screen.capture', id });
+  }, 500);
+  codexMenuPoll.set(id, poll);
+}
+
+function cancelCodexMenuPoll(id) {
+  const timer = codexMenuPoll.get(id);
+  if (timer) { clearInterval(timer); codexMenuPoll.delete(id); }
+}
+
 function startEscIdle(id) {
   cancelEscIdle(id);
   const started = Date.now();
@@ -202,16 +236,20 @@ function cancelEscIdle(id) {
 
 function clear(id) {
   activity.delete(id);
+  lastEvent.delete(id);
   cancelPendingIdle(id);
+  cancelCodexMenuPoll(id);
   cancelEscIdle(id);
   escSuppressUntil.delete(id);
   const pending = pendingSetup.get(id);
   if (pending) { clearTimeout(pending.timer); pendingSetup.delete(id); }
 }
 
+function getLastEvent(id) { return lastEvent.get(id) || ''; }
+
 // Returns true if we've received telemetry events for this session
 function hasEvents(id) {
   return activity.has(id);
 }
 
-module.exports = { init, handleLogs, clear, hasEvents, watchSession, startPendingIdle, startEscIdle };
+module.exports = { init, handleLogs, clear, hasEvents, getLastEvent, cancelCodexMenuPoll, watchSession, startPendingIdle, startEscIdle };

package/transcript.js

@@ -321,16 +321,18 @@ const MENU_CHOICE_RE = /^\s*(?:[│❯›●•]\s+)*(\d+)\.\s+(.+)$/;
 function detectMenu(lines, presetId) {
   const marker = MENU_MARKERS[presetId];
   if (!marker) return null;
+  // Only scan the bottom 40 lines — menus are always near the visible area
+  const scanStart = Math.max(0, lines.length - 40);
   let footerIdx = -1;
-  for (let i = lines.length - 1; i >= 0; i--) {
+  for (let i = lines.length - 1; i >= scanStart; i--) {
     if (/\besc\b|\(esc\)/i.test(lines[i])) { footerIdx = MENU_CHOICE_RE.test(lines[i]) ? i + 1 : i; break; }
   }
   if (footerIdx < 0) return null;
   const choices = [];
-  for (let i = footerIdx - 1; i >= 0; i--) {
+  for (let i = footerIdx - 1; i >= scanStart; i--) {
     if (!lines[i].trim() || /^[│\s]+$/.test(lines[i])) continue;
     const m = lines[i].match(MENU_CHOICE_RE);
-    if (!m) break;
+    if (!m) { if (/^\s{2,}\S/.test(lines[i])) continue; break; }
     if (choices.length && +m[1] >= +choices[0].value) break;
     choices.unshift({ value: m[1], label: m[2].trim(), selected: marker.test(lines[i]) });
   }