claude-remote 0.2.0 → 0.2.2

package/hooks/bridge-session-end.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Bridge session-end hook — notifies WebUI that a Claude session has ended.
+// Fire-and-forget: POST stdin JSON to bridge server, don't wait for response.
+
+const http = require('http');
+
+if (!process.env.BRIDGE_PORT) process.exit(0);
+
+const PORT = process.env.BRIDGE_PORT;
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => (input += chunk));
+process.stdin.on('end', () => {
+  const body = input || '{}';
+  const req = http.request({
+    hostname: '127.0.0.1',
+    port: PORT,
+    path: '/hook/session-end',
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Content-Length': Buffer.byteLength(body),
+    },
+  }, () => {
+    process.exit(0);
+  });
+
+  req.on('error', () => process.exit(0));
+  req.setTimeout(10000, () => { req.destroy(); process.exit(0); });
+  req.write(body);
+  req.end();
+});

package/package.json

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

package/server.js

@@ -118,8 +118,11 @@ const EVENT_BUFFER_MAX = 5000;
 let nextWsId = 0;
 let tailTimer = null;
 let switchWatcher = null;
+let switchWatcherDelayTimer = null;
 let expectingSwitch = false;
 let expectingSwitchTimer = null;
+let pendingSwitchTarget = null;
+let pendingInitialClearTranscript = null; // { sessionId }
 let tailRemainder = Buffer.alloc(0);
 let tailCatchingUp = false; // true while reading historical transcript content
 const isTTY = process.stdin.isTTY && process.stdout.isTTY;
@@ -196,6 +199,7 @@ function resolveHookTranscript(data) {
 function maybeAttachHookSession(data, source) {
   const target = resolveHookTranscript(data);
   if (!target) return;
+  let hookSource = null;
 
   // Already attached to this exact session — no-op
   if (currentSessionId === target.sessionId && transcriptPath &&
@@ -206,16 +210,29 @@ function maybeAttachHookSession(data, source) {
   const targetHasContent = fileLooksLikeTranscript(target.full);
 
   if (source === 'session-start') {
-    // session-start is unreliable for --resume (fires twice, one is a
-    // snapshot-only session). Only accept when:
-    // 1. No session bound yet (first attach), OR
-    // 2. Expecting a switch (/clear), OR
-    // 3. Target has conversation content and current doesn't
-    if (currentSessionId && !expectingSwitch) {
-      const currentHasContent = transcriptPath && fileLooksLikeTranscript(transcriptPath);
-      if (!targetHasContent || currentHasContent) {
-        log(`Ignored session-start: ${target.sessionId} (current=${currentSessionId} currentHasContent=${currentHasContent} targetHasContent=${targetHasContent})`);
-        return;
+    // Check hook stdin's source field for deterministic binding
+    hookSource = data.source; // "startup" | "resume" | "clear" | "compact"
+
+    // /clear or resume: deterministic bind — skip defensive filtering
+    if (hookSource === 'clear' || hookSource === 'resume') {
+      log(`Deterministic session-start (hookSource=${hookSource}): ${target.sessionId}`);
+      // Fall through to attachTranscript below
+    } else {
+      // session-start is unreliable for --resume (fires twice, one is a
+      // snapshot-only session). Only accept when:
+      // 1. No session bound yet (first attach), OR
+      // 2. Expecting a switch (/clear), OR
+      // 3. Target has conversation content and current doesn't
+      if (currentSessionId && !expectingSwitch) {
+        const currentHasContent = transcriptPath && fileLooksLikeTranscript(transcriptPath);
+        if (!targetHasContent || currentHasContent) {
+          if (currentSessionId !== target.sessionId) {
+            pendingSwitchTarget = { ...target, seenAt: Date.now(), source };
+            log(`Queued pending session-start: ${target.sessionId} (current=${currentSessionId} currentHasContent=${currentHasContent} targetHasContent=${targetHasContent})`);
+          }
+          log(`Ignored session-start: ${target.sessionId} (current=${currentSessionId} currentHasContent=${currentHasContent} targetHasContent=${targetHasContent})`);
+          return;
+        }
       }
     }
   } else if (source === 'pre-tool-use') {
@@ -235,7 +252,35 @@ function maybeAttachHookSession(data, source) {
   }
 
   log(`Hook session attached from ${source}: ${target.sessionId}`);
+  attachTranscript({
+    full: target.full,
+    ignoreInitialClearCommand: source === 'session-start' && hookSource === 'clear',
+  }, 0);
+}
+
+function maybeAttachPendingSwitchTarget(reason, requireReady = true) {
+  if (!pendingSwitchTarget) return false;
+  if ((Date.now() - pendingSwitchTarget.seenAt) > 15000) {
+    log(`Dropped stale pending switch target: ${pendingSwitchTarget.sessionId}`);
+    pendingSwitchTarget = null;
+    return false;
+  }
+  if (pendingSwitchTarget.sessionId === currentSessionId) {
+    pendingSwitchTarget = null;
+    return false;
+  }
+
+  if (requireReady && !fileLooksLikeTranscript(pendingSwitchTarget.full)) {
+    return false;
+  }
+
+  const target = pendingSwitchTarget;
+  pendingSwitchTarget = null;
+  log(`Attaching pending switch target from ${reason}: ${target.sessionId}`);
+  if (tailTimer) { clearInterval(tailTimer); tailTimer = null; }
+  if (switchWatcher) { clearInterval(switchWatcher); switchWatcher = null; }
   attachTranscript({ full: target.full }, 0);
+  return true;
 }
 
 // ============================================================
@@ -326,7 +371,9 @@ const server = http.createServer((req, res) => {
     req.on('data', chunk => (body += chunk));
     req.on('end', () => {
       try {
-        maybeAttachHookSession(JSON.parse(body), 'session-start');
+        const data = JSON.parse(body);
+        log(`/hook/session-start received (source=${data.source || 'unknown'}, session_id=${data.session_id || 'none'})`);
+        maybeAttachHookSession(data, 'session-start');
       } catch {}
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end('{}');
@@ -334,6 +381,25 @@ const server = http.createServer((req, res) => {
     return;
   }
 
+  // --- API: Session end hook endpoint ---
+  if (req.method === 'POST' && url === '/hook/session-end') {
+    let body = '';
+    req.on('data', chunk => (body += chunk));
+    req.on('end', () => {
+      let data = {};
+      try { data = JSON.parse(body); } catch {}
+      const reason = data.reason || 'unknown';
+      log(`/hook/session-end received (reason=${reason})`);
+      if (reason === 'clear') {
+        markExpectingSwitch();
+      }
+      broadcast({ type: 'session_end', reason });
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end('{}');
+    });
+    return;
+  }
+
   // --- API: Stop hook endpoint ---
   if (req.method === 'POST' && url === '/hook/stop') {
     let body = '';
@@ -872,9 +938,26 @@ function extractSlashCommand(content) {
   return inlineMatch ? inlineMatch[1].trim().toLowerCase() : '';
 }
 
+function isNonAiUserEvent(event, content) {
+  if (!event || typeof event !== 'object') return false;
+  if (event.isMeta === true) return true;
+  if (event.isCompactSummary === true) return true;
+  if (event.isVisibleInTranscriptOnly === true) return true;
+
+  const text = flattenUserContent(content).trim();
+  if (!text) return false;
+  return /<local-command-(?:stdout|stderr|caveat)>/i.test(text);
+}
+
 function attachTranscript(target, startOffset = 0) {
   transcriptPath = target.full;
   currentSessionId = path.basename(transcriptPath, '.jsonl');
+  pendingInitialClearTranscript = target.ignoreInitialClearCommand
+    ? { sessionId: currentSessionId }
+    : null;
+  if (pendingSwitchTarget && pendingSwitchTarget.sessionId === currentSessionId) {
+    pendingSwitchTarget = null;
+  }
   transcriptOffset = Math.max(0, startOffset);
   tailRemainder = Buffer.alloc(0);
   eventBuffer = [];
@@ -885,6 +968,7 @@ function attachTranscript(target, startOffset = 0) {
     expectingSwitch = false;
     if (expectingSwitchTimer) { clearTimeout(expectingSwitchTimer); expectingSwitchTimer = null; }
   }
+  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.
@@ -903,7 +987,7 @@ function attachTranscript(target, startOffset = 0) {
     lastSeq: 0,
   });
   startTailing();
-  startSwitchWatcher();
+  // switchWatcher is now only started as a delayed fallback from markExpectingSwitch()
 }
 
 function markExpectingSwitch() {
@@ -915,6 +999,18 @@ function markExpectingSwitch() {
     log('Expecting-switch flag expired (no new transcript found)');
   }, 15000);
   log('Expecting session switch (/clear detected)');
+  if (maybeAttachPendingSwitchTarget('markExpectingSwitch')) return;
+
+  // Delay switchWatcher as fallback — give hooks 5s to bind deterministically
+  if (switchWatcher) { clearInterval(switchWatcher); switchWatcher = null; }
+  if (switchWatcherDelayTimer) { clearTimeout(switchWatcherDelayTimer); switchWatcherDelayTimer = null; }
+  switchWatcherDelayTimer = setTimeout(() => {
+    switchWatcherDelayTimer = null;
+    if (expectingSwitch && !switchWatcher) {
+      log('Hook did not bind within 5s, starting switchWatcher fallback');
+      startSwitchWatcher();
+    }
+  }, 5000);
 }
 
 function startSwitchWatcher() {
@@ -952,6 +1048,7 @@ function startSwitchWatcher() {
 function startTailing() {
   tailRemainder = Buffer.alloc(0);
   tailTimer = setInterval(() => {
+    if (maybeAttachPendingSwitchTarget('tail_pending_target')) return;
     if (!transcriptPath) return;
     try {
       const stat = fs.statSync(transcriptPath);
@@ -983,15 +1080,38 @@ function startTailing() {
           if (event.type === 'user' || (event.message && event.message.role === 'user')) {
             const content = event.message && event.message.content;
             const slashCommand = extractSlashCommand(content);
+            const isPassiveUserEvent = isNonAiUserEvent(event, content);
+            const ignoreInitialClear = (
+              slashCommand === '/clear' &&
+              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).
-            if (!tailCatchingUp && !slashCommand) {
+            if (!tailCatchingUp && !slashCommand && !isPassiveUserEvent) {
               broadcast({ type: 'working_started' });
             }
             if (slashCommand === '/clear') {
-              markExpectingSwitch();
+              if (ignoreInitialClear) {
+                pendingInitialClearTranscript = null;
+                log(`Ignored bootstrap /clear transcript event for session ${currentSessionId}`);
+              } else {
+                markExpectingSwitch();
+              }
+            } else if (
+              pendingInitialClearTranscript &&
+              pendingInitialClearTranscript.sessionId === currentSessionId &&
+              !isPassiveUserEvent &&
+              !event.isMeta &&
+              !event.isCompactSummary &&
+              !event.isVisibleInTranscriptOnly
+            ) {
+              pendingInitialClearTranscript = null;
             }
+          } else if (pendingInitialClearTranscript && pendingInitialClearTranscript.sessionId === currentSessionId &&
+                     event.type === 'assistant') {
+            pendingInitialClearTranscript = null;
           }
           // Enrich Edit tool_use blocks with source file start line
           enrichEditStartLines(event);
@@ -1037,8 +1157,11 @@ function enrichEditStartLines(event) {
 function stopTailing() {
   if (tailTimer) { clearInterval(tailTimer); tailTimer = null; }
   if (switchWatcher) { clearInterval(switchWatcher); switchWatcher = null; }
+  if (switchWatcherDelayTimer) { clearTimeout(switchWatcherDelayTimer); switchWatcherDelayTimer = null; }
   if (expectingSwitchTimer) { clearTimeout(expectingSwitchTimer); expectingSwitchTimer = null; }
   expectingSwitch = false;
+  pendingSwitchTarget = null;
+  pendingInitialClearTranscript = null;
   tailRemainder = Buffer.alloc(0);
 }
 
@@ -1194,6 +1317,23 @@ function setupHooks() {
   }
   settings.hooks.SessionStart = existingSessionStart;
 
+  // Merge bridge hook into SessionEnd (notify bridge when session ends, e.g. /clear)
+  const sessionEndScript = path.resolve(__dirname, 'hooks', 'bridge-session-end.js').replace(/\\/g, '/');
+  const sessionEndCmd = `node "${sessionEndScript}"`;
+  const existingSessionEnd = settings.hooks.SessionEnd || [];
+  const sessionEndBridgeIdx = existingSessionEnd.findIndex(e =>
+    e.hooks?.some(h => h.command?.includes('bridge-session-end'))
+  );
+  const sessionEndEntry = {
+    hooks: [{ type: 'command', command: sessionEndCmd, timeout: 10 }],
+  };
+  if (sessionEndBridgeIdx >= 0) {
+    existingSessionEnd[sessionEndBridgeIdx] = sessionEndEntry;
+  } else {
+    existingSessionEnd.push(sessionEndEntry);
+  }
+  settings.hooks.SessionEnd = existingSessionEnd;
+
   fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
   log(`Hooks configured: ${settingsPath}`);
 }