claude-remote 0.5.1 → 0.5.2

package/lib/logger.js

@@ -0,0 +1,216 @@
+'use strict';
+
+const fs = require('fs');
+const { WebSocket } = require('ws');
+const crypto = require('crypto');
+const { state, LOG_FILE, EVENT_BUFFER_MAX } = require('./state');
+const APPROVAL_MODE_ORDER = { default: 0, partial: 1, all: 2 };
+
+// --- Logging → file only (never pollute the terminal) ---
+fs.writeFileSync(LOG_FILE, `--- Bridge started ${new Date().toISOString()} ---\n`);
+
+function log(msg) {
+  const line = `[${new Date().toISOString()}] ${msg}\n`;
+  fs.appendFileSync(LOG_FILE, line);
+}
+
+function wsLabel(ws) {
+  const clientId = ws && ws._clientInstanceId ? ` client=${ws._clientInstanceId}` : '';
+  return `ws#${ws && ws._bridgeId ? ws._bridgeId : '?'}${clientId}`;
+}
+
+function isAuthenticatedClient(ws) {
+  return !!ws && ws.readyState === WebSocket.OPEN && !!ws._authenticated;
+}
+
+function normalizeApprovalMode(mode) {
+  const normalized = String(mode || '').toLowerCase();
+  return Object.prototype.hasOwnProperty.call(APPROVAL_MODE_ORDER, normalized) ? normalized : 'default';
+}
+
+function computeConnectedHighestApprovalMode() {
+  if (!state.wss) return 'default';
+  let best = 'default';
+  let bestScore = APPROVAL_MODE_ORDER.default;
+  for (const ws of state.wss.clients) {
+    if (!isAuthenticatedClient(ws)) continue;
+    const mode = normalizeApprovalMode(ws._approvalMode);
+    const score = APPROVAL_MODE_ORDER[mode];
+    if (score > bestScore) {
+      best = mode;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+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' || 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 broadcast(msg) {
+  if (!state.wss) return;
+  const raw = JSON.stringify(msg);
+  const recipients = [];
+  for (const ws of state.wss.clients) {
+    if (isAuthenticatedClient(ws)) {
+      ws.send(raw);
+      recipients.push(wsLabel(ws));
+    }
+  }
+  if (msg.type === 'status' || msg.type === 'transcript_ready' || msg.type === 'turn_state') {
+    log(`Broadcast ${msg.type} -> ${recipients.length} client(s)${recipients.length ? ` [${recipients.join(', ')}]` : ''}`);
+  }
+}
+
+function autoResolveAllPendingApprovals(reason = '') {
+  if (state.pendingApprovals.size === 0) return;
+  for (const [id, approval] of state.pendingApprovals) {
+    clearTimeout(approval.timer);
+    approval.res.writeHead(200, { 'Content-Type': 'application/json' });
+    approval.res.end(JSON.stringify({ decision: 'allow' }));
+    log(`Permission #${id}: auto-allowed (${reason || 'effective mode switched to all'})`);
+  }
+  state.pendingApprovals.clear();
+  broadcast({ type: 'clear_permissions' });
+}
+
+function recomputeEffectiveApprovalMode(reason = '') {
+  const connectedHighest = computeConnectedHighestApprovalMode();
+  const connectedScore = APPROVAL_MODE_ORDER[connectedHighest];
+  const turnFloor = normalizeApprovalMode(state.turnApprovalFloorMode);
+  const turnFloorScore = APPROVAL_MODE_ORDER[turnFloor];
+  const floorActive = state.turnState.phase === 'running' && !!state.turnApprovalFloorMode;
+  const nextMode = (floorActive && turnFloorScore > connectedScore) ? turnFloor : connectedHighest;
+  if (state.approvalMode === nextMode) return nextMode;
+
+  const prevMode = state.approvalMode;
+  state.approvalMode = nextMode;
+  log(`Approval mode effective: ${prevMode} -> ${nextMode}${reason ? ` (${reason})` : ''} connected=${connectedHighest} turnFloor=${floorActive ? turnFloor : 'none'} phase=${state.turnState.phase}`);
+  if (nextMode === 'all' && prevMode !== 'all') {
+    autoResolveAllPendingApprovals(reason || 'effective mode switched to all');
+  }
+  return nextMode;
+}
+
+function setClientApprovalMode(ws, mode, reason = '') {
+  if (!ws) return state.approvalMode;
+  const normalized = normalizeApprovalMode(mode);
+  ws._approvalMode = normalized;
+  log(`Approval mode reported by ${wsLabel(ws)}: ${normalized}${reason ? ` (${reason})` : ''}`);
+  return recomputeEffectiveApprovalMode(`client mode update ${wsLabel(ws)}`);
+}
+
+function setTurnApprovalFloorMode(mode, reason = '') {
+  const normalized = normalizeApprovalMode(mode);
+  const prev = state.turnApprovalFloorMode || 'none';
+  state.turnApprovalFloorMode = normalized;
+  log(`Turn approval floor set: ${prev} -> ${normalized}${reason ? ` (${reason})` : ''}`);
+  return normalized;
+}
+
+function clearTurnApprovalFloorMode(reason = '') {
+  if (!state.turnApprovalFloorMode) return state.approvalMode;
+  const prev = state.turnApprovalFloorMode;
+  state.turnApprovalFloorMode = '';
+  log(`Turn approval floor cleared: ${prev}${reason ? ` (${reason})` : ''}`);
+  return recomputeEffectiveApprovalMode(`turn floor cleared${reason ? `: ${reason}` : ''}`);
+}
+
+function latestEventSeq() {
+  return state.eventBuffer.length > 0 ? state.eventBuffer[state.eventBuffer.length - 1].seq : 0;
+}
+
+function getTurnStatePayload() {
+  return {
+    type: 'turn_state',
+    phase: state.turnState.phase,
+    sessionId: state.turnState.sessionId,
+    version: state.turnState.version,
+    updatedAt: state.turnState.updatedAt,
+    reason: state.turnState.reason || '',
+  };
+}
+
+function sendTurnState(ws, context = '') {
+  return sendWs(ws, getTurnStatePayload(), context);
+}
+
+function setTurnState(phase, { sessionId = state.currentSessionId, reason = '', force = false } = {}) {
+  const normalizedPhase = phase === 'running' ? 'running' : 'idle';
+  const normalizedSessionId = sessionId || null;
+  const changed = force ||
+    state.turnState.phase !== normalizedPhase ||
+    state.turnState.sessionId !== normalizedSessionId;
+
+  if (!changed) return false;
+
+  state.turnState = {
+    phase: normalizedPhase,
+    sessionId: normalizedSessionId,
+    version: ++state.turnStateVersion,
+    updatedAt: Date.now(),
+    reason,
+  };
+
+  const modeReason = reason || `turn_state:${normalizedPhase}`;
+  if (normalizedPhase !== 'running' && state.turnApprovalFloorMode) {
+    clearTurnApprovalFloorMode(modeReason);
+  } else {
+    recomputeEffectiveApprovalMode(modeReason);
+  }
+
+  log(`Turn state -> phase=${state.turnState.phase} session=${state.turnState.sessionId ?? 'null'} version=${state.turnState.version}${reason ? ` reason=${reason}` : ''}`);
+  broadcast(getTurnStatePayload());
+  return true;
+}
+
+function emitInterrupt(source) {
+  const interruptEvent = {
+    type: 'interrupt',
+    source,
+    timestamp: Date.now(),
+    uuid: crypto.randomUUID(),
+  };
+  const record = { seq: ++state.eventSeq, event: interruptEvent };
+  state.eventBuffer.push(record);
+  if (state.eventBuffer.length > EVENT_BUFFER_MAX) {
+    state.eventBuffer = state.eventBuffer.slice(-Math.round(EVENT_BUFFER_MAX * 0.8));
+  }
+  broadcast({ type: 'log_event', seq: record.seq, event: interruptEvent });
+  setTurnState('idle', { reason: `${source}_interrupt` });
+}
+
+function formatTtyInputChunk(chunk) {
+  const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+  return `len=${buf.length} hex=${buf.toString('hex')} base64=${buf.toString('base64')} utf8=${JSON.stringify(buf.toString('utf8'))}`;
+}
+
+module.exports = {
+  log,
+  wsLabel,
+  isAuthenticatedClient,
+  sendWs,
+  broadcast,
+  latestEventSeq,
+  getTurnStatePayload,
+  sendTurnState,
+  setTurnState,
+  recomputeEffectiveApprovalMode,
+  setClientApprovalMode,
+  setTurnApprovalFloorMode,
+  clearTurnApprovalFloorMode,
+  emitInterrupt,
+  formatTtyInputChunk,
+};

package/lib/pty-manager.js

@@ -0,0 +1,162 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const pty = require('node-pty');
+const { state, CLAUDE_STATE_FILE, isTTY } = require('./state');
+const { log, broadcast, setTurnState, latestEventSeq, emitInterrupt, formatTtyInputChunk } = require('./logger');
+const { stopTailing } = require('./transcript');
+const { setupHooks } = require('./hooks');
+
+function attachTtyForwarders() {
+  if (!isTTY || state.ttyInputForwarderAttached) return;
+
+  state.ttyInputHandler = (chunk) => {
+    if (state.DEBUG_TTY_INPUT) {
+      try {
+        log(`TTY input ${formatTtyInputChunk(chunk)}`);
+      } catch (err) {
+        log(`TTY input log error: ${err.message}`);
+      }
+    }
+    if (state.claudeProc) state.claudeProc.write(chunk);
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    if (buf.includes(0x03) && state.turnState.phase === 'running') {
+      log('Terminal Ctrl+C detected — injecting interrupt event');
+      emitInterrupt('terminal');
+    }
+  };
+  state.ttyResizeHandler = () => {
+    if (state.claudeProc) state.claudeProc.resize(process.stdout.columns, process.stdout.rows);
+  };
+
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on('data', state.ttyInputHandler);
+  process.stdout.on('resize', state.ttyResizeHandler);
+  state.ttyInputForwarderAttached = true;
+}
+
+function trustProjectCwd(cwd) {
+  const resolved = path.resolve(String(cwd || ''));
+  if (!resolved) return;
+
+  let stateData = {};
+  try {
+    stateData = JSON.parse(fs.readFileSync(CLAUDE_STATE_FILE, 'utf8'));
+  } catch {}
+
+  stateData.projects = stateData.projects && typeof stateData.projects === 'object' ? stateData.projects : {};
+  const keyVariants = process.platform === 'win32'
+    ? [resolved, resolved.replace(/\\/g, '/')]
+    : [resolved];
+
+  for (const projectKey of keyVariants) {
+    const existing = stateData.projects[projectKey];
+    stateData.projects[projectKey] = {
+      ...(existing && typeof existing === 'object' ? existing : {}),
+      hasTrustDialogAccepted: true,
+      projectOnboardingSeenCount: Number.isInteger(existing?.projectOnboardingSeenCount)
+        ? existing.projectOnboardingSeenCount
+        : 0,
+    };
+  }
+
+  fs.writeFileSync(CLAUDE_STATE_FILE, JSON.stringify(stateData, null, 2));
+  log(`Trusted Claude project cwd: ${resolved}`);
+}
+
+function spawnClaude() {
+  const isWin = process.platform === 'win32';
+  const shell = isWin ? 'powershell.exe' : (process.env.SHELL || '/bin/bash');
+  const claudeCmd = state.CLAUDE_EXTRA_ARGS.length > 0
+    ? `claude ${state.CLAUDE_EXTRA_ARGS.join(' ')}`
+    : 'claude';
+  const args = isWin
+    ? ['-NoLogo', '-NoProfile', '-Command', claudeCmd]
+    : ['-c', claudeCmd];
+
+  const cols = isTTY ? process.stdout.columns : 120;
+  const rows = isTTY ? process.stdout.rows : 40;
+
+  const proc = state.claudeProc = pty.spawn(shell, args, {
+    name: 'xterm-256color',
+    cols,
+    rows,
+    cwd: state.CWD,
+    env: { ...process.env, FORCE_COLOR: '1', BRIDGE_PORT: String(state.PORT) },
+  });
+
+  log(`Claude spawned (pid ${state.claudeProc.pid}) — ${cols}x${rows} cmd="${claudeCmd}"`);
+  setTurnState('idle', { sessionId: state.currentSessionId, reason: 'claude_spawned' });
+  broadcast({
+    type: 'status',
+    status: 'running',
+    pid: proc.pid,
+    cwd: state.CWD,
+    sessionId: state.currentSessionId,
+    lastSeq: latestEventSeq(),
+  });
+
+  proc.onData((data) => {
+    if (isTTY) process.stdout.write(data);
+    broadcast({ type: 'pty_output', data });
+  });
+
+  attachTtyForwarders();
+
+  proc.onExit(({ exitCode, signal }) => {
+    if (state.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: state.currentSessionId, reason: 'pty_exit' });
+    broadcast({ type: 'pty_exit', exitCode, signal });
+    state.claudeProc = null;
+
+    if (isTTY) {
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    }
+    stopTailing();
+    log('Bridge shutting down.');
+    setTimeout(() => process.exit(exitCode || 0), 300);
+  });
+}
+
+function restartClaude(newCwd) {
+  log(`Restarting Claude with new CWD: ${newCwd}`);
+  state.CWD = newCwd;
+  try {
+    trustProjectCwd(state.CWD);
+  } catch (err) {
+    log(`Failed to trust Claude project cwd "${state.CWD}": ${err.message}`);
+  }
+
+  stopTailing();
+
+  state.currentSessionId = null;
+  state.transcriptPath = null;
+  state.transcriptOffset = 0;
+  state.eventBuffer = [];
+  state.eventSeq = 0;
+  state.tailCatchingUp = false;
+  setTurnState('idle', { sessionId: null, reason: 'restart_claude' });
+
+  const procToRestart = state.claudeProc;
+  state.claudeProc = null;
+  if (procToRestart) {
+    procToRestart.kill();
+  }
+
+  setupHooks();
+  broadcast({ type: 'cwd_changed', cwd: state.CWD, sessionId: null, lastSeq: 0 });
+  spawnClaude();
+}
+
+module.exports = {
+  spawnClaude,
+  restartClaude,
+  attachTtyForwarders,
+};

package/lib/state.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const path = require('path');
+const os = require('os');
+
+// --- Paths ---
+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');
+const LOG_FILE = path.join(CLAUDE_HOME, 'bridge.log');
+const TOKEN_FILE = path.join(os.homedir(), '.claude-remote-token');
+const IMAGE_UPLOAD_DIR = os.tmpdir();
+
+// --- Constants ---
+const AUTH_HELLO_TIMEOUT_MS = 5000;
+const WS_CLOSE_AUTH_FAILED = 4001;
+const WS_CLOSE_AUTH_TIMEOUT = 4002;
+const WS_CLOSE_REASON_AUTH_FAILED = 'auth_failed';
+const WS_CLOSE_REASON_AUTH_TIMEOUT = 'auth_timeout';
+const EVENT_BUFFER_MAX = 5000;
+const LEGACY_REPLAY_DELAY_MS = 1500;
+const IMAGE_UPLOAD_TTL_MS = 15 * 60 * 1000;
+const LINUX_CLIPBOARD_READY_GRACE_MS = 400;
+const LINUX_AT_PROMPT_SUBMIT_DELAY_MS = 450;
+const LINUX_AT_IMAGE_CLEANUP_DELAY_MS = 10 * 60 * 1000;
+
+// --- Auto-allow sets ---
+const ALWAYS_AUTO_ALLOW = new Set(['TaskCreate', 'TaskUpdate']);
+const PARTIAL_AUTO_ALLOW = new Set(['Read', 'Glob', 'Grep', 'Write', 'Edit']);
+
+// --- TTY ---
+const isTTY = process.stdin.isTTY && process.stdout.isTTY;
+
+// --- Mutable shared state ---
+const state = {
+  // Config (set once at startup)
+  PORT: 3100,
+  CWD: process.cwd(),
+  AUTH_TOKEN: null,
+  AUTH_DISABLED: false,
+  CLAUDE_EXTRA_ARGS: [],
+  DEBUG_TTY_INPUT: false,
+
+  // PTY
+  claudeProc: null,
+
+  // Transcript
+  transcriptPath: null,
+  currentSessionId: null,
+  transcriptOffset: 0,
+  eventBuffer: [],
+  eventSeq: 0,
+  tailTimer: null,
+  tailRemainder: Buffer.alloc(0),
+  tailCatchingUp: false,
+
+  // Session switch
+  switchWatcher: null,
+  switchWatcherDelayTimer: null,
+  expectingSwitch: false,
+  expectingSwitchTimer: null,
+  pendingSwitchTarget: null,
+  pendingInitialClearTranscript: null,
+
+  // Turn state
+  turnStateVersion: 0,
+  turnState: {
+    phase: 'idle',
+    sessionId: null,
+    version: 0,
+    updatedAt: Date.now(),
+  },
+
+  // WebSocket
+  wss: null,
+  nextWsId: 0,
+
+  // Permission approval
+  approvalSeq: 0,
+  pendingApprovals: new Map(),
+  pendingImageUploads: new Map(),
+  approvalMode: 'default',
+  turnApprovalFloorMode: '',
+
+  // TTY forwarders
+  ttyInputForwarderAttached: false,
+  ttyInputHandler: null,
+  ttyResizeHandler: null,
+
+  // Linux clipboard
+  activeLinuxClipboardProc: null,
+  linuxImagePasteInFlight: false,
+};
+
+module.exports = {
+  state,
+  CLAUDE_HOME,
+  CLAUDE_STATE_FILE,
+  PROJECTS_DIR,
+  LOG_FILE,
+  TOKEN_FILE,
+  IMAGE_UPLOAD_DIR,
+  AUTH_HELLO_TIMEOUT_MS,
+  WS_CLOSE_AUTH_FAILED,
+  WS_CLOSE_AUTH_TIMEOUT,
+  WS_CLOSE_REASON_AUTH_FAILED,
+  WS_CLOSE_REASON_AUTH_TIMEOUT,
+  EVENT_BUFFER_MAX,
+  LEGACY_REPLAY_DELAY_MS,
+  IMAGE_UPLOAD_TTL_MS,
+  LINUX_CLIPBOARD_READY_GRACE_MS,
+  LINUX_AT_PROMPT_SUBMIT_DELAY_MS,
+  LINUX_AT_IMAGE_CLEANUP_DELAY_MS,
+  ALWAYS_AUTO_ALLOW,
+  PARTIAL_AUTO_ALLOW,
+  isTTY,
+};