clideck 1.25.7 → 1.26.0

package/activity.js

@@ -56,6 +56,8 @@ function isActive(id) {
   return s ? (Date.now() - s.lastOutAt < 2000) : false;
 }
 
+function lastOutputAt(id) { return stream[id]?.lastOutAt || 0; }
+
 function clear(id) { delete net[id]; delete stream[id]; }
 
-module.exports = { start, stop, trackIn, trackOut, isActive, clear };
+module.exports = { start, stop, trackIn, trackOut, isActive, lastOutputAt, clear };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clideck",
-  "version": "1.25.7",
+  "version": "1.26.0",
   "description": "One screen for all your AI coding agents — run, monitor, and manage multiple CLI agents from a single browser tab",
   "main": "server.js",
   "bin": {

package/sessions.js

@@ -104,14 +104,29 @@ function spawnSession(id, cmd, parts, cwd, name, themeId, commandId, savedToken,
 
   term.onExit(() => {
     // Skip cleanup if this PTY was replaced by a restart
-    if (sessions.get(id)?.pty !== term) return;
+    const s = sessions.get(id);
+    if (s?.pty !== term) return;
     activity.clear(id);
     telemetry.clear(id);
     opencodeBridge.clear(id);
-    transcript.clear(id);
     plugins.clearStatus(id);
+    // If resumable and token captured, move to resumable list (keep transcript for search)
+    if (cmd.canResume && cmd.resumeCommand && s.sessionToken) {
+      resumable.push({
+        id, name: s.name, commandId: s.commandId, presetId: s.presetId || 'shell', cwd: s.cwd,
+        themeId: s.themeId, sessionToken: s.sessionToken, projectId: s.projectId, muted: !!s.muted,
+        lastPreview: s.lastPreview || '', lastActivityAt: s.lastActivityAt || null,
+        savedAt: new Date().toISOString(),
+      });
+      console.log(`Session ${id.slice(0, 8)}: moved to resumable on exit (token: ${s.sessionToken.slice(0, 12)}…)`);
+    } else {
+      transcript.clear(id);
+    }
     sessions.delete(id);
     broadcast({ type: 'closed', id });
+    if (cmd.canResume && s.sessionToken) {
+      broadcast({ type: 'sessions.resumable', list: getResumable() });
+    }
   });
 
   return null;

package/telemetry-receiver.js

@@ -2,8 +2,10 @@
 // CLI agents export telemetry events here; we capture agent session IDs
 // (for resume) and detect whether telemetry is configured (setup prompts).
 
+const ioActivity = require('./activity');
 const activity = new Map(); // sessionId → has received events
 const pendingSetup = new Map(); // sessionId → timer (waiting for first event)
+const pendingIdle = new Map(); // sessionId → timer (api_request → confirm idle after output silence)
 let broadcastFn = null;
 let sessionsFn = null;
 
@@ -69,36 +71,42 @@ function handleLogs(req, res) {
         const attrs = parseAttrs(lr.attributes);
 
         const eventName = attrs['event.name'];
+        // 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}`);
         // if (serviceName === 'gemini-cli' && eventName) console.log(`[telemetry:gemini] ${eventName}`);
 
         // Telemetry-based status
         const startEvents = new Set(['user_prompt', 'gemini_cli.user_prompt', 'codex.user_prompt']);
         if (startEvents.has(eventName)) {
+          cancelPendingIdle(resolvedId);
           broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
         }
-        // Claude: telemetry-only status. user_prompt/any event → working, api_request → idle.
+        // Claude: telemetry-only status. api_request → pending idle (confirm after 1s output silence, expire after 6s).
         if (serviceName === 'claude-code' && eventName) {
           if (eventName === 'api_request') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: false, source: 'telemetry' });
+            startPendingIdle(resolvedId);
           } else if (eventName !== 'user_prompt') {
+            cancelPendingIdle(resolvedId);
             broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
           }
         }
-        // Codex: telemetry-only status. codex.user_prompt/any event → working, codex.sse_event → idle.
+        // Codex: codex.sse_event → pending idle (2s PTY silence), other events → working.
         if (serviceName === 'codex_cli_rs' && eventName) {
           if (eventName === 'codex.sse_event') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: false, source: 'telemetry' });
+            startPendingIdle(resolvedId);
           } else if (eventName !== 'codex.user_prompt') {
+            cancelPendingIdle(resolvedId);
             broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
           }
         }
-        // Gemini: telemetry-only status. Whitelisted events → working, api_response (role=main) → idle.
+        // Gemini: api_response (role=main) → pending idle (2s PTY silence), whitelisted events → working.
         if (serviceName === 'gemini-cli' && eventName) {
           if (eventName === 'gemini_cli.api_response' && attrs['role'] === 'main') {
-            broadcastFn?.({ type: 'session.status', id: resolvedId, working: false, source: 'telemetry' });
+            startPendingIdle(resolvedId);
           } else if (eventName === 'gemini_cli.api_request' || eventName === 'gemini_cli.model_routing'
             || (eventName === 'gemini_cli.api_response' && attrs['role'] !== 'main')) {
+            cancelPendingIdle(resolvedId);
             broadcastFn?.({ type: 'session.status', id: resolvedId, working: true, source: 'telemetry' });
           }
         }
@@ -142,8 +150,27 @@ function cancelPendingSetup(sessionId) {
   }
 }
 
+// Pending idle: starts a check loop. Confirm idle after 2s of PTY output silence.
+function startPendingIdle(id) {
+  cancelPendingIdle(id);
+  const started = Date.now();
+  const check = setInterval(() => {
+    if (Date.now() - Math.max(started, ioActivity.lastOutputAt(id)) >= 2000) {
+      cancelPendingIdle(id);
+      broadcastFn?.({ type: 'session.status', id, working: false, source: 'telemetry' });
+    }
+  }, 250);
+  pendingIdle.set(id, check);
+}
+
+function cancelPendingIdle(id) {
+  const timer = pendingIdle.get(id);
+  if (timer) { clearInterval(timer); pendingIdle.delete(id); }
+}
+
 function clear(id) {
   activity.delete(id);
+  cancelPendingIdle(id);
   const pending = pendingSetup.get(id);
   if (pending) { clearTimeout(pending.timer); pendingSetup.delete(id); }
 }

package/workplan.txt

@@ -1,28 +1,43 @@
-CliDeck — Future Tasks
+CliDeck — Work Plan
 ======================
 
-## Structured menu events
-
-Move interactive menu detection from mobile-side parsing to CliDeck desktop.
-Detect menus server-side, broadcast as structured data, render on both desktop and mobile.
-
-Why:
-- Single source of truth — detect once, consume everywhere
-- Enables desktop sidebar preview ("please make a choice")
-- Opens the door to raw ANSI-based detection (mobile never sees PTY bytes)
-- Fixes stuck "working" status when agent shows a menu: no telemetry event fires for
-  "waiting for user input", so CliDeck never flips to idle and never sends the notification.
-  Menu detection can double as an idle signal — if a menu is detected, force status to idle.
-
-Steps:
-1. Add menu detection in CliDeck where screen parsing already happens
-2. Store per-session menu state (choices, selected, footer)
-3. Detect menu appearance and disappearance, broadcast session.menu events
-4. Show "make a choice" preview in desktop session list
-5. Daemon forwards session.menu to mobile
-6. Remove mobile-side menu parsing, render from structured state instead
-
-Notes:
-- Detection heuristic stays the same (footer + numbered lines) unless ANSI-based approach is pursued
-- Currently mobile detection works fine with regex fix + "Esc to cancel" footer check
-- No agent-side telemetry event exists for menus — heuristic is the only option for now
+## Structured menu events — DONE
+
+Moved interactive menu detection from mobile-side parsing to CliDeck desktop.
+Menus detected server-side, broadcast as structured data, rendered on both desktop and mobile.
+
+Implementation:
+- transcript.js: detectMenu(lines, presetId) — walks upward from footer/esc anchor,
+  collects sequential numbered choices, requires agent-specific marker (❯/›/●) on at least one line.
+  Handles footerless Gemini menus via (esc) in choice text.
+- handlers.js: after terminal.buffer capture, runs detectMenu, broadcasts session.menu
+  with structured choices. Forces idle when menu detected. Deduplicates via _menuKey on session.
+- sessions.js: list() includes menu state for daemon reconnect.
+- daemon.js: forwards session.menu to mobile, caches per-session menu state,
+  sends on subscribe, clears on working status.
+- mobile index.html: renderMenu(choices) replaces 28-line updateChoices parser.
+  Menu state comes from session.menu event, no local parsing.
+
+## Pending idle for Claude — DONE
+
+Claude's api_request no longer flips to idle immediately. Instead:
+- api_request → starts pending idle window (polls every 250ms)
+- Confirm idle: 1s of no PTY output (measured from max(started, lastOutputAt))
+- Cancel: any new telemetry event, or 6s timeout
+- activity.js: exposes lastOutputAt(id) — timestamp of last PTY output per session
+- telemetry-receiver.js: startPendingIdle/cancelPendingIdle manage the window
+
+Why: api_request fires between tool calls mid-work, not just at end-of-turn.
+Immediate idle caused false status flickers. The 1s output silence confirms
+the agent is truly waiting for user input.
+
+## Future: desktop sidebar menu preview
+
+Show "please make a choice" or choice labels in the desktop session list
+when a menu is active. Infrastructure is ready (session.menu broadcast exists).
+
+## Future: OpenCode menu support
+
+OpenCode not yet in MENU_MARKERS. Need to determine:
+- Does OpenCode expose menu events via bridge plugin API?
+- If not, what marker character does OpenCode use for interactive menus?