claude-remote 0.2.2 → 0.2.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-remote",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Remote control bridge for Claude Code REPL - drive from phone/WebUI",
   "main": "server.js",
   "bin": {

package/server.js

@@ -103,8 +103,9 @@ const { cwd: _parsedCwd, claudeArgs: CLAUDE_EXTRA_ARGS, blocked: _blockedArgs }
 
 // --- Config ---
 const PORT = parseInt(process.env.PORT || '3100', 10);
-const CWD = _parsedCwd;
+let CWD = _parsedCwd;
 const CLAUDE_HOME = path.join(os.homedir(), '.claude');
+const CLAUDE_STATE_FILE = path.join(os.homedir(), '.claude.json');
 const PROJECTS_DIR = path.join(CLAUDE_HOME, 'projects');
 
 // --- State ---
@@ -128,6 +129,16 @@ let tailCatchingUp = false; // true while reading historical transcript content
 const isTTY = process.stdin.isTTY && process.stdout.isTTY;
 const LEGACY_REPLAY_DELAY_MS = 1500;
 const IMAGE_UPLOAD_TTL_MS = 15 * 60 * 1000;
+let turnStateVersion = 0;
+let turnState = {
+  phase: 'idle',
+  sessionId: null,
+  version: 0,
+  updatedAt: Date.now(),
+};
+let ttyInputForwarderAttached = false;
+let ttyInputHandler = null;
+let ttyResizeHandler = null;
 
 // --- Permission approval state ---
 let approvalSeq = 0;
@@ -153,16 +164,70 @@ function wsLabel(ws) {
 function sendWs(ws, msg, context = '') {
   if (!ws || ws.readyState !== WebSocket.OPEN) return false;
   ws.send(JSON.stringify(msg));
-  if (msg.type === 'status' || msg.type === 'transcript_ready' || msg.type === 'replay_done') {
+  if (msg.type === 'status' || msg.type === 'transcript_ready' || msg.type === 'replay_done' || msg.type === 'turn_state') {
     const extra = [];
     if (msg.sessionId !== undefined) extra.push(`session=${msg.sessionId ?? 'null'}`);
     if (msg.lastSeq !== undefined) extra.push(`lastSeq=${msg.lastSeq}`);
     if (msg.resumed !== undefined) extra.push(`resumed=${msg.resumed}`);
+    if (msg.phase !== undefined) extra.push(`phase=${msg.phase}`);
+    if (msg.version !== undefined) extra.push(`version=${msg.version}`);
     log(`Send ${msg.type}${context ? ` (${context})` : ''} -> ${wsLabel(ws)}${extra.length ? ` ${extra.join(' ')}` : ''}`);
   }
   return true;
 }
 
+function getTurnStatePayload() {
+  return {
+    type: 'turn_state',
+    phase: turnState.phase,
+    sessionId: turnState.sessionId,
+    version: turnState.version,
+    updatedAt: turnState.updatedAt,
+  };
+}
+
+function sendTurnState(ws, context = '') {
+  return sendWs(ws, getTurnStatePayload(), context);
+}
+
+function setTurnState(phase, { sessionId = currentSessionId, reason = '', force = false } = {}) {
+  const normalizedPhase = phase === 'running' ? 'running' : 'idle';
+  const normalizedSessionId = sessionId || null;
+  const changed = force ||
+    turnState.phase !== normalizedPhase ||
+    turnState.sessionId !== normalizedSessionId;
+
+  if (!changed) return false;
+
+  turnState = {
+    phase: normalizedPhase,
+    sessionId: normalizedSessionId,
+    version: ++turnStateVersion,
+    updatedAt: Date.now(),
+  };
+
+  log(`Turn state -> phase=${turnState.phase} session=${turnState.sessionId ?? 'null'} version=${turnState.version}${reason ? ` reason=${reason}` : ''}`);
+  broadcast(getTurnStatePayload());
+  return true;
+}
+
+function attachTtyForwarders() {
+  if (!isTTY || ttyInputForwarderAttached) return;
+
+  ttyInputHandler = (chunk) => {
+    if (claudeProc) claudeProc.write(chunk);
+  };
+  ttyResizeHandler = () => {
+    if (claudeProc) claudeProc.resize(process.stdout.columns, process.stdout.rows);
+  };
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on('data', ttyInputHandler);
+  process.stdout.on('resize', ttyResizeHandler);
+  ttyInputForwarderAttached = true;
+}
+
 function normalizeFsPath(value) {
   const resolved = path.resolve(String(value || ''));
   return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
@@ -393,6 +458,7 @@ const server = http.createServer((req, res) => {
       if (reason === 'clear') {
         markExpectingSwitch();
       }
+      setTurnState('idle', { reason: `session-end:${reason}` });
       broadcast({ type: 'session_end', reason });
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end('{}');
@@ -409,7 +475,7 @@ const server = http.createServer((req, res) => {
       try {
         maybeAttachHookSession(JSON.parse(body), 'stop');
       } catch {}
-      broadcast({ type: 'turn_complete' });
+      setTurnState('idle', { reason: 'stop-hook' });
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end('{}');
     });
@@ -444,7 +510,7 @@ function broadcast(msg) {
       recipients.push(wsLabel(ws));
     }
   }
-  if (msg.type === 'working_started' || msg.type === 'turn_complete' || msg.type === 'status' || msg.type === 'transcript_ready') {
+  if (msg.type === 'status' || msg.type === 'transcript_ready' || msg.type === 'turn_state') {
     log(`Broadcast ${msg.type} -> ${recipients.length} client(s)${recipients.length ? ` [${recipients.join(', ')}]` : ''}`);
   }
 }
@@ -476,6 +542,7 @@ function sendReplay(ws, lastSeq = null) {
     lastSeq: latestEventSeq(),
     resumed: normalizedLastSeq != null,
   }, 'sendReplay');
+  sendTurnState(ws, 'sendReplay');
 }
 
 function sendUploadStatus(ws, uploadId, status, extra = {}) {
@@ -553,7 +620,7 @@ wss.on('connection', (ws, req) => {
     sendReplay(ws, null);
   }, LEGACY_REPLAY_DELAY_MS);
 
-  ws.on('message', (raw) => {
+  ws.on('message', async (raw) => {
     let msg;
     try { msg = JSON.parse(raw); } catch { return; }
 
@@ -580,6 +647,7 @@ wss.on('connection', (ws, req) => {
             lastSeq: 0,
             resumed: false,
           }));
+          sendTurnState(ws, 'resume-empty');
           break;
         }
 
@@ -620,11 +688,11 @@ wss.on('connection', (ws, req) => {
           if (slashCommand === '/clear') {
             markExpectingSwitch();
           }
-          // Slash commands (e.g. /clear, /help, /compact) are internal CLI
+          // Slash commands are internal CLI control flow.
           // commands, not AI turns — the stop hook will never fire, so don't
-          // enter the waiting state.
+          // They should never mutate the live turn state into running.
           if (!slashCommand) {
-            broadcast({ type: 'working_started' });
+            setTurnState('running', { reason: 'chat' });
           }
           claudeProc.write(text);
           setTimeout(() => {
@@ -787,6 +855,7 @@ wss.on('connection', (ws, req) => {
             logLabel: upload.name || uploadId,
             onCleanup: () => cleanupImageUpload(uploadId),
           });
+          setTurnState('running', { reason: 'image_submit' });
           sendUploadStatus(ws, uploadId, 'submitted');
         } catch (err) {
           sendUploadStatus(ws, uploadId, 'error', { message: err.message });
@@ -798,6 +867,55 @@ wss.on('connection', (ws, req) => {
         handleImageUpload(msg);
         break;
       }
+      case 'list_sessions': {
+        try {
+          const sessions = scanSessions(CWD, 20);
+          sendWs(ws, { type: 'sessions', sessions });
+        } catch (err) {
+          log(`scanSessions error: ${err.message}`);
+          sendWs(ws, { type: 'sessions', sessions: [], error: err.message });
+        }
+        break;
+      }
+      case 'list_dirs': {
+        try {
+          const browser = listDirectories(msg.cwd || CWD);
+          sendWs(ws, { type: 'dir_list', ...browser });
+        } catch (err) {
+          log(`listDirectories error: ${err.message}`);
+          sendWs(ws, {
+            type: 'dir_list',
+            cwd: path.resolve(String(msg.cwd || CWD || '')),
+            parent: null,
+            roots: getDirectoryRoots(),
+            entries: [],
+            error: err.message,
+          });
+        }
+        break;
+      }
+      case 'switch_session': {
+        if (claudeProc && msg.sessionId) {
+          log(`Switch session → /resume ${msg.sessionId}`);
+          markExpectingSwitch();
+          claudeProc.write(`/resume ${msg.sessionId}`);
+          setTimeout(() => {
+            if (claudeProc) claudeProc.write('\r');
+          }, 150);
+        }
+        break;
+      }
+      case 'change_cwd': {
+        if (msg.cwd) {
+          try {
+            const targetCwd = assertDirectoryPath(msg.cwd);
+            restartClaude(targetCwd);
+          } catch (err) {
+            sendWs(ws, { type: 'cwd_change_error', cwd: String(msg.cwd), error: err.message });
+          }
+        }
+        break;
+      }
     }
   });
 
@@ -828,7 +946,7 @@ function spawnClaude() {
   const cols = isTTY ? process.stdout.columns : 120;
   const rows = isTTY ? process.stdout.rows : 40;
 
-  claudeProc = pty.spawn(shell, args, {
+  const proc = claudeProc = pty.spawn(shell, args, {
     name: 'xterm-256color',
     cols,
     rows,
@@ -837,33 +955,33 @@ function spawnClaude() {
   });
 
   log(`Claude spawned (pid ${claudeProc.pid}) — ${cols}x${rows} cmd="${claudeCmd}"`);
-  broadcast({ type: 'status', status: 'running', pid: claudeProc.pid });
+  setTurnState('idle', { sessionId: currentSessionId, reason: 'claude_spawned' });
+  broadcast({
+    type: 'status',
+    status: 'running',
+    pid: proc.pid,
+    cwd: CWD,
+    sessionId: currentSessionId,
+    lastSeq: latestEventSeq(),
+  });
 
   // === PTY output → local terminal + WebSocket + mode detection ===
-  claudeProc.onData((data) => {
+  proc.onData((data) => {
     if (isTTY) process.stdout.write(data);   // show in the terminal you ran the bridge from
     broadcast({ type: 'pty_output', data });  // push to WebUI
   });
 
   // === Local terminal input → PTY ===
-  if (isTTY) {
-    process.stdin.setRawMode(true);
-    process.stdin.resume();
-    process.stdin.on('data', (chunk) => {
-      if (claudeProc) claudeProc.write(chunk);
-    });
-
-    // Resize PTY when local terminal resizes
-    process.stdout.on('resize', () => {
-      if (claudeProc) {
-        claudeProc.resize(process.stdout.columns, process.stdout.rows);
-      }
-    });
-  }
+  attachTtyForwarders();
 
   // === PTY exit → cleanup ===
-  claudeProc.onExit(({ exitCode, signal }) => {
+  proc.onExit(({ exitCode, signal }) => {
+    if (claudeProc !== proc) {
+      log(`Ignoring stale Claude exit (pid ${proc.pid}, code=${exitCode}, signal=${signal})`);
+      return;
+    }
     log(`Claude exited (code=${exitCode}, signal=${signal})`);
+    setTurnState('idle', { sessionId: currentSessionId, reason: 'pty_exit' });
     broadcast({ type: 'pty_exit', exitCode, signal });
     claudeProc = null;
 
@@ -949,9 +1067,25 @@ function isNonAiUserEvent(event, content) {
   return /<local-command-(?:stdout|stderr|caveat)>/i.test(text);
 }
 
+function extractSessionPrompt(event) {
+  if (!event || event.type !== 'user') return '';
+
+  const message = event.message;
+  const content = typeof message === 'string'
+    ? message
+    : (message && typeof message === 'object' ? message.content : '');
+  const text = flattenUserContent(content).trim();
+  if (!text) return '';
+  if (isNonAiUserEvent(event, content)) return '';
+  if (extractSlashCommand(content)) return '';
+
+  return text.replace(/\s+/g, ' ').trim().substring(0, 120);
+}
+
 function attachTranscript(target, startOffset = 0) {
   transcriptPath = target.full;
   currentSessionId = path.basename(transcriptPath, '.jsonl');
+  setTurnState('idle', { sessionId: currentSessionId, reason: 'transcript_attached' });
   pendingInitialClearTranscript = target.ignoreInitialClearCommand
     ? { sessionId: currentSessionId }
     : null;
@@ -970,8 +1104,8 @@ function attachTranscript(target, startOffset = 0) {
   }
   if (switchWatcherDelayTimer) { clearTimeout(switchWatcherDelayTimer); switchWatcherDelayTimer = null; }
 
-  // If transcript file already has content, mark as catching up so we don't
-  // broadcast working_started for historical user messages.
+  // If transcript file already has content, mark as catching up so historical
+  // transcript replay cannot mutate live turn state.
   try {
     const stat = fs.statSync(transcriptPath);
     tailCatchingUp = stat.size > transcriptOffset;
@@ -1086,11 +1220,10 @@ function startTailing() {
               pendingInitialClearTranscript &&
               pendingInitialClearTranscript.sessionId === currentSessionId
             );
-            // Only broadcast working_started for live (new) user messages,
-            // not for historical events during catch-up, and not for slash
-            // commands (which are CLI commands, not AI turns).
+            // Only live, AI-producing user messages can move the turn state
+            // into running. Historical replay and slash commands are ignored.
             if (!tailCatchingUp && !slashCommand && !isPassiveUserEvent) {
-              broadcast({ type: 'working_started' });
+              setTurnState('running', { sessionId: currentSessionId, reason: 'transcript_user_event' });
             }
             if (slashCommand === '/clear') {
               if (ignoreInitialClear) {
@@ -1154,6 +1287,111 @@ function enrichEditStartLines(event) {
   }
 }
 
+// ============================================================
+//  Session Scanner — list historical sessions from JSONL files
+// ============================================================
+function scanSessions(cwd, limit = 20) {
+  const dir = path.join(PROJECTS_DIR, getProjectSlug(cwd));
+  let files;
+  try {
+    files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+  } catch {
+    return [];
+  }
+
+  // Stat each file, sort by mtime desc
+  const entries = [];
+  for (const f of files) {
+    const full = path.join(dir, f);
+    try {
+      const stat = fs.statSync(full);
+      entries.push({ file: f, full, mtime: stat.mtimeMs, size: stat.size });
+    } catch { /* skip */ }
+  }
+  entries.sort((a, b) => b.mtime - a.mtime);
+  const top = entries.slice(0, limit);
+
+  const sessions = [];
+  for (const entry of top) {
+    const sessionId = path.basename(entry.file, '.jsonl');
+    const info = {
+      sessionId,
+      summary: '',
+      firstPrompt: '',
+      lastModified: Math.round(entry.mtime),
+      fileSize: entry.size,
+      cwd: cwd,
+    };
+
+    // Read first ~64KB to extract the first real user prompt and model.
+    try {
+      const fd = fs.openSync(entry.full, 'r');
+      const buf = Buffer.alloc(Math.min(entry.size, 64 * 1024));
+      fs.readSync(fd, buf, 0, buf.length, 0);
+      fs.closeSync(fd);
+      const lines = buf.toString('utf8').split('\n').filter(Boolean);
+      for (const line of lines) {
+        try {
+          const evt = JSON.parse(line);
+          if (!info.firstPrompt) {
+            info.firstPrompt = extractSessionPrompt(evt);
+          }
+          if (!info.model && evt.model) {
+            info.model = evt.model;
+          }
+        } catch { /* skip malformed line */ }
+      }
+    } catch { /* skip unreadable file */ }
+
+    info.summary = info.firstPrompt || 'Untitled';
+    sessions.push(info);
+  }
+  return sessions;
+}
+
+function getDirectoryRoots() {
+  if (process.platform === 'win32') {
+    const roots = [];
+    for (let code = 65; code <= 90; code++) {
+      const drive = String.fromCharCode(code) + ':\\';
+      try {
+        if (fs.existsSync(drive)) roots.push(drive);
+      } catch {}
+    }
+    return roots;
+  }
+  return ['/'];
+}
+
+function assertDirectoryPath(target) {
+  const resolved = path.resolve(String(target || ''));
+  let stat;
+  try {
+    stat = fs.statSync(resolved);
+  } catch {
+    throw new Error('Directory not found');
+  }
+  if (!stat.isDirectory()) throw new Error('Path is not a directory');
+  return resolved;
+}
+
+function listDirectories(target) {
+  const cwd = assertDirectoryPath(target);
+  const roots = getDirectoryRoots();
+  const parentDir = path.dirname(cwd);
+  const parent = normalizeFsPath(parentDir) === normalizeFsPath(cwd) ? null : parentDir;
+
+  const entries = fs.readdirSync(cwd, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => ({
+      name: entry.name,
+      path: path.join(cwd, entry.name),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: 'base' }));
+
+  return { cwd, parent, roots, entries };
+}
+
 function stopTailing() {
   if (tailTimer) { clearInterval(tailTimer); tailTimer = null; }
   if (switchWatcher) { clearInterval(switchWatcher); switchWatcher = null; }
@@ -1165,6 +1403,75 @@ function stopTailing() {
   tailRemainder = Buffer.alloc(0);
 }
 
+function trustProjectCwd(cwd) {
+  const resolved = path.resolve(String(cwd || ''));
+  if (!resolved) return;
+
+  let state = {};
+  try {
+    state = JSON.parse(fs.readFileSync(CLAUDE_STATE_FILE, 'utf8'));
+  } catch {}
+
+  state.projects = state.projects && typeof state.projects === 'object' ? state.projects : {};
+  const keyVariants = process.platform === 'win32'
+    ? [resolved, resolved.replace(/\\/g, '/')]
+    : [resolved];
+
+  for (const projectKey of keyVariants) {
+    const existing = state.projects[projectKey];
+    state.projects[projectKey] = {
+      ...(existing && typeof existing === 'object' ? existing : {}),
+      hasTrustDialogAccepted: true,
+      projectOnboardingSeenCount: Number.isInteger(existing?.projectOnboardingSeenCount)
+        ? existing.projectOnboardingSeenCount
+        : 0,
+    };
+  }
+
+  fs.writeFileSync(CLAUDE_STATE_FILE, JSON.stringify(state, null, 2));
+  log(`Trusted Claude project cwd: ${resolved}`);
+}
+
+function restartClaude(newCwd) {
+  log(`Restarting Claude with new CWD: ${newCwd}`);
+  CWD = newCwd;
+  try {
+    trustProjectCwd(CWD);
+  } catch (err) {
+    log(`Failed to trust Claude project cwd "${CWD}": ${err.message}`);
+  }
+
+  // Stop transcript tailing (also clears switch/expect state)
+  stopTailing();
+
+  // Reset session state
+  currentSessionId = null;
+  transcriptPath = null;
+  transcriptOffset = 0;
+  eventBuffer = [];
+  eventSeq = 0;
+  tailCatchingUp = false;
+  setTurnState('idle', { sessionId: null, reason: 'restart_claude' });
+
+  // Mark the current PTY as stale before killing it so its exit handler
+  // does not shut down the whole bridge during a restart.
+  const procToRestart = claudeProc;
+  claudeProc = null;
+  if (procToRestart) {
+    procToRestart.kill();
+  }
+
+  // Re-setup hooks (CWD changed → project slug may change)
+  setupHooks();
+
+  // Broadcast cwd change immediately so clients drop the previous session
+  // before the replacement Claude process attaches a new transcript.
+  broadcast({ type: 'cwd_changed', cwd: CWD, sessionId: null, lastSeq: 0 });
+
+  // Respawn Claude in new directory
+  spawnClaude();
+}
+
 // ============================================================
 //  5. Image Upload → Clipboard Injection
 // ============================================================
@@ -1244,6 +1551,7 @@ function handleImageUpload(msg) {
       mediaType: msg.mediaType,
       text: msg.text || '',
     });
+    setTurnState('running', { reason: 'legacy_image_upload' });
   } catch (err) {
     log(`Image upload error: ${err.message}`);
     try { fs.unlinkSync(tmpFile); } catch {}