@logicseek/hello-cc 0.1.8 → 1.0.0

package/lib/web/tmux-stream.mjs

@@ -0,0 +1,166 @@
+// tmux terminal streaming/snapshot helpers extracted from cmdWeb.
+// These manage the raw pipe-pane FIFO → WebSocket data path and the
+// capture-pane fallback for tmux-backed sessions.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { runTmux, tmuxCapturePane, tmuxCursorInfo, tmuxCursorPayload } from '../terminal/tmux.mjs';
+import { CliError } from '../shared/errors.mjs';
+
+export function createTmuxStream({
+  broadcast,
+  now,
+  refreshPeerIoHeartbeat,
+  bufferDirectory,
+  withBufferDirectoryLease,
+  shellQuoteArg,
+  ctx
+}) {
+  function cursorEscape(payload) {
+    if (!payload) return '';
+    return '[' + (payload.row + 1) + ';' + (payload.col + 1) + 'H' +
+      (payload.visible ? '[?25h' : '[?25l');
+  }
+
+  function tmuxSnapshot(session) {
+    const captured = tmuxCapturePane(session.pane);
+    return captured + cursorEscape(tmuxCursorPayload(captured, tmuxCursorInfo(session.pane)));
+  }
+
+  function refreshTmuxSnapshot(session) {
+    if (session.type !== 'tmux' || !session.pane) return session.buffer || '';
+    try {
+      session.buffer = tmuxSnapshot(session);
+    } catch {
+      // Keep the previous buffer if the pane disappears during capture.
+    }
+    return session.buffer || '';
+  }
+
+  function scheduleTmuxReplace(session) {
+    if (session.type !== 'tmux' || !session.pane) return;
+    if (session.replaceTimer) clearTimeout(session.replaceTimer);
+    session.replaceTimer = setTimeout(() => {
+      session.replaceTimer = null;
+      session.lastBroadcastTime = Date.now();
+      broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
+    }, 80);
+  }
+
+  function startTmuxReplacePoller(session, warning = null) {
+    if (session.replacePoller) clearInterval(session.replacePoller);
+    if (warning) {
+      session.warning = {
+        code: 'TMUX_STREAM_FALLBACK',
+        message: `Raw tmux streaming unavailable; using capture polling: ${warning}`
+      };
+    }
+    session.lastBroadcastTime = Date.now();
+    session.replacePoller = setInterval(() => {
+      if (session.status !== 'running') return;
+      if (Date.now() - (session.lastBroadcastTime || 0) > 4000) {
+        session.lastBroadcastTime = Date.now();
+        broadcast(session, { type: 'replace', data: refreshTmuxSnapshot(session) });
+      }
+    }, 1600);
+  }
+
+  function startTmuxStream(session) {
+    const safePane = String(session.pane).replace(/[^A-Za-z0-9_-]/g, '');
+    const safeId = String(session.id).replace(/[^A-Za-z0-9_.-]/g, '_');
+    const streamDirectory = bufferDirectory(session.ctx || ctx);
+    fs.mkdirSync(streamDirectory, { recursive: true });
+    const pipeFile = path.join(streamDirectory, `tmux-${safePane}-${safeId}.pipe`);
+    session.pipeFile = pipeFile;
+    try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
+    try {
+      session.buffer = tmuxSnapshot(session);
+    } catch {}
+
+    try {
+      withBufferDirectoryLease(path.dirname(pipeFile), () => {
+        fs.rmSync(pipeFile, { force: true });
+        const mkfifo = spawnSync('mkfifo', [pipeFile], {
+          encoding: 'utf8',
+          stdio: ['ignore', 'pipe', 'pipe']
+        });
+        if (mkfifo.status !== 0) {
+          const message = (mkfifo.stderr || mkfifo.stdout || '').trim() || 'mkfifo failed';
+          throw new CliError('TMUX_STREAM_ERROR', message);
+        }
+        try { fs.chmodSync(pipeFile, 0o600); } catch {}
+        session.streamFd = fs.openSync(pipeFile, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
+      });
+    } catch (err) {
+      const message = err?.message || String(err);
+      stopTmuxStream(session);
+      startTmuxReplacePoller(session, message);
+      return 'poll';
+    }
+
+    try {
+      runTmux(['pipe-pane', '-t', session.pane, `cat > ${shellQuoteArg(pipeFile)}`]);
+    } catch (err) {
+      stopTmuxStream(session);
+      startTmuxReplacePoller(session, err?.message || String(err));
+      return 'poll';
+    }
+    session.streamPoller = setInterval(() => {
+      try {
+        if (session.streamFd === null || session.streamFd === undefined) return;
+        const chunks = [];
+        for (;;) {
+          const buf = Buffer.alloc(65536);
+          let bytes = 0;
+          try {
+            bytes = fs.readSync(session.streamFd, buf, 0, buf.length, null);
+          } catch (err) {
+            if (['EAGAIN', 'EWOULDBLOCK'].includes(err?.code)) break;
+            throw err;
+          }
+          if (bytes <= 0) break;
+          chunks.push(buf.subarray(0, bytes));
+          if (bytes < buf.length) break;
+        }
+        if (!chunks.length) return;
+        const data = Buffer.concat(chunks).toString();
+        session.buffer += data;
+        if (session.buffer.length > 250000) session.buffer = session.buffer.slice(-200000);
+        session.lastBroadcastTime = Date.now();
+        broadcast(session, { type: 'data', data });
+        refreshPeerIoHeartbeat(session);
+      } catch {
+        if (session.streamFd !== null && session.streamFd !== undefined) {
+          try { fs.closeSync(session.streamFd); } catch {}
+          session.streamFd = null;
+        }
+      }
+    }, 40);
+
+    startTmuxReplacePoller(session);
+    return 'stream';
+  }
+
+  function stopTmuxStream(session) {
+    if (session.streamPoller) { clearInterval(session.streamPoller); session.streamPoller = null; }
+    if (session.replacePoller) { clearInterval(session.replacePoller); session.replacePoller = null; }
+    if (session.replaceTimer) { clearTimeout(session.replaceTimer); session.replaceTimer = null; }
+    if (session.inputRefreshTimer) { clearTimeout(session.inputRefreshTimer); session.inputRefreshTimer = null; }
+    try { runTmux(['pipe-pane', '-t', session.pane]); } catch {}
+    if (session.streamFd !== null && session.streamFd !== undefined) {
+      try { fs.closeSync(session.streamFd); } catch {}
+      session.streamFd = null;
+    }
+    if (session.pipeFile) {
+      try {
+        withBufferDirectoryLease(path.dirname(session.pipeFile), () => {
+          fs.unlinkSync(session.pipeFile);
+        });
+      } catch {}
+      session.pipeFile = null;
+    }
+  }
+
+  return { cursorEscape, tmuxSnapshot, refreshTmuxSnapshot, scheduleTmuxReplace, startTmuxReplacePoller, startTmuxStream, stopTmuxStream };
+}

package/lib/web/ui-template.mjs

@@ -1,4 +1,15 @@
-export function webIndexHtml() {
+import { API_VERSION } from './api-version.mjs';
+
+function nonceAttribute(nonce) {
+  const value = String(nonce || '');
+  if (!/^[A-Za-z0-9_-]{16,}$/.test(value)) {
+    throw new Error('A valid CSP nonce is required');
+  }
+  return ` nonce="${value}"`;
+}
+
+export function webIndexHtml({ nonce } = {}) {
+  const inlineScriptNonce = nonceAttribute(nonce);
   return `<!doctype html>
 <html lang="en">
 <head>
@@ -169,10 +180,12 @@ export function webIndexHtml() {
       white-space: nowrap;
     }
     #connState {
-      flex: 0 0 92px;
-      max-width: 92px;
+      flex: 0 1 72px;
+      max-width: 72px;
       text-align: right;
     }
+    .brand-actions { display: flex; align-items: center; gap: 4px; min-width: 0; }
+    .brand-actions button { width: 26px; height: 26px; padding: 0; font-size: 14px; }
     .form {
       padding: 12px;
       display: grid;
@@ -534,7 +547,10 @@ export function webIndexHtml() {
           <strong>hello-cc</strong>
           <div class="path" id="rootPath"></div>
         </div>
-        <span id="connState" data-i18n="conn.offline">offline</span>
+        <div class="brand-actions">
+          <span id="connState" data-i18n="conn.offline">offline</span>
+          <button id="logoutBtn" type="button" data-i18n-title="logout" data-i18n-aria="logout" title="Log out" aria-label="Log out">↪</button>
+        </div>
       </div>
       <div class="form" style="padding-top:10px;padding-bottom:10px">
         <div class="grid2">
@@ -624,16 +640,25 @@ export function webIndexHtml() {
   </div>
 
   <script src="/assets/xterm.js"></script>
-  <script>
+  <script${inlineScriptNonce}>
     const initialParams = new URLSearchParams(location.search);
+    sessionStorage.removeItem('hcc_logged_out');
     const token = initialParams.get('token') || '';
-    const headers = token ? { Authorization: 'Bearer ' + token } : {};
+    const runtimeApiVersion = ${API_VERSION};
+    const headers = {
+      'X-HCC-API-Version': String(runtimeApiVersion),
+      ...(token ? { Authorization: 'Bearer ' + token } : {})
+    };
     let currentProject = initialParams.get('project') || initialParams.get('root') || '';
     let projects = [];
     let sessionKindFilter = initialParams.get('kind') || 'all';
     let sessions  = [];    // managed (PTY) sessions
     let detected  = [];    // coordination-only peers (from hooks/watcher)
     let resumableCache = []; // provider sessions available to resume (from /api/resumable)
+    // The current token belongs to one terminal WebSocket connection and is
+    // replaced on every reconnect.
+    const sessionActionTokens = new Map();
+    const pendingTerminalInput = new Map();
     let active    = null;  // active managed session id
     let activeDetected = null; // active detected peer id
     let activeType = 'managed'; // 'managed' | 'detected'
@@ -643,6 +668,9 @@ export function webIndexHtml() {
     let lastStateRoot = '';
     let ws        = null;
     let wsReconnectTimer = null;
+    // ui-4: after logout (or repeated failed reconnects) the WS must not loop
+    // forever every 2s against a server that now rejects the upgrade.
+    let wsReconnectFailures = 0;
     let terminalHasContent = false;
     let terminalLastDataAt = 0;
     let terminalLastResizeAt = 0;
@@ -681,6 +709,7 @@ export function webIndexHtml() {
         'action.renewHeartbeat': 'renew heartbeat',
         'action.reregister': 're-register peer',
         'action.runStatusTerminal': 'run status in terminal',
+        logout: 'log out',
         actionResult: 'Action Result',
         stop: 'stop',
         projectState: 'Project State',
@@ -804,6 +833,7 @@ export function webIndexHtml() {
         'action.renewHeartbeat': '续期心跳',
         'action.reregister': '重新注册协作方',
         'action.runStatusTerminal': '在终端运行状态命令',
+        logout: '退出登录',
         actionResult: '操作结果',
         stop: '停止',
         projectState: '项目状态',
@@ -998,20 +1028,39 @@ export function webIndexHtml() {
       const cols = Math.max(60, Math.floor((el.clientWidth  - 16) / w));
       const rows = Math.max(10, Math.floor((el.clientHeight - 16) / h));
       term.resize(cols, rows);
-      if (ws && ws.readyState === WebSocket.OPEN) {
+      const actionToken = sessionActionTokens.get(active) || '';
+      if (ws && ws.readyState === WebSocket.OPEN && actionToken) {
         terminalLastResizeAt = Date.now();
-        ws.send(JSON.stringify({ type: 'resize', cols, rows }));
+        ws.send(JSON.stringify({ type: 'resize', cols, rows, action_token: actionToken }));
       }
     }
     window.addEventListener('resize', resizeTerm);
     setTimeout(resizeTerm, 80);
 
     term.onData((data) => {
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        ws.send(JSON.stringify({ type: 'input', data }));
-      }
+      sendTerminalInput(data);
     });
 
+    function sendTerminalInput(data) {
+      if (!active || !ws) return;
+      const actionToken = sessionActionTokens.get(active) || '';
+      if (ws.readyState === WebSocket.OPEN && actionToken) {
+        ws.send(JSON.stringify({ type: 'input', data, action_token: actionToken }));
+        return;
+      }
+      if (ws.readyState !== WebSocket.CONNECTING && ws.readyState !== WebSocket.OPEN) return;
+      const queued = (pendingTerminalInput.get(active) || '') + String(data || '');
+      pendingTerminalInput.set(active, queued.slice(-65536));
+    }
+
+    function flushPendingTerminalInput(id, socket) {
+      const data = pendingTerminalInput.get(id) || '';
+      const actionToken = sessionActionTokens.get(id) || '';
+      if (!data || active !== id || ws !== socket || socket.readyState !== WebSocket.OPEN || !actionToken) return;
+      pendingTerminalInput.delete(id);
+      socket.send(JSON.stringify({ type: 'input', data, action_token: actionToken }));
+    }
+
     async function api(path, options = {}) {
       const res = await fetch(path + (path.includes('?') ? '&' : '?') + requestQuery().slice(1), {
         ...options,
@@ -1612,18 +1661,25 @@ export function webIndexHtml() {
 
     function openWs(id) {
       const proto = location.protocol === 'https:' ? 'wss' : 'ws';
-      ws = new WebSocket(proto + '://' + location.host + '/ws/terminal/' + encodeURIComponent(id) + requestQuery());
-      ws.onopen = () => {
-        resizeTerm();
+      sessionActionTokens.delete(id);
+      const socket = new WebSocket(proto + '://' + location.host + '/ws/terminal/' + encodeURIComponent(id) + requestQuery({ api_version: runtimeApiVersion }));
+      ws = socket;
+      socket.onopen = () => {
+        wsReconnectFailures = 0;
         connText('attached');
       };
-      ws.onmessage = (event) => {
+      socket.onmessage = (event) => {
         const msg = JSON.parse(event.data);
         const pinned = terminalPinned();
         // The server streams the tmux pane's raw output, so xterm renders
         // incrementally (no reset/redraw → no flicker) and the program's own
         // escape sequences carry the cursor.
-        if (msg.type === 'snapshot') { writeTerminalSnapshot(msg.data || '', true); }
+        if (msg.type === 'snapshot') {
+          if (msg.action_token) sessionActionTokens.set(id, msg.action_token);
+          writeTerminalSnapshot(msg.data || '', true);
+          resizeTerm();
+          flushPendingTerminalInput(id, socket);
+        }
         if (msg.type === 'data') {
           terminalHasContent = true;
           terminalLastDataAt = Date.now();
@@ -1634,7 +1690,21 @@ export function webIndexHtml() {
         }
         if (msg.type === 'exit') { refreshSessions().catch(console.error); }
       };
-      ws.onclose = () => {
+      socket.onclose = (event) => {
+        sessionActionTokens.delete(id);
+        if (ws !== socket) return;
+        // ui-4: no reconnect after logout, and stop after repeated failures
+        // (e.g. the session cookie was revoked in another tab) instead of
+        // looping every 2s forever.
+        if (event.code === 4001 || sessionStorage.getItem('hcc_logged_out') === '1') {
+          connText('signed out');
+          return;
+        }
+        wsReconnectFailures += 1;
+        if (wsReconnectFailures > 5) {
+          connText('offline');
+          return;
+        }
         connText('reconnecting');
         // Auto-reconnect if session is still in the list and running
         wsReconnectTimer = setTimeout(() => {
@@ -1702,8 +1772,7 @@ export function webIndexHtml() {
 
     // ── Helpers ───────────────────────────────────────────────────────────
     function sendLine(text) {
-      if (!active || !ws || ws.readyState !== WebSocket.OPEN) return;
-      ws.send(JSON.stringify({ type: 'input', data: text + '\\r' }));
+      sendTerminalInput(text + '\\r');
     }
 
     // ── Start session form ────────────────────────────────────────────────
@@ -1734,7 +1803,9 @@ export function webIndexHtml() {
       return {
         session,
         peerId: sessionPeerId(session) || active,
-        actionToken: session.action_token || ''
+        // The action token is delivered via the terminal WS snapshot frame, not
+        // the session list (net-05); read it from the per-session store.
+        actionToken: sessionActionTokens.get(active) || ''
       };
     }
 
@@ -1838,6 +1909,15 @@ export function webIndexHtml() {
         closeActionsMenu();
       });
     });
+    document.getElementById('logoutBtn').addEventListener('click', async () => {
+      closeActionsMenu();
+      const res = await fetch('/logout', { method: 'POST', headers });
+      if (!res.ok) throw new Error('logout failed');
+      // Stop reconnect only after the server confirms revocation. A failed
+      // logout must not poison a later authenticated page in this tab.
+      sessionStorage.setItem('hcc_logged_out', '1');
+      location.replace('/');
+    });
     document.getElementById('actionResultClose').addEventListener('click', () => {
       document.getElementById('actionResult').hidden = true;
     });
@@ -2055,3 +2135,55 @@ export function webIndexHtml() {
 </body>
 </html>`;
 }
+
+// Minimal fallback page shown when a browser visits the bare URL with no valid
+// session cookie (e.g. a bookmarked URL after the runtime restarted). The main
+// flow is the token-in-URL exchange performed by the server; this form lets the
+// user re-enter the token once to get a fresh cookie.
+export function webLoginPage({ nonce } = {}) {
+  const inlineScriptNonce = nonceAttribute(nonce);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>hello-cc — sign in</title>
+  <style>
+    body { font-family: system-ui, sans-serif; background: #101418; color: #e8eaed; display: flex; align-items: center; justify-content: center; height: 100vh; margin: 0; }
+    .card { background: #1a2027; border: 1px solid #2c343d; border-radius: 10px; padding: 28px; width: 320px; }
+    h1 { font-size: 18px; margin: 0 0 16px; }
+    label { display: block; font-size: 13px; margin-bottom: 6px; color: #aab3bd; }
+    input { width: 100%; box-sizing: border-box; padding: 9px 10px; border-radius: 6px; border: 1px solid #39424c; background: #101418; color: #e8eaed; font-size: 14px; }
+    button { margin-top: 16px; width: 100%; padding: 9px; border-radius: 6px; border: 0; background: #40c4aa; color: #06211b; font-weight: 600; font-size: 14px; cursor: pointer; }
+    button:hover { background: #57d4bc; }
+    .err { color: #ff8b8b; font-size: 13px; margin-top: 10px; min-height: 18px; }
+  </style>
+</head>
+<body>
+  <div class="card">
+    <h1>hello-cc</h1>
+    <label for="tok">Access token</label>
+    <input id="tok" type="password" autocomplete="off" placeholder="paste the ?token= value" autofocus>
+    <button id="go">Sign in</button>
+    <div class="err" id="err"></div>
+  </div>
+  <script${inlineScriptNonce}>
+    const input = document.getElementById('tok');
+    const err = document.getElementById('err');
+    async function submit() {
+      const token = input.value.trim();
+      if (!token) return;
+      err.textContent = '';
+      const res = await fetch('/login', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ token })
+      });
+      if (res.ok) { location.href = '/'; } else { err.textContent = 'Invalid token.'; }
+    }
+    document.getElementById('go').addEventListener('click', submit);
+    input.addEventListener('keydown', (e) => { if (e.key === 'Enter') submit(); });
+  </script>
+</body>
+</html>`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logicseek/hello-cc",
-  "version": "0.1.8",
+  "version": "1.0.0",
   "description": "Local control plane for coordinating Claude Code, Codex, and other coding CLI sessions.",
   "type": "module",
   "bin": {
@@ -27,7 +27,10 @@
     "release:github": "node ./scripts/github-release.mjs",
     "release:github:dry-run": "node ./scripts/github-release.mjs --dry-run",
     "smoke": "node ./bin/hcc.mjs --help",
-    "test": "node ./scripts/regression.mjs",
+    "pretest": "npm run test:audit && npm run test:unit",
+    "test": "npm run test:regression",
+    "test:audit": "node ./scripts/check-free-identifiers.mjs",
+    "test:unit": "node --test test/*.test.mjs",
     "test:regression": "node ./scripts/regression.mjs"
   },
   "repository": {