@oar-sh/oar 0.9.0

package/server/services/tmux-inspector-stream-service.mjs

@@ -0,0 +1,552 @@
+'use strict';
+
+import { execFileSync, spawn } from 'child_process';
+import {
+  isTmuxAvailable,
+  normalizeTmuxSessionName,
+  tmuxSessionExists,
+} from './session-worker-launch-service.mjs';
+
+function normalizeSessionId(value) {
+  const text = String(value || '').trim();
+  return text || '';
+}
+
+function normalizeWatcherId(value) {
+  const text = String(value || '').trim();
+  return text || '';
+}
+
+function normalizeLineCount(value, fallback = 1000) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  const whole = Math.trunc(n);
+  if (whole < 50) return 50;
+  if (whole > 20_000) return 20_000;
+  return whole;
+}
+
+function normalizeIntervalMs(value, fallback = 700) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  const whole = Math.trunc(n);
+  if (whole < 200) return 200;
+  if (whole > 5_000) return 5_000;
+  return whole;
+}
+
+function normalizeCols(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const whole = Math.trunc(n);
+  if (whole < 80 || whole > 400) return null;
+  return whole;
+}
+
+function normalizeRows(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return null;
+  const whole = Math.trunc(n);
+  if (whole < 24 || whole > 120) return null;
+  return whole;
+}
+
+function computeChunk(previousText, nextText) {
+  const previous = String(previousText || '');
+  const next = String(nextText || '');
+  if (next === previous) return null;
+  if (!previous) return { kind: 'snapshot', data: next };
+  if (next.startsWith(previous)) {
+    return { kind: 'delta', data: next.slice(previous.length) };
+  }
+  return { kind: 'reset', data: next };
+}
+
+function createTmuxCaptureReader({
+  execFileSyncImpl = execFileSync,
+} = {}) {
+  return function readCapture(sessionName, {
+    historyLines = 1000,
+  } = {}) {
+    const output = execFileSyncImpl('tmux', [
+      'capture-pane',
+      '-p',
+      '-e',
+      '-J',
+      '-S',
+      `-${normalizeLineCount(historyLines, 1000)}`,
+      '-t',
+      sessionName,
+    ], {
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return String(output || '');
+  };
+}
+
+export function createTmuxInspectorStreamService({
+  platform = process.platform,
+  execFileSyncImpl = execFileSync,
+  spawnImpl = spawn,
+  tmuxAvailable = null,
+  historyLines = 1200,
+  pollIntervalMs = 700,
+  watchdogIntervalMs = 1000,
+  preferByteStream = platform !== 'win32',
+  isSessionAllowed = () => ({ ok: true }),
+  nowIso = () => new Date().toISOString(),
+} = {}) {
+  const readCapture = createTmuxCaptureReader({ execFileSyncImpl });
+  const watchersBySession = new Map();
+  const sessionByWatcher = new Map();
+  const streamBySession = new Map();
+  const lines = normalizeLineCount(historyLines, 1200);
+  const intervalMs = normalizeIntervalMs(pollIntervalMs, 700);
+  const watchdogMs = normalizeIntervalMs(watchdogIntervalMs, 1000);
+
+  const tmuxReady = tmuxAvailable === null
+    ? isTmuxAvailable({ platform, execFileSyncImpl })
+    : (tmuxAvailable === true);
+
+  function emitStatusToSession(sdkSessionId, payload = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap || watcherMap.size === 0) return;
+    for (const watcher of watcherMap.values()) {
+      try {
+        watcher?.onStatus?.({
+          type: 'tmux_inspector_status',
+          sdkSessionId: sid,
+          timestamp: nowIso(),
+          ...payload,
+        });
+      } catch {
+        // watcher callbacks are isolated
+      }
+    }
+  }
+
+  function emitChunkToSession(sdkSessionId, payload = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap || watcherMap.size === 0) return;
+    for (const watcher of watcherMap.values()) {
+      try {
+        watcher?.onChunk?.({
+          type: 'tmux_inspector_chunk',
+          sdkSessionId: sid,
+          timestamp: nowIso(),
+          ...payload,
+        });
+      } catch {
+        // watcher callbacks are isolated
+      }
+    }
+  }
+
+  function clearStream(sdkSessionId) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    const stream = streamBySession.get(sid);
+    if (stream?.watchdogTimer) {
+      clearInterval(stream.watchdogTimer);
+    }
+    if (stream?.timer) {
+      clearInterval(stream.timer);
+    }
+    if (stream?.process && typeof stream.process.kill === 'function') {
+      stream.closing = true;
+      try {
+        stream.process.kill('SIGTERM');
+      } catch {}
+    }
+    streamBySession.delete(sid);
+  }
+
+  function stopWatchingSession(sdkSessionId, { reason = 'watch-stopped', code = null } = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    clearStream(sid);
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap || watcherMap.size === 0) return;
+    emitStatusToSession(sid, {
+      state: 'ended',
+      reason,
+      code,
+    });
+  }
+
+  function pollSession(sdkSessionId) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap || watcherMap.size === 0) {
+      clearStream(sid);
+      return;
+    }
+
+    const allowed = isSessionAllowed(sid);
+    if (!allowed?.ok) {
+      stopWatchingSession(sid, {
+        reason: allowed?.reason || 'session-not-allowed',
+        code: allowed?.code || 'session-not-allowed',
+      });
+      return;
+    }
+
+    const sessionName = normalizeTmuxSessionName(sid);
+    if (!tmuxSessionExists(sessionName, { execFileSyncImpl })) {
+      stopWatchingSession(sid, {
+        reason: 'tmux-session-not-found',
+        code: 'tmux-session-not-found',
+      });
+      return;
+    }
+
+    const stream = streamBySession.get(sid);
+    if (!stream) return;
+
+    let nextSnapshot = '';
+    try {
+      nextSnapshot = readCapture(sessionName, { historyLines: lines });
+    } catch {
+      stopWatchingSession(sid, {
+        reason: 'tmux-capture-failed',
+        code: 'tmux-capture-failed',
+      });
+      return;
+    }
+
+    const chunk = computeChunk(stream.lastSnapshot, nextSnapshot);
+    stream.lastSnapshot = nextSnapshot;
+    if (!chunk?.data) return;
+    emitChunkToSession(sid, {
+      chunkKind: chunk.kind,
+      data: chunk.data,
+    });
+  }
+
+  function watchSessionHealth(sdkSessionId) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return false;
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap || watcherMap.size === 0) {
+      clearStream(sid);
+      return false;
+    }
+    const allowed = isSessionAllowed(sid);
+    if (!allowed?.ok) {
+      stopWatchingSession(sid, {
+        reason: allowed?.reason || 'session-not-allowed',
+        code: allowed?.code || 'session-not-allowed',
+      });
+      return false;
+    }
+    const sessionName = normalizeTmuxSessionName(sid);
+    if (!tmuxSessionExists(sessionName, { execFileSyncImpl })) {
+      stopWatchingSession(sid, {
+        reason: 'tmux-session-not-found',
+        code: 'tmux-session-not-found',
+      });
+      return false;
+    }
+    return true;
+  }
+
+  function ensureWatchdog(sdkSessionId) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    const stream = streamBySession.get(sid);
+    if (!stream || stream.watchdogTimer) return;
+    const watchdogTimer = setInterval(() => {
+      watchSessionHealth(sid);
+    }, watchdogMs);
+    if (typeof watchdogTimer.unref === 'function') watchdogTimer.unref();
+    stream.watchdogTimer = watchdogTimer;
+  }
+
+  function ensureSessionByteStream(sdkSessionId, sessionName) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return false;
+    if (streamBySession.has(sid)) return true;
+    if (!preferByteStream || platform === 'win32') return false;
+    const child = spawnImpl('script', [
+      '-q',
+      '-f',
+      '/dev/null',
+      'tmux',
+      'attach-session',
+      '-r',
+      '-t',
+      sessionName,
+    ], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const stream = {
+      mode: 'byte',
+      process: child,
+      closing: false,
+      watchdogTimer: null,
+    };
+    streamBySession.set(sid, stream);
+    ensureWatchdog(sid);
+
+    if (child.stdout) {
+      child.stdout.on('data', (chunk) => {
+        const data = String(chunk || '');
+        if (!data) return;
+        emitChunkToSession(sid, {
+          chunkKind: 'byte',
+          data,
+        });
+      });
+    }
+
+    const onByteStreamEnded = () => {
+      const current = streamBySession.get(sid);
+      if (!current || current !== stream) return;
+      const hadWatchers = (watchersBySession.get(sid)?.size || 0) > 0;
+      clearStream(sid);
+      if (!hadWatchers) return;
+      const sessionStillHealthy = watchSessionHealth(sid);
+      if (!sessionStillHealthy) return;
+      // Byte stream failed while session remains healthy; degrade to snapshot polling.
+      ensureSessionPolling(sid);
+      emitStatusToSession(sid, {
+        state: 'stream-fallback',
+        reason: 'byte-stream-ended-falling-back-to-snapshot',
+        code: 'byte-stream-ended',
+      });
+    };
+
+    child.on('error', onByteStreamEnded);
+    child.on('exit', () => {
+      if (stream.closing) return;
+      onByteStreamEnded();
+    });
+    return true;
+  }
+
+  function ensureSessionPolling(sdkSessionId) {
+    const sid = normalizeSessionId(sdkSessionId);
+    if (!sid) return;
+    if (streamBySession.has(sid)) return;
+    const timer = setInterval(() => pollSession(sid), intervalMs);
+    if (typeof timer.unref === 'function') timer.unref();
+    streamBySession.set(sid, {
+      mode: 'snapshot',
+      timer,
+      lastSnapshot: '',
+      watchdogTimer: null,
+    });
+    ensureWatchdog(sid);
+  }
+
+  function attach({
+    sdkSessionId,
+    watcherId,
+    onChunk = () => {},
+    onStatus = () => {},
+  } = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    const wid = normalizeWatcherId(watcherId);
+    if (!sid) return { ok: false, code: 'missing-session-id', reason: 'Missing sdkSessionId' };
+    if (!wid) return { ok: false, code: 'missing-watcher-id', reason: 'Missing watcher id' };
+    if (!tmuxReady) {
+      return { ok: false, code: 'tmux-unavailable', reason: 'tmux is unavailable on this relay host' };
+    }
+
+    const allowed = isSessionAllowed(sid);
+    if (!allowed?.ok) {
+      return {
+        ok: false,
+        code: allowed?.code || 'session-not-allowed',
+        reason: allowed?.reason || 'Session is not active in the relay',
+      };
+    }
+
+    const sessionName = normalizeTmuxSessionName(sid);
+    if (!tmuxSessionExists(sessionName, { execFileSyncImpl })) {
+      return {
+        ok: false,
+        code: 'tmux-session-not-found',
+        reason: `tmux session "${sid}" was not found`,
+      };
+    }
+
+    let snapshot = '';
+    try {
+      snapshot = readCapture(sessionName, { historyLines: lines });
+    } catch (error) {
+      return {
+        ok: false,
+        code: 'tmux-capture-failed',
+        reason: String(error?.message || 'Failed to capture tmux pane'),
+      };
+    }
+
+    const existingSessionId = sessionByWatcher.get(wid);
+    if (existingSessionId && existingSessionId !== sid) {
+      detach({ sdkSessionId: existingSessionId, watcherId: wid });
+    }
+
+    let watcherMap = watchersBySession.get(sid);
+    if (!watcherMap) {
+      watcherMap = new Map();
+      watchersBySession.set(sid, watcherMap);
+    }
+    watcherMap.set(wid, { onChunk, onStatus });
+    sessionByWatcher.set(wid, sid);
+    if (!ensureSessionByteStream(sid, sessionName)) {
+      ensureSessionPolling(sid);
+    }
+
+    const stream = streamBySession.get(sid);
+    if (stream?.mode === 'snapshot') {
+      stream.lastSnapshot = snapshot;
+    }
+
+    return {
+      ok: true,
+      sdkSessionId: sid,
+      snapshot,
+      watcherCount: watcherMap.size,
+      code: 'attached',
+    };
+  }
+
+  function detach({
+    sdkSessionId,
+    watcherId,
+  } = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    const wid = normalizeWatcherId(watcherId);
+    if (!sid || !wid) return { ok: false, removed: false };
+    const watcherMap = watchersBySession.get(sid);
+    if (!watcherMap) return { ok: true, removed: false };
+    const removed = watcherMap.delete(wid);
+    if (sessionByWatcher.get(wid) === sid) {
+      sessionByWatcher.delete(wid);
+    }
+    if (watcherMap.size === 0) {
+      watchersBySession.delete(sid);
+      clearStream(sid);
+    }
+    return {
+      ok: true,
+      removed,
+      watcherCount: watcherMap.size,
+    };
+  }
+
+  function detachWatcher(watcherId) {
+    const wid = normalizeWatcherId(watcherId);
+    if (!wid) return 0;
+    const sid = sessionByWatcher.get(wid);
+    if (!sid) return 0;
+    const result = detach({ sdkSessionId: sid, watcherId: wid });
+    return result?.removed ? 1 : 0;
+  }
+
+  function isWatcherAttached({ sdkSessionId, watcherId } = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    const wid = normalizeWatcherId(watcherId);
+    if (!sid || !wid) return false;
+    const watcherMap = watchersBySession.get(sid);
+    return watcherMap instanceof Map && watcherMap.has(wid);
+  }
+
+  function resizeSession({
+    sdkSessionId,
+    watcherId,
+    cols,
+    rows,
+  } = {}) {
+    const sid = normalizeSessionId(sdkSessionId);
+    const wid = normalizeWatcherId(watcherId);
+    const nextCols = normalizeCols(cols);
+    const nextRows = normalizeRows(rows);
+    if (!sid) return { ok: false, code: 'missing-session-id', reason: 'Missing sdkSessionId' };
+    if (!wid) return { ok: false, code: 'missing-watcher-id', reason: 'Missing watcher id' };
+    if (!nextCols || !nextRows) {
+      return { ok: false, code: 'invalid-size', reason: 'Invalid terminal size' };
+    }
+    if (!isWatcherAttached({ sdkSessionId: sid, watcherId: wid })) {
+      return { ok: false, code: 'not-attached', reason: 'Watcher is not attached to session' };
+    }
+    if (!tmuxReady) {
+      return { ok: false, code: 'tmux-unavailable', reason: 'tmux unavailable' };
+    }
+    const sessionName = normalizeTmuxSessionName(sid);
+    if (!tmuxSessionExists(sessionName, { execFileSyncImpl })) {
+      return { ok: false, code: 'tmux-session-not-found', reason: 'tmux session not found' };
+    }
+    try {
+      execFileSyncImpl('tmux', [
+        'resize-window',
+        '-t',
+        sessionName,
+        '-x',
+        String(nextCols),
+        '-y',
+        String(nextRows),
+      ], {
+        stdio: ['ignore', 'ignore', 'ignore'],
+      });
+      return {
+        ok: true,
+        code: 'resized',
+        cols: nextCols,
+        rows: nextRows,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        code: 'tmux-resize-failed',
+        reason: String(error?.message || 'tmux resize failed'),
+      };
+    }
+  }
+
+  function stopAll() {
+    for (const sid of streamBySession.keys()) {
+      clearStream(sid);
+    }
+    streamBySession.clear();
+    watchersBySession.clear();
+    sessionByWatcher.clear();
+  }
+
+  function status() {
+    const sessions = [];
+    let watcherCount = 0;
+    for (const [sdkSessionId, watchers] of watchersBySession.entries()) {
+      const count = watchers.size;
+      watcherCount += count;
+      sessions.push({
+        sdkSessionId,
+        watcherCount: count,
+      });
+    }
+    return {
+      enabled: tmuxReady,
+      watchedSessionCount: sessions.length,
+      watcherCount,
+      sessions,
+    };
+  }
+
+  return {
+    attach,
+    detach,
+    detachWatcher,
+    isWatcherAttached,
+    resizeSession,
+    stopWatchingSession,
+    pollNow: (sdkSessionId) => pollSession(sdkSessionId),
+    stopAll,
+    status,
+  };
+}

package/server/services/tunnel-worker-path-guard.mjs

@@ -0,0 +1,107 @@
+'use strict';
+
+import { URL } from 'url';
+
+import { buildAcceptedWorkerPaths } from './session-worker-websocket-service.mjs';
+
+// Cloudflare's edge stamps `cf-ray` on every proxied request and a remote client
+// cannot strip it, so its presence means the request came in over the tunnel
+// rather than from a local session worker on 127.0.0.1.
+const DEFAULT_TUNNEL_MARKER_HEADERS = ['cf-ray'];
+
+function normalizeHeaderName(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function normalizeMarkerHeaders(extraHeaders) {
+  const names = [...DEFAULT_TUNNEL_MARKER_HEADERS];
+  const extras = Array.isArray(extraHeaders)
+    ? extraHeaders
+    : String(extraHeaders || '').split(',');
+  for (const entry of extras) {
+    const name = normalizeHeaderName(entry);
+    if (name && !names.includes(name)) names.push(name);
+  }
+  return names;
+}
+
+function requestPathname(req) {
+  const rawUrl = String(req?.url || '/');
+  try {
+    return new URL(rawUrl, 'http://localhost').pathname;
+  } catch {
+    return rawUrl.split('?')[0] || '/';
+  }
+}
+
+/**
+ * Blocks session-worker WebSocket paths when the request arrived through a
+ * public tunnel. The guard keys off *the path being a worker path*, never off
+ * "unauthenticated request bearing cf-ray" — shared conversations legitimately
+ * arrive over Cloudflare with no credentials and must keep working.
+ */
+export function createTunnelWorkerPathGuard({
+  pathPrefix = '',
+  extraMarkerHeaders = [],
+  logger = console,
+} = {}) {
+  const workerPaths = new Set(buildAcceptedWorkerPaths(pathPrefix));
+  const markerHeaders = normalizeMarkerHeaders(extraMarkerHeaders);
+
+  function isWorkerPath(pathname) {
+    if (workerPaths.has(pathname)) return true;
+    // The prefix is stripped later in the express pipeline, so tolerate both forms.
+    for (const workerPath of workerPaths) {
+      if (pathname === workerPath || pathname === `${workerPath}/`) return true;
+    }
+    return false;
+  }
+
+  function matchedMarkerHeader(headers) {
+    if (!headers) return null;
+    for (const name of markerHeaders) {
+      const value = headers[name];
+      if (typeof value === 'string' ? value.trim() : value) return name;
+    }
+    return null;
+  }
+
+  function evaluate(req) {
+    const pathname = requestPathname(req);
+    if (!isWorkerPath(pathname)) return { blocked: false, pathname, marker: null };
+    const marker = matchedMarkerHeader(req?.headers);
+    if (!marker) return { blocked: false, pathname, marker: null };
+    return { blocked: true, pathname, marker };
+  }
+
+  // Express middleware: 403 the request before any auth middleware runs.
+  function requestMiddleware(req, res, next) {
+    const result = evaluate(req);
+    if (!result.blocked) {
+      next();
+      return;
+    }
+    logger?.warn?.(`[tunnel-guard] Blocked session-worker path ${result.pathname} carrying ${result.marker}`);
+    res.status(403).json({ error: 'Session worker endpoints are not reachable through the tunnel' });
+  }
+
+  // Raw upgrade guard: destroy the socket before the WebSocket handshake.
+  function handleUpgrade(req, socket) {
+    const result = evaluate(req);
+    if (!result.blocked) return false;
+    logger?.warn?.(`[tunnel-guard] Blocked session-worker upgrade ${result.pathname} carrying ${result.marker}`);
+    try {
+      socket.write('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n');
+    } catch {}
+    try { socket.destroy(); } catch {}
+    return true;
+  }
+
+  return {
+    markerHeaders,
+    workerPaths: [...workerPaths],
+    evaluate,
+    requestMiddleware,
+    handleUpgrade,
+  };
+}

package/server/services/upload-sweep.mjs

@@ -0,0 +1,60 @@
+// Reclaims upload blobs that no reference will ever point at.
+//
+// Uploads are eager, so a blob can exist before anything references it: pasting
+// into a conversation that is then abandoned, or switching conversations while
+// an upload is in flight. Conversation-scoped sweeps only ever visit blobs that
+// already have a reference, so these would otherwise stay on disk forever.
+
+export const UNREFERENCED_UPLOAD_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+
+/**
+ * Selects unreferenced blobs old enough that no upload can still be in flight
+ * for them. Rows without a usable timestamp are left alone rather than guessed
+ * at, since deleting a blob that is still being attached is far worse than
+ * keeping a stale one.
+ */
+export function collectUnreferencedUploads(rows = [], {
+  now = Date.now(),
+  maxAgeMs = UNREFERENCED_UPLOAD_MAX_AGE_MS,
+} = {}) {
+  const cutoff = now - Math.max(0, Number(maxAgeMs) || 0);
+  const collected = [];
+  for (const row of (Array.isArray(rows) ? rows : [])) {
+    const sha256 = String(row?.sha256 || '').trim().toLowerCase();
+    if (!SHA256_PATTERN.test(sha256)) continue;
+    const createdAt = Date.parse(String(row?.created_at || ''));
+    if (!Number.isFinite(createdAt)) continue;
+    if (createdAt >= cutoff) continue;
+    collected.push(sha256);
+  }
+  return collected;
+}
+
+export const UNREFERENCED_UPLOADS_QUERY = `
+  SELECT f.sha256, f.created_at
+  FROM uploaded_files f
+  LEFT JOIN upload_refs r ON r.file_sha256 = f.sha256
+  WHERE r.id IS NULL
+`;
+
+/**
+ * Runs one sweep. Never throws: a failed reclaim must not take the relay down.
+ */
+export function sweepUnreferencedUploads({
+  listUnreferenced,
+  deleteUploads,
+  now = Date.now(),
+  maxAgeMs = UNREFERENCED_UPLOAD_MAX_AGE_MS,
+} = {}) {
+  try {
+    if (typeof listUnreferenced !== 'function' || typeof deleteUploads !== 'function') return 0;
+    const stale = collectUnreferencedUploads(listUnreferenced() || [], { now, maxAgeMs });
+    if (!stale.length) return 0;
+    deleteUploads(stale);
+    return stale.length;
+  } catch {
+    return 0;
+  }
+}