claude-remote 0.2.1 → 0.2.3

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.1",
+  "version": "0.2.3",
   "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 ---
@@ -118,14 +119,19 @@ 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;
 const LEGACY_REPLAY_DELAY_MS = 1500;
 const IMAGE_UPLOAD_TTL_MS = 15 * 60 * 1000;
+let ttyInputForwarderAttached = false;
+let ttyInputHandler = null;
+let ttyResizeHandler = null;
 
 // --- Permission approval state ---
 let approvalSeq = 0;
@@ -161,6 +167,23 @@ function sendWs(ws, msg, context = '') {
   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;
@@ -197,6 +220,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 &&
@@ -207,20 +231,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) {
-        if (currentSessionId !== target.sessionId) {
-          pendingSwitchTarget = { ...target, seenAt: Date.now(), source };
-          log(`Queued pending session-start: ${target.sessionId} (current=${currentSessionId} currentHasContent=${currentHasContent} targetHasContent=${targetHasContent})`);
+    // 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;
         }
-        log(`Ignored session-start: ${target.sessionId} (current=${currentSessionId} currentHasContent=${currentHasContent} targetHasContent=${targetHasContent})`);
-        return;
       }
     }
   } else if (source === 'pre-tool-use') {
@@ -240,7 +273,10 @@ function maybeAttachHookSession(data, source) {
   }
 
   log(`Hook session attached from ${source}: ${target.sessionId}`);
-  attachTranscript({ full: target.full }, 0);
+  attachTranscript({
+    full: target.full,
+    ignoreInitialClearCommand: source === 'session-start' && hookSource === 'clear',
+  }, 0);
 }
 
 function maybeAttachPendingSwitchTarget(reason, requireReady = true) {
@@ -356,7 +392,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('{}');
@@ -364,6 +402,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 = '';
@@ -517,7 +574,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; }
 
@@ -762,6 +819,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;
+      }
     }
   });
 
@@ -792,7 +898,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,
@@ -801,32 +907,30 @@ function spawnClaude() {
   });
 
   log(`Claude spawned (pid ${claudeProc.pid}) — ${cols}x${rows} cmd="${claudeCmd}"`);
-  broadcast({ type: 'status', status: 'running', pid: claudeProc.pid });
+  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})`);
     broadcast({ type: 'pty_exit', exitCode, signal });
     claudeProc = null;
@@ -902,9 +1006,38 @@ 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 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');
+  pendingInitialClearTranscript = target.ignoreInitialClearCommand
+    ? { sessionId: currentSessionId }
+    : null;
   if (pendingSwitchTarget && pendingSwitchTarget.sessionId === currentSessionId) {
     pendingSwitchTarget = null;
   }
@@ -918,6 +1051,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.
@@ -936,7 +1070,7 @@ function attachTranscript(target, startOffset = 0) {
     lastSeq: 0,
   });
   startTailing();
-  startSwitchWatcher();
+  // switchWatcher is now only started as a delayed fallback from markExpectingSwitch()
 }
 
 function markExpectingSwitch() {
@@ -949,6 +1083,17 @@ function markExpectingSwitch() {
   }, 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() {
@@ -1018,15 +1163,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);
@@ -1069,15 +1237,190 @@ 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; }
+  if (switchWatcherDelayTimer) { clearTimeout(switchWatcherDelayTimer); switchWatcherDelayTimer = null; }
   if (expectingSwitchTimer) { clearTimeout(expectingSwitchTimer); expectingSwitchTimer = null; }
   expectingSwitch = false;
   pendingSwitchTarget = null;
+  pendingInitialClearTranscript = null;
   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;
+
+  // 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
 // ============================================================
@@ -1230,6 +1573,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}`);
 }