@clearlysh/beehaven 0.8.16

package/dist/telemetry.js

@@ -0,0 +1,166 @@
+// ============================================================================
+// Beehaven — System Telemetry & Git Status
+// Collects machine metrics and git repo state for remote monitoring.
+// All shell commands use execFileSync (no shell interpolation).
+// ============================================================================
+import { cpus, totalmem, freemem, loadavg, uptime, platform, arch } from 'os';
+import { execFileSync } from 'child_process';
+import { existsSync } from 'fs';
+/** Collect system telemetry using Node.js built-in APIs + minimal shell commands */
+export function collectSystemTelemetry() {
+    const totalMem = totalmem();
+    const freeMem = freemem();
+    const load = loadavg();
+    return {
+        cpu: {
+            cores: cpus().length,
+            loadAvg1m: +load[0].toFixed(2),
+        },
+        memory: {
+            totalGB: +(totalMem / 1073741824).toFixed(1),
+            freeGB: +(freeMem / 1073741824).toFixed(1),
+            usedPct: +((1 - freeMem / totalMem) * 100).toFixed(1),
+        },
+        disk: collectDiskUsage(),
+        uptime: Math.floor(uptime()),
+        platform: platform(),
+        arch: arch(),
+    };
+}
+/** Get disk usage for the home directory via `df` */
+function collectDiskUsage() {
+    try {
+        const output = execFileSync('df', ['-k', '.'], {
+            timeout: 5000,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const lines = output.trim().split('\n');
+        if (lines.length < 2)
+            return null;
+        // df output: Filesystem 1K-blocks Used Available Use% Mounted
+        const parts = lines[1].split(/\s+/);
+        const totalKB = parseInt(parts[1], 10);
+        const usedKB = parseInt(parts[2], 10);
+        const availKB = parseInt(parts[3], 10);
+        if (isNaN(totalKB))
+            return null;
+        return {
+            totalGB: +(totalKB / 1048576).toFixed(1),
+            freeGB: +(availKB / 1048576).toFixed(1),
+            usedPct: +((usedKB / totalKB) * 100).toFixed(1),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Collect git status for a working directory */
+export function collectGitStatus(cwd) {
+    if (!existsSync(cwd))
+        return null;
+    try {
+        // Check if it's a git repo
+        execFileSync('git', ['rev-parse', '--git-dir'], {
+            cwd,
+            timeout: 3000,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch {
+        return null;
+    }
+    try {
+        // Branch name
+        let branch = 'HEAD';
+        try {
+            branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                cwd,
+                timeout: 3000,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            /* detached HEAD */
+        }
+        // Ahead/behind
+        let ahead = 0;
+        let behind = 0;
+        try {
+            const abOutput = execFileSync('git', ['rev-list', '--left-right', '--count', `HEAD...@{upstream}`], {
+                cwd,
+                timeout: 3000,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            const [a, b] = abOutput.split(/\s+/);
+            ahead = parseInt(a, 10) || 0;
+            behind = parseInt(b, 10) || 0;
+        }
+        catch {
+            /* no upstream */
+        }
+        // Status counts
+        let staged = 0;
+        let modified = 0;
+        let untracked = 0;
+        try {
+            const status = execFileSync('git', ['status', '--porcelain', '-uall'], {
+                cwd,
+                timeout: 5000,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            for (const line of status.split('\n')) {
+                if (!line)
+                    continue;
+                const x = line[0];
+                const y = line[1];
+                if (x === '?' && y === '?')
+                    untracked++;
+                else if (x !== ' ' && x !== '?')
+                    staged++;
+                if (y !== ' ' && y !== '?')
+                    modified++;
+            }
+        }
+        catch {
+            /* empty repo */
+        }
+        // Last commit
+        let lastCommitHash = '';
+        let lastCommitMsg = '';
+        let lastCommitAge = 0;
+        try {
+            const log = execFileSync('git', ['log', '-1', '--format=%H%n%s%n%ct'], {
+                cwd,
+                timeout: 3000,
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            const [hash, msg, timestamp] = log.split('\n');
+            lastCommitHash = hash?.slice(0, 8) || '';
+            lastCommitMsg = msg?.slice(0, 100) || '';
+            lastCommitAge = Math.floor(Date.now() / 1000) - (parseInt(timestamp, 10) || 0);
+        }
+        catch {
+            /* no commits */
+        }
+        return {
+            branch,
+            ahead,
+            behind,
+            staged,
+            modified,
+            untracked,
+            lastCommitHash,
+            lastCommitMsg,
+            lastCommitAge,
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/terminal/block-parser.js

@@ -0,0 +1,207 @@
+// ============================================================================
+// TerminalBlockParser — raw PTY byte stream → command "blocks"
+// ----------------------------------------------------------------------------
+// Turns a shell's PTY output into structured command blocks using OSC 633 / 133
+// semantic prompt markers (the protocol Warp / iTerm2 / VS Code use). It is fed
+// the SAME bytes that stream to xterm as `pty-output`; it never consumes or
+// mutates them, so the live terminal is completely unaffected. On each finished
+// command (a `D` marker) it emits a structured block to mint as a canvas frame.
+//
+// Markers (emitted by our injected shell integration — see shell-integration.ts):
+//   OSC 633;A              prompt start
+//   OSC 633;B              prompt end (user input begins)
+//   OSC 633;C              output start (pre-exec)
+//   OSC 633;E;<cmdline>    explicit command line (survives ; and newlines)
+//   OSC 633;D;<exit>       command finished + exit code
+//   OSC 7;file://host/pwd  cwd report
+// OSC 133;A/B/C/D are accepted as a fallback for shells that already ship their
+// own integration. Everything else in the stream (colors, cursor moves, foreign
+// OSC) is treated as opaque output content.
+// ============================================================================
+const ESC = '\x1b';
+const BEL = '\x07';
+/** Strip the common ANSI escape families so block output renders as clean text. */
+export function stripAnsi(s) {
+    return s
+        .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '') // CSI (colors, cursor)
+        .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '') // OSC (BEL- or ST-terminated)
+        .replace(/\x1b[()][0-9A-Za-z]/g, '') // charset select
+        .replace(/\x1b[=>]/g, '') // keypad mode
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, ''); // stray control bytes (keep \t \n \r)
+}
+export class TerminalBlockParser {
+    onBlock;
+    now;
+    buf = '';
+    phase = 'idle';
+    cwd = '';
+    altScreen = false;
+    cur = null;
+    /**
+     * @param onBlock  called once per completed command block
+     * @param now      injectable clock (ms) — override in tests
+     */
+    constructor(onBlock, now = () => Date.now()) {
+        this.onBlock = onBlock;
+        this.now = now;
+    }
+    /** Feed a chunk of raw PTY output. Safe to call with partial escape sequences. */
+    write(chunk) {
+        if (!chunk)
+            return;
+        this.buf += chunk;
+        this.drain();
+    }
+    drain() {
+        const buf = this.buf;
+        let i = 0;
+        let text = ''; // plain/opaque bytes accumulated since the last flush
+        const flush = () => {
+            if (text && this.cur && this.phase === 'running' && !this.altScreen) {
+                this.cur.raw += text;
+            }
+            text = '';
+        };
+        while (i < buf.length) {
+            const esc = buf.indexOf(ESC, i);
+            if (esc === -1) {
+                text += buf.slice(i);
+                break;
+            }
+            text += buf.slice(i, esc);
+            // Commit pending output to the open block BEFORE any marker changes state
+            // (a D marker closes the block and reads its raw output right here).
+            flush();
+            const next = buf[esc + 1];
+            if (next === undefined) {
+                // Lone trailing ESC — could start any sequence; wait for more bytes.
+                this.buf = buf.slice(esc);
+                return;
+            }
+            if (next === ']') {
+                // OSC — terminated by BEL or ST (ESC \).
+                const bel = buf.indexOf(BEL, esc + 2);
+                const st = buf.indexOf(ESC + '\\', esc + 2);
+                let end = -1;
+                let stLen = 1;
+                if (bel !== -1 && (st === -1 || bel < st)) {
+                    end = bel;
+                    stLen = 1;
+                }
+                else if (st !== -1) {
+                    end = st;
+                    stLen = 2;
+                }
+                if (end === -1) {
+                    // Incomplete OSC — buffer from ESC and wait for the rest.
+                    this.buf = buf.slice(esc);
+                    return;
+                }
+                const body = buf.slice(esc + 2, end);
+                if (!this.handleOsc(body)) {
+                    // Foreign OSC — keep it verbatim in the raw output.
+                    text += buf.slice(esc, end + stLen);
+                }
+                i = end + stLen;
+                continue;
+            }
+            if (next === '[') {
+                // CSI — special-case the alt-screen toggles (TUI apps own the grid),
+                // otherwise it's opaque output; pass the ESC byte through and rescan.
+                if (buf.startsWith('[?1049h', esc + 1)) {
+                    this.altScreen = true;
+                    if (this.cur)
+                        this.cur.touchedAlt = true;
+                    i = esc + 8;
+                    continue;
+                }
+                if (buf.startsWith('[?1049l', esc + 1)) {
+                    this.altScreen = false;
+                    i = esc + 8;
+                    continue;
+                }
+                text += ESC;
+                i = esc + 1;
+                continue;
+            }
+            // Any other escape — opaque; pass the ESC byte through.
+            text += ESC;
+            i = esc + 1;
+        }
+        flush();
+        this.buf = '';
+    }
+    /** Handle one OSC body. Returns true if it was one of OUR markers. */
+    handleOsc(body) {
+        // OSC 7 — cwd report: "7;file://host/path"
+        if (body.startsWith('7;')) {
+            const m = body.slice(2).match(/^file:\/\/[^/]*(\/.*)$/);
+            if (m) {
+                try {
+                    this.cwd = decodeURIComponent(m[1]);
+                }
+                catch {
+                    this.cwd = m[1];
+                }
+            }
+            return true;
+        }
+        // OSC 633 (VS Code) / 133 (FinalTerm) semantic prompt markers.
+        let rest = null;
+        if (body.startsWith('633;'))
+            rest = body.slice(4);
+        else if (body.startsWith('133;'))
+            rest = body.slice(4);
+        if (rest === null)
+            return false;
+        const code = rest[0];
+        // Everything after "X;" is the argument (may itself contain ';' or newlines).
+        const arg = rest.length > 2 && rest[1] === ';' ? rest.slice(2) : '';
+        switch (code) {
+            case 'A': // prompt start
+                this.phase = 'idle';
+                return true;
+            case 'B': // prompt end — user input begins
+                this.phase = 'input';
+                return true;
+            case 'C': // output start — open a block
+                this.cur = { command: '', raw: '', startedAt: this.now(), touchedAlt: false };
+                this.phase = 'running';
+                return true;
+            case 'E': // explicit command line
+                if (this.cur)
+                    this.cur.command = arg;
+                return true;
+            case 'D': {
+                // command finished
+                if (this.cur) {
+                    const raw = this.cur.raw;
+                    const block = {
+                        command: this.cur.command.trim(),
+                        cwd: this.cwd,
+                        exitCode: arg ? parseInt(arg, 10) || 0 : 0,
+                        output: stripAnsi(raw).replace(/[ \t\r\n]+$/, ''),
+                        raw,
+                        startedAt: this.cur.startedAt,
+                        durationMs: Math.max(0, this.now() - this.cur.startedAt),
+                    };
+                    const touchedAlt = this.cur.touchedAlt;
+                    this.cur = null;
+                    this.phase = 'idle';
+                    // Suppress blocks for alt-screen apps (vim/htop/interactive claude) —
+                    // the live xterm viewport owns those; there is no linear output to block-ify.
+                    if (!touchedAlt) {
+                        try {
+                            this.onBlock(block);
+                        }
+                        catch {
+                            /* never break the stream */
+                        }
+                    }
+                }
+                return true;
+            }
+        }
+        return true; // recognized prefix, unknown sub-code — swallow
+    }
+}

package/dist/terminal/shell-integration.js

@@ -0,0 +1,108 @@
+// ============================================================================
+// Shell integration — inject OSC 633 semantic prompt markers into a spawned
+// shell so TerminalBlockParser can slice the PTY stream into command blocks.
+// ----------------------------------------------------------------------------
+// We spawn the shell ourselves, so we own its startup: point it at a temp rc
+// that FIRST sources the user's real rc (aliases, PATH, prompt, everything
+// unchanged) and THEN installs precmd/preexec hooks emitting the markers.
+//   • zsh  → ZDOTDIR redirection (the VS Code / iTerm2 approach); we restore the
+//            real ZDOTDIR inside so subshells + completion are unaffected.
+//   • bash → --rcfile; a DEBUG trap (preexec) + PROMPT_COMMAND (precmd).
+//   • anything else (sh, …) → no integration; the live terminal still works,
+//            blocks just aren't parsed.
+// Emitted markers: 633;A prompt-start · 633;B prompt-end · 633;C output-start ·
+// 633;E;<cmd> command line · 633;D;<exit> done · OSC 7 cwd.
+//
+// NOTE: these scripts are built with plain concatenation (not template literals)
+// on purpose — a `${...}` in a JS template is interpolation, and shell syntax is
+// full of `${VAR:-default}`. Backslashes are doubled so the FILE contains literal
+// `\e`/`\a` for the shell's printf to turn into ESC/BEL.
+// ============================================================================
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir, homedir } from 'os';
+const ROOT = join(tmpdir(), 'beehaven-term');
+// zsh hooks. `precmd_functions` is PREPENDED (not add-zsh-hook) so _bh_precmd
+// captures the real $? before any user precmd hook can clobber it.
+const ZSH_HOOKS = [
+    'autoload -Uz add-zsh-hook 2>/dev/null',
+    "_bh_preexec() { printf '\\e]633;C\\a'; printf '\\e]633;E;%s\\a' \"$1\"; }",
+    '_bh_precmd()  { printf \'\\e]633;D;%s\\a\' "$?"; printf \'\\e]7;file://%s%s\\a\' "${HOST:-localhost}" "$PWD"; printf \'\\e]633;A\\a\'; }',
+    'typeset -ga precmd_functions preexec_functions',
+    'precmd_functions=(_bh_precmd ${precmd_functions:#_bh_precmd})',
+    'preexec_functions=(${preexec_functions:#_bh_preexec} _bh_preexec)',
+    'PS1="$PS1"$\'\\e]633;B\\a\'',
+    '',
+].join('\n');
+function bashRc(home) {
+    return [
+        '[ -f "' + home + '/.bashrc" ] && source "' + home + '/.bashrc"',
+        '_bh_last_cmd=""',
+        '_bh_preexec() {',
+        '  [ -n "$COMP_LINE" ] && return', // skip during completion
+        '  [ "$BASH_COMMAND" = "$PROMPT_COMMAND" ] && return',
+        '  [ "$BASH_COMMAND" = "$_bh_last_cmd" ] && return', // DEBUG fires per simple-command; dedupe
+        '  _bh_last_cmd="$BASH_COMMAND"',
+        "  printf '\\e]633;C\\a'; printf '\\e]633;E;%s\\a' \"$BASH_COMMAND\"",
+        '}',
+        '_bh_precmd() {',
+        '  local ec=$?',
+        '  _bh_last_cmd=""',
+        '  printf \'\\e]633;D;%s\\a\' "$ec"',
+        '  printf \'\\e]7;file://%s%s\\a\' "${HOSTNAME:-localhost}" "$PWD"',
+        "  printf '\\e]633;A\\a'",
+        '}',
+        "trap '_bh_preexec' DEBUG",
+        'PROMPT_COMMAND="_bh_precmd${PROMPT_COMMAND:+; $PROMPT_COMMAND}"',
+        'PS1="$PS1"$\'\\e]633;B\\a\'',
+        '',
+    ].join('\n');
+}
+/** Detect the shell family from an absolute shell path. */
+function shellKind(shell) {
+    if (/zsh$/.test(shell))
+        return 'zsh';
+    if (/bash$/.test(shell))
+        return 'bash';
+    return 'other';
+}
+/**
+ * Materialize the integration for a session. Returns `{ env, args }` to merge
+ * into the PTY spawn, plus the temp `dir` to clean up on exit. Never throws — on
+ * any failure returns a no-op so the shell still spawns (without block parsing).
+ */
+export function writeIntegration(sessionId, shell) {
+    const kind = shellKind(shell);
+    const noop = { env: {}, args: [], dir: null };
+    if (kind === 'other')
+        return noop;
+    try {
+        const dir = join(ROOT, sessionId);
+        mkdirSync(dir, { recursive: true });
+        if (kind === 'zsh') {
+            const real = process.env.ZDOTDIR || homedir();
+            const src = (name) => '[ -f "' + real + '/' + name + '" ] && source "' + real + '/' + name + '"\n';
+            writeFileSync(join(dir, '.zshenv'), src('.zshenv'));
+            writeFileSync(join(dir, '.zprofile'), src('.zprofile'));
+            writeFileSync(join(dir, '.zlogin'), src('.zlogin'));
+            writeFileSync(join(dir, '.zshrc'), 'export ZDOTDIR="' + real + '"\n' + src('.zshrc') + ZSH_HOOKS);
+            return { env: { ZDOTDIR: dir, BH_USER_ZDOTDIR: real }, args: [], dir };
+        }
+        // bash
+        const rc = join(dir, 'bashrc');
+        writeFileSync(rc, bashRc(homedir()));
+        return { env: {}, args: ['--rcfile', rc, '-i'], dir };
+    }
+    catch {
+        return noop;
+    }
+}
+/** Remove a session's integration temp dir. Safe to call more than once. */
+export function cleanupIntegration(sessionId) {
+    try {
+        rmSync(join(ROOT, sessionId), { recursive: true, force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}