@alyibrahim/claude-statusline 1.5.4 → 1.6.0

package/README.md

@@ -64,6 +64,7 @@ claude-statusline setup
 | Git branch | Detected automatically, silently absent if not a git repo |
 | Session commits | Shows `+N` next to the branch for commits made during the current session |
 | Directory label | Displays as `~/parent/dir` so you always know which project you're in |
+| Terminal wrapping | Lines wrap to fit terminal width — reads `COLUMNS` or `stdout.columns` automatically |
 
 ---
 
@@ -162,6 +163,43 @@ Rows are color-coded by exit reason: green = normal, yellow = interrupted, orang
 
 <div align="center">
 
+## Realtime Renderer
+
+</div>
+
+An optional background process that maintains a persistent Unix socket per terminal, enabling terminal-resize awareness and faster state access. **Disabled by default.**
+
+**Enable** by setting the environment variable (add to your shell profile to persist):
+
+```bash
+export CLAUDE_STATUSLINE_REALTIME=1
+```
+
+Accepted values: `1`, `true`, `TRUE`.
+
+When enabled, the native binary auto-spawns a renderer process the first time it runs in a terminal session. The renderer listens on a Unix socket and persists state to `~/.claude/statusline-state-{tty}.json`. It exits automatically on `session_end` or when explicitly stopped.
+
+**Terminal identification**
+
+Each terminal gets its own renderer, identified by a *TTY slug* derived in priority order from:
+
+1. `CLAUDE_STATUSLINE_TTY` — set this explicitly for a stable, human-readable slug
+2. `TERM_SESSION_ID` — used automatically by terminal emulators that set it
+3. `pid-{PID}` — fallback, changes on each shell restart
+
+**Commands:**
+
+```bash
+claude-statusline realtime-status   # Show renderer state and paths for current terminal
+claude-statusline realtime-stop     # Request renderer shutdown for current terminal
+```
+
+> The realtime renderer is Unix-only. On Windows, the feature flag is silently ignored.
+
+---
+
+<div align="center">
+
 ## Platform support
 
 </div>

package/bin/cli.js

@@ -6,6 +6,7 @@ const config = require('../scripts/config');
 const { getSettingsPath } = config;
 const { spawnSync } = require('child_process');
 const path = require('path');
+const fs = require('fs');
 
 const USAGE = `
 claude-statusline <command>
@@ -16,6 +17,8 @@ Commands:
   download-binary  Download the native binary for this platform
   enable-history   Enable tracking session analytics to JSONL (default on setup)
   disable-history  Remove history tracking hooks from Claude settings
+  realtime-status  Show realtime renderer state for current terminal
+  realtime-stop    Request realtime renderer shutdown for current terminal
   history          Open the session analytics dashboard
                    --mode web|terminal (persist dashboard mode preference)
 `.trim();
@@ -100,6 +103,72 @@ function runHistory() {
   process.exit(child.status || 0);
 }
 
+function runRealtimeStatus() {
+  const paths = config.getRealtimePaths();
+  let registry = null;
+  let state = null;
+
+  try {
+    if (fs.existsSync(paths.registryPath)) {
+      registry = JSON.parse(fs.readFileSync(paths.registryPath, 'utf8'));
+    }
+  } catch (e) {}
+
+  try {
+    if (fs.existsSync(paths.statePath)) {
+      state = JSON.parse(fs.readFileSync(paths.statePath, 'utf8'));
+    }
+  } catch (e) {}
+
+  const summary = {
+    ttySlug: paths.ttySlug,
+    registryPath: paths.registryPath,
+    statePath: paths.statePath,
+    socketPath: paths.socketPath,
+    hasRegistry: !!registry,
+    hasState: !!state,
+    registry,
+    stateEventType: state?.event_type || null,
+    stateUpdatedAt: state?.updated_at_ms || null,
+  };
+
+  console.log(JSON.stringify(summary, null, 2));
+  process.exit(0);
+}
+
+function runRealtimeStop() {
+  const net = require('net');
+  const paths = config.getRealtimePaths();
+  const ts = Date.now();
+  const event = {
+    version: 1,
+    event_type: 'shutdown',
+    tty_slug: paths.ttySlug,
+    updated_at_ms: ts,
+  };
+
+  try {
+    config.atomicWrite(paths.statePath, event);
+  } catch (e) {}
+
+  const done = () => {
+    console.log('✓ Realtime shutdown event sent');
+    process.exit(0);
+  };
+
+  if (fs.existsSync(paths.socketPath)) {
+    const client = net.createConnection(paths.socketPath);
+    client.on('connect', () => {
+      client.write(JSON.stringify(event) + '\n');
+      client.end();
+    });
+    client.on('close', done);
+    client.on('error', done);
+  } else {
+    done();
+  }
+}
+
 const cmd = process.argv[2];
 
 if (cmd === 'setup') {
@@ -161,6 +230,12 @@ if (cmd === 'setup') {
 } else if (cmd === 'history') {
   runHistory();
 
+} else if (cmd === 'realtime-status') {
+  runRealtimeStatus();
+
+} else if (cmd === 'realtime-stop') {
+  runRealtimeStop();
+
 } else if (cmd === undefined) {
   console.log(USAGE);
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alyibrahim/claude-statusline",
-  "version": "1.5.4",
+  "version": "1.6.0",
   "description": "Rich statusline for Claude Code — model, context bar, real-time token tracking, git branch, rate limits, and session stats. Rust binary, ~5ms startup.",
   "keywords": [
     "claude",

package/scripts/config.js

@@ -3,11 +3,43 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-function getSettingsPath() {
+function getClaudeConfigDir() {
   const configDir = process.env.CLAUDE_CONFIG_DIR;
-  const base = (configDir && configDir.trim())
+  return (configDir && configDir.trim())
     ? configDir
     : path.join(os.homedir(), '.claude');
+}
+
+function sanitizeSlug(s) {
+  return String(s || '')
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function getRealtimeTtySlug() {
+  const preferred = [process.env.CLAUDE_STATUSLINE_TTY, process.env.TERM_SESSION_ID];
+  for (const raw of preferred) {
+    const slug = sanitizeSlug(raw || '');
+    if (slug) return slug;
+  }
+  return sanitizeSlug(`pid-${process.pid}`);
+}
+
+function getRealtimePaths() {
+  const claudeDir = getClaudeConfigDir();
+  const ttySlug = getRealtimeTtySlug();
+  return {
+    claudeDir,
+    ttySlug,
+    registryPath: path.join(claudeDir, `statusline-renderer-${ttySlug}.json`),
+    statePath: path.join(claudeDir, `statusline-state-${ttySlug}.json`),
+    socketPath: path.join(claudeDir, `statusline-rt-${ttySlug}.sock`),
+  };
+}
+
+function getSettingsPath() {
+  const base = getClaudeConfigDir();
   return path.join(base, 'settings.json');
 }
 
@@ -40,4 +72,11 @@ function resolveBinary() {
   return binaryPath;
 }
 
-module.exports = { getSettingsPath, atomicWrite, resolveBinary };
+module.exports = {
+  getSettingsPath,
+  atomicWrite,
+  resolveBinary,
+  getClaudeConfigDir,
+  getRealtimeTtySlug,
+  getRealtimePaths,
+};

package/statusline.js

@@ -8,6 +8,135 @@ const os = require('os');
 const { execSync, execFileSync } = require('child_process');
 const { normalizeProjectSlug } = require('./scripts/slug-utils');
 
+function realtimeEnabled() {
+  const v = process.env.CLAUDE_STATUSLINE_REALTIME;
+  return v === '1' || v === 'true' || v === 'TRUE';
+}
+
+function realtimeTtySlug() {
+  const raw = (process.env.CLAUDE_STATUSLINE_TTY || process.env.TERM_SESSION_ID || `pid-${process.pid}`).trim();
+  return raw.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+}
+
+function atomicWrite(filePath, obj) {
+  const tmp = `${filePath}.tmp`;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(tmp, JSON.stringify(obj));
+  fs.renameSync(tmp, filePath);
+}
+
+function emitRealtimeEvent(eventType, payload) {
+  if (!realtimeEnabled()) return;
+  try {
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+    const ttySlug = realtimeTtySlug();
+    const now = Date.now();
+    const statePath = path.join(claudeDir, `statusline-state-${ttySlug}.json`);
+    const registryPath = path.join(claudeDir, `statusline-renderer-${ttySlug}.json`);
+
+    atomicWrite(registryPath, {
+      version: 1,
+      pid: process.pid,
+      tty_slug: ttySlug,
+      heartbeat_at_ms: now,
+      socket_path: path.join(claudeDir, `statusline-rt-${ttySlug}.sock`),
+    });
+
+    atomicWrite(statePath, {
+      version: 1,
+      event_type: eventType,
+      tty_slug: ttySlug,
+      updated_at_ms: now,
+      payload: payload || {},
+    });
+  } catch (_) {
+    // Silent fail - never break statusline rendering
+  }
+}
+
+function stripSgr(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function visibleLen(s) {
+  return [...stripSgr(String(s))].reduce((sum, ch) => sum + (ch.codePointAt(0) > 0xFFFF ? 2 : 1), 0);
+}
+
+function terminalColumns() {
+  const fromStdout = Number(process.stdout && process.stdout.columns);
+  if (Number.isFinite(fromStdout) && fromStdout > 0) return fromStdout;
+  const fromEnv = Number(process.env.COLUMNS);
+  if (Number.isFinite(fromEnv) && fromEnv > 0) return fromEnv;
+  return null;
+}
+
+function truncateVisible(s, maxVisible) {
+  if (!maxVisible || maxVisible <= 0) return '';
+  if (visibleLen(s) <= maxVisible) return String(s);
+
+  const src = String(s);
+  let out = '';
+  let visible = 0;
+  for (let i = 0; i < src.length;) {
+    if (src[i] === '\x1b' && src[i + 1] === '[') {
+      let j = i + 2;
+      while (j < src.length && /[0-9;]/.test(src[j])) j++;
+      if (j < src.length && /[mGKHFABCDJ]/.test(src[j])) {
+        out += src.slice(i, j + 1);
+        i = j + 1;
+        continue;
+      }
+    }
+
+    const code = src.codePointAt(i);
+    const ch = String.fromCodePoint(code);
+    const width = code > 0xFFFF ? 2 : 1;
+    if (visible + width > maxVisible) break;
+    out += ch;
+    visible += width;
+    i += code > 0xFFFF ? 2 : 1;
+  }
+  return `${out}…\x1b[0m`;
+}
+
+function wrapChunks(chunks, width, sep) {
+  if (!width) return [chunks.join(sep)];
+  if (width < 8) {
+    return chunks.map(c => truncateVisible(c, Math.max(1, width - 1)));
+  }
+
+  const sepLen = visibleLen(sep);
+  const lines = [];
+  let current = '';
+  let currentLen = 0;
+
+  for (const rawChunk of chunks) {
+    const chunk = visibleLen(rawChunk) > width
+      ? truncateVisible(rawChunk, Math.max(1, width - 1))
+      : rawChunk;
+    const chunkLen = visibleLen(chunk);
+
+    if (!current) {
+      current = chunk;
+      currentLen = chunkLen;
+      continue;
+    }
+
+    const needed = currentLen + sepLen + chunkLen;
+    if (needed <= width) {
+      current += `${sep}${chunk}`;
+      currentLen = needed;
+    } else {
+      lines.push(current);
+      current = chunk;
+      currentLen = chunkLen;
+    }
+  }
+
+  if (current) lines.push(current);
+  return lines;
+}
+
 const cmd = process.argv[2];
 if (cmd === 'history') {
   require('./scripts/history').handleHistory().catch(e => {
@@ -18,12 +147,20 @@ if (cmd === 'history') {
 } else if (cmd === 'hook') {
   const hookcmd = process.argv[3];
   if (hookcmd === 'start') {
+    emitRealtimeEvent('session_start', {});
     require('./scripts/history').handleHookStart();
     return;
   } else if (hookcmd === 'end') {
+    emitRealtimeEvent('session_end', {});
     require('./scripts/history').handleHookEnd();
     return;
   }
+} else if (cmd === 'realtime') {
+  const subcmd = process.argv[3];
+  if (subcmd === 'shutdown') {
+    emitRealtimeEvent('shutdown', {});
+    return;
+  }
 }
 
 // Reads cumulative token totals from the session JSONL file, using a byte-offset
@@ -89,6 +226,7 @@ process.stdin.on('end', () => {
   try {
     const sanitize = s => String(s).replace(/\x1b\[[0-9;]*[mGKHFABCDJ]/g, '');
     const data = JSON.parse(input);
+    emitRealtimeEvent('state_update', data);
     const model = sanitize(data.model?.display_name || 'Claude');
     const dir = data.workspace?.current_dir || process.cwd();
     const session = data.session_id || '';
@@ -230,13 +368,14 @@ process.stdin.on('end', () => {
       const fmt = n => n >= 1_000_000 ? (n % 1_000_000 === 0 ? `${n / 1_000_000}M` : `${(n / 1_000_000).toFixed(1)}M`)
                      : n >= 1000     ? `${(n / 1000).toFixed(1)}k`
                      : String(n);
-      tokenDisplay = `\x1b[2m│\x1b[0m \x1b[97m${fmt(totalIn ?? 0)}↓ ${fmt(totalOut ?? 0)}↑\x1b[0m`;
+      tokenDisplay = `\x1b[97m${fmt(totalIn ?? 0)}↓ ${fmt(totalOut ?? 0)}↑\x1b[0m`;
     }
 
     const usageContent = [u7d, u5h].filter(Boolean).join('  ');
-    const line2 = (usageContent || costDisplay || tokenDisplay)
-      ? `\x1b[0m\x1b[32mUsage\x1b[0m \x1b[2m│\x1b[0m ${[usageContent, costDisplay, tokenDisplay].filter(Boolean).join('  ')}`
-      : '';
+    const line2Chunks = ['\x1b[0m\x1b[32mUsage\x1b[0m'];
+    if (usageContent) line2Chunks.push(usageContent);
+    if (costDisplay) line2Chunks.push(costDisplay.trimStart());
+    if (tokenDisplay) line2Chunks.push(tokenDisplay);
     // Effort level: read from env var first, then settings.json, then fall back to
     // model-based default (sonnet-4/opus-4 default to "medium" in Claude Code).
     const effortLetters = { low: 'L', medium: 'M', high: 'H' };
@@ -262,12 +401,17 @@ process.stdin.on('end', () => {
 
     const agentDisplay = activeAgents > 0 ? ` \x1b[0m\x1b[36m↪ ${activeAgents}\x1b[0m` : '';
     const modelDisplay = `\x1b[0m\x1b[94m${model}\x1b[0m` + effortSuffix + agentDisplay;
-    const line1 = task
-      ? `${modelDisplay} \x1b[2m│\x1b[0m \x1b[1m${task}\x1b[0m \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`
-      : `${modelDisplay} \x1b[2m│\x1b[0m ${dirDisplay}${ctx}`;
-    const visibleLen = line1.replace(/\x1b\[[0-9;]*m/g, '').length;
-    const sep = `\x1b[2m${'─'.repeat(visibleLen)}\x1b[0m`;
-    process.stdout.write(line2 ? `${line1}\n${sep}\n${line2}` : line1);
+    const line1Chunks = [modelDisplay];
+    if (task) line1Chunks.push(`\x1b[1m${task}\x1b[0m`);
+    line1Chunks.push(`${dirDisplay}${ctx}`);
+
+    const columns = terminalColumns();
+    const sepToken = ' \x1b[2m│\x1b[0m ';
+    const wrappedLine1 = wrapChunks(line1Chunks, columns, sepToken);
+    const sepLen = wrappedLine1.reduce((max, line) => Math.max(max, visibleLen(line)), 0);
+    const sep = `\x1b[2m${'─'.repeat(sepLen)}\x1b[0m`;
+    const wrappedLine2 = line2Chunks.length > 1 ? wrapChunks(line2Chunks, columns, sepToken) : [];
+    process.stdout.write(wrappedLine2.length ? `${wrappedLine1.join('\n')}\n${sep}\n${wrappedLine2.join('\n')}` : wrappedLine1.join('\n'));
   } catch (e) {
     // Silent fail - don't break statusline on parse errors
   }