@expitc/termad 0.0.0-stage → 0.1.1

package/dist/install.js

@@ -0,0 +1,182 @@
+/**
+ * Install / uninstall orchestration across all opted-in surfaces.
+ *
+ * Every change is recorded in the sha256 audit manifest BEFORE the user
+ * consents (the plan is shown) and re-verified by `termad audit`.
+ */
+import { loadConfig, saveConfig, writeFileAtomic } from "./core/config.js";
+import { paths, termadHome, backupPath } from "./core/paths.js";
+import { fetchAd, writeAdCache } from "./core/source.js";
+import { existsSync, mkdirSync } from "node:fs";
+import { getSurface } from "./surfaces/surfaces.js";
+import { installWrapper, uninstallWrapper, isWrapped } from "./surfaces/wrap.js";
+import { installStatusline, uninstallStatusline, settingsPath, isStatuslineInstalled } from "./surfaces/statusline.js";
+import { loadManifest, recordEntry, removeEntries, sha256File } from "./core/manifest.js";
+/** What `termad install` would change — shown to the user before consent. */
+export function planInstall(surfaces, force = false) {
+    const cfg = loadConfig();
+    const wanted = surfaces ?? Object.entries(cfg.surfaces).filter(([, v]) => v).map(([k]) => k);
+    const items = [];
+    for (const id of wanted) {
+        if (id === "claude") {
+            items.push({
+                surface: id,
+                target: settingsPath(),
+                action: isStatuslineInstalled()
+                    ? "already chained — no change"
+                    : "chain statusLine (your current statusLine captured, restored on uninstall)",
+            });
+            continue;
+        }
+        const s = getSurface(id);
+        const bin = s?.locate();
+        if (!bin) {
+            items.push({ surface: id, target: "(not found)", action: `skip — CLI not found (set TERMAD_${id.toUpperCase()}_BIN)` });
+            continue;
+        }
+        items.push({
+            surface: id,
+            target: bin,
+            action: isWrapped(bin)
+                ? force
+                    ? "re-bake wrapper (pristine backup kept)"
+                    : "already wrapped — no change"
+                : `wrap binary; pristine original → ${backupPath(bin)}`,
+        });
+    }
+    return items;
+}
+/** Fetch the ad, write the cache, then install the opted-in surfaces. */
+export async function install(surfaces, opts = {}) {
+    const force = opts.force ?? false;
+    const cfg = loadConfig();
+    mkdirSync(termadHome(), { recursive: true });
+    const ad = await fetchAd(surfaces?.[0] ?? "claude");
+    writeAdCache(ad);
+    const wanted = surfaces ?? Object.entries(cfg.surfaces).filter(([, v]) => v).map(([k]) => k);
+    const out = [];
+    for (const id of wanted) {
+        const s = getSurface(id);
+        if (!s)
+            continue;
+        if (id === "claude") {
+            const target = settingsPath();
+            const shaBefore = sha256File(target);
+            const hadEntry = manifestHas(id, target);
+            const r = installStatusline();
+            if (r.ok && !hadEntry) {
+                recordEntry({
+                    surface: id,
+                    target,
+                    mechanism: "statusline",
+                    backup: existsSync(paths.prevStatusline()) ? paths.prevStatusline() : null,
+                    sha256Original: shaBefore,
+                    sha256Installed: sha256File(target),
+                });
+            }
+            out.push({ surface: id, ok: r.ok, detail: r.alreadyInstalled ? "already installed" : r.ok ? "statusline chained" : (r.reason ?? "failed") });
+        }
+        else {
+            const bin = s.locate();
+            if (!bin) {
+                out.push({ surface: id, ok: false, detail: "CLI not found (set TERMAD_" + id.toUpperCase() + "_BIN)" });
+                continue;
+            }
+            const wasWrapped = isWrapped(bin);
+            const shaBefore = sha256File(bin);
+            const r = installWrapper(bin, paths.adCache(), force);
+            if (r.ok) {
+                const entry = loadManifest().entries.find((e) => e.surface === id && e.target === bin);
+                if (!entry) {
+                    if (wasWrapped) {
+                        // Legacy install (no manifest yet): original = the backup's bytes.
+                        recordEntry({
+                            surface: id,
+                            target: bin,
+                            mechanism: "wrapper",
+                            backup: backupPath(bin),
+                            sha256Original: sha256File(backupPath(bin)),
+                            sha256Installed: shaBefore,
+                        });
+                    }
+                    else {
+                        recordEntry({
+                            surface: id,
+                            target: bin,
+                            mechanism: "wrapper",
+                            backup: backupPath(bin),
+                            sha256Original: shaBefore,
+                            sha256Installed: sha256File(bin),
+                        });
+                    }
+                }
+                else if (force && wasWrapped) {
+                    // Re-bake: original stays, installed fingerprint follows the new wrapper.
+                    recordEntry({
+                        surface: entry.surface,
+                        target: entry.target,
+                        mechanism: entry.mechanism,
+                        backup: entry.backup,
+                        sha256Original: entry.sha256Original,
+                        sha256Installed: sha256File(bin),
+                    });
+                }
+            }
+            out.push({ surface: id, ok: r.ok, detail: r.alreadyInstalled ? "already wrapped" : r.ok ? `wrapped ${bin}` : (r.reason ?? "failed") });
+        }
+        cfg.surfaces[id] = true;
+    }
+    saveConfig(cfg);
+    return out;
+}
+function manifestHas(surface, target) {
+    return loadManifest().entries.some((e) => e.surface === surface && e.target === target);
+}
+export function uninstall(surfaces) {
+    const cfg = loadConfig();
+    const wanted = surfaces ?? Object.keys(cfg.surfaces).filter((k) => cfg.surfaces[k]);
+    const out = [];
+    for (const id of wanted) {
+        const s = getSurface(id);
+        if (!s)
+            continue;
+        if (id === "claude") {
+            const r = uninstallStatusline();
+            if (r.ok && r.alreadyInstalled)
+                removeEntries(id);
+            out.push({ surface: id, ok: r.ok, detail: r.reason ?? (r.alreadyInstalled ? "restored" : "nothing to do") });
+        }
+        else {
+            const bin = s.locate();
+            if (!bin) {
+                out.push({ surface: id, ok: false, detail: "CLI not found" });
+                continue;
+            }
+            // Integrity gate: never restore from a backup that fails its sha256 check.
+            const entry = loadManifest().entries.find((e) => e.surface === id && e.target === bin);
+            if (entry?.backup && entry.sha256Original && sha256File(entry.backup) !== entry.sha256Original) {
+                out.push({
+                    surface: id,
+                    ok: false,
+                    detail: "REFUSED: backup fails sha256 check (tampered) — run `termad audit`; restore manually if needed",
+                });
+                continue;
+            }
+            const r = uninstallWrapper(bin, paths.adCache());
+            if (r.ok && r.alreadyInstalled)
+                removeEntries(id);
+            out.push({ surface: id, ok: r.ok, detail: r.reason ?? (r.alreadyInstalled ? `restored ${bin}` : "nothing to do") });
+        }
+        cfg.surfaces[id] = false;
+    }
+    saveConfig(cfg);
+    return out;
+}
+/** Refresh the ad cache (used by `termad watch` and cron). */
+export async function sync() {
+    const cfg = loadConfig();
+    const ad = await fetchAd("claude");
+    writeAdCache(ad);
+    writeFileAtomic(paths.adCache() + ".meta", JSON.stringify({ at: Date.now(), endpoint: cfg.endpoint }));
+    return ad.text;
+}

package/dist/render/render.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Terminal renderers — the "reservation space".
+ *
+ * line:    one line of wording (+ optional auto-linked URL)
+ * banner:  small ANSI box — a "selected banner" that catches the eye
+ *
+ * All output is plain text + ANSI color. No images, no escape-sequence
+ * hyperlinks (OSC 8) — bare URLs let the terminal's own link detection
+ * do the clicking, which is the most portable path.
+ */
+declare const BOLD = "\u001B[1m";
+export interface AdLines {
+    text: string;
+    url?: string;
+    sub?: string;
+}
+export declare function renderLine(ad: AdLines): string;
+export declare function renderBanner(ad: AdLines): string;
+export declare function render(ad: AdLines, style: "line" | "banner"): string;
+export { BOLD };

package/dist/render/render.js

@@ -0,0 +1,47 @@
+/**
+ * Terminal renderers — the "reservation space".
+ *
+ * line:    one line of wording (+ optional auto-linked URL)
+ * banner:  small ANSI box — a "selected banner" that catches the eye
+ *
+ * All output is plain text + ANSI color. No images, no escape-sequence
+ * hyperlinks (OSC 8) — bare URLs let the terminal's own link detection
+ * do the clicking, which is the most portable path.
+ */
+const RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const CYAN = "\x1b[36m";
+const YELLOW = "\x1b[33m";
+export function renderLine(ad) {
+    const out = [`${DIM}  [ad]${RESET} ${YELLOW}${ad.text}${RESET}`];
+    if (ad.url)
+        out.push(`  ${CYAN}${ad.url}${RESET}`);
+    if (ad.sub)
+        out.push(`  ${DIM}${ad.sub}${RESET}`);
+    return out.join("\n");
+}
+export function renderBanner(ad) {
+    const content = [ad.text, ...(ad.url ? [ad.url] : []), ...(ad.sub ? [ad.sub] : [])];
+    const width = Math.min(Math.max(...content.map((l) => visibleLen(l))), 56);
+    const bar = "─".repeat(width + 2);
+    const row = (s) => `  ${DIM}│${RESET} ${YELLOW}${pad(s, width)}${RESET} ${DIM}│${RESET}\n`;
+    let out = `  ${DIM}╭${bar}╮${RESET}\n`;
+    out += `  ${DIM}│${RESET} ${DIM}${pad("ad", width)}${RESET} ${DIM}│${RESET}\n`;
+    out += `  ${DIM}├${bar}┤${RESET}\n`;
+    for (const line of content)
+        out += row(line);
+    out += `  ${DIM}╰${bar}╯${RESET}`;
+    return out;
+}
+export function render(ad, style) {
+    return style === "banner" ? renderBanner(ad) : renderLine(ad);
+}
+/** Width ignoring ANSI codes. */
+function visibleLen(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function pad(s, width) {
+    return s + " ".repeat(Math.max(0, width - visibleLen(s)));
+}
+export { BOLD };

package/dist/report.d.ts

@@ -0,0 +1,7 @@
+/** Counts from the live log (used by tests / `termad status`). */
+export declare function pendingDisplayCount(): number;
+/**
+ * Report accumulated displays. Returns a human summary, or null when there
+ * is nothing to report or the endpoint is unreachable (counts are kept).
+ */
+export declare function reportDisplays(): Promise<string | null>;

package/dist/report.js

@@ -0,0 +1,91 @@
+/**
+ * Batch impression reporting: the wrapper appends one line of ad id to the
+ * display log per render; this reports the accumulated counts to the
+ * endpoint and credits the runner's 50% share in the ledger.
+ *
+ * No per-render network activity exists anywhere — the only "measurement"
+ * is counting what was actually printed to a terminal.
+ */
+import { appendFileSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { loadConfig } from "./core/config.js";
+import { paths } from "./core/paths.js";
+const PENDING = () => paths.displayLog() + ".sending";
+const REPORT_TIMEOUT_MS = 5000;
+/** Counts from the live log (used by tests / `termad status`). */
+export function pendingDisplayCount() {
+    let raw = "";
+    try {
+        raw = readFileSync(paths.displayLog(), "utf8");
+    }
+    catch {
+        return 0;
+    }
+    return raw.split("\n").filter((l) => l.trim()).length;
+}
+/**
+ * Report accumulated displays. Returns a human summary, or null when there
+ * is nothing to report or the endpoint is unreachable (counts are kept).
+ */
+export async function reportDisplays() {
+    const cfg = loadConfig();
+    if (!cfg.endpoint)
+        return null;
+    // Recover a previous attempt that failed mid-flight (counts are never
+    // dropped silently; worst case a crash re-reports one batch once).
+    try {
+        const prev = readFileSync(PENDING(), "utf8");
+        if (prev)
+            appendFileSync(paths.displayLog(), prev);
+        rmSync(PENDING(), { force: true });
+    }
+    catch { }
+    let raw;
+    try {
+        raw = readFileSync(paths.displayLog(), "utf8");
+    }
+    catch {
+        return null;
+    }
+    const counts = {};
+    for (const line of raw.split("\n")) {
+        const id = line.trim();
+        if (id)
+            counts[id] = (counts[id] ?? 0) + 1;
+    }
+    const total = Object.values(counts).reduce((a, b) => a + b, 0);
+    if (!total)
+        return null;
+    // Snapshot before the POST so renders that happen mid-flight stay counted.
+    try {
+        renameSync(paths.displayLog(), PENDING());
+    }
+    catch {
+        return null;
+    }
+    try {
+        const res = await fetch(`${cfg.endpoint.replace(/\/+$/, "")}/v1/report`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ uid: cfg.uid, counts }),
+            signal: AbortSignal.timeout(REPORT_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return null;
+        const body = (await res.json());
+        rmSync(PENDING(), { force: true });
+        const share = typeof body.runnerEarnedMilliCents === "number"
+            ? `, runner share +$${(body.runnerEarnedMilliCents / 1000 / 100).toFixed(4)}`
+            : "";
+        return `${total} display(s) reported${share}`;
+    }
+    catch {
+        // Endpoint down → restore the snapshot so nothing is lost.
+        try {
+            const snap = readFileSync(PENDING(), "utf8");
+            appendFileSync(paths.displayLog(), snap);
+            rmSync(PENDING(), { force: true });
+        }
+        catch { }
+        return null;
+    }
+}

package/dist/surfaces/inline.d.ts

@@ -0,0 +1,17 @@
+export interface InlineResult {
+    ok: boolean;
+    alreadyPatched?: boolean;
+    reason?: string;
+    mode?: "binary-patch" | "wrapper-fallback";
+}
+export declare const INLINE_MARKER = "===== TERMAD-INLINE =====";
+export declare const INLINE_BACKUP_EXT = ".termad-bundle-orig";
+export declare function inlineBackupPath(target: string): string;
+export declare function isInlinePatched(target: string): boolean;
+/**
+ * Attempt to patch a compiled binary to render ads inline in the TUI.
+ * Falls back gracefully if patching isn't possible.
+ */
+export declare function installInline(target: string): InlineResult;
+export declare function uninstallInline(target: string): InlineResult;
+export declare function isCompiledBinary(p: string): boolean;

package/dist/surfaces/inline.js

@@ -0,0 +1,171 @@
+/**
+ * Inline (in-TUI) patching for compiled CLIs.
+ *
+ * Goal: inject a tiny footer renderer into the CLI's TUI so the ad appears
+ * inside the UI (like Kickbacks did), not above it.
+ *
+ * Strategy:
+ * - Detect Bun/Node compiled single-file binaries (Mach-O/ELF) by magic bytes
+ * - Keep pristine original in <bin>.termad-bundle-orig (separate from wrapper backup)
+ * - Search for Ink/render footers or stable strings and inject a loader that
+ *   reads ~/.termad/ad.txt and renders "[ad] ..." as a subtle footer line
+ * - Fully reversible via uninstall + audit tracking
+ */
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { WRAPPER_MARKER } from "../core/paths.js";
+export const INLINE_MARKER = "===== TERMAD-INLINE =====";
+export const INLINE_BACKUP_EXT = ".termad-bundle-orig";
+export function inlineBackupPath(target) {
+    return target + INLINE_BACKUP_EXT;
+}
+export function isInlinePatched(target) {
+    try {
+        const buf = readFileSync(target);
+        // Quick check: look for our marker string in the binary
+        return buf.indexOf(Buffer.from(INLINE_MARKER)) !== -1;
+    }
+    catch {
+        return false;
+    }
+}
+function isMachO(p) {
+    try {
+        const buf = readFileSync(p);
+        if (buf.length < 4)
+            return false;
+        // fat binary or 64-bit little/big endian
+        const m = buf.readUInt32BE(0);
+        if (m === 0xcafebabe || m === 0xbebafeca)
+            return true;
+        const m2 = buf.readUInt32LE(0);
+        if (m2 === 0xfeedfacf || m2 === 0xcffaedfe)
+            return true;
+        if (m === 0xfeedface || m === 0xcefaedfe)
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function isElf(p) {
+    try {
+        const buf = readFileSync(p);
+        return buf.length >= 4 && buf[0] === 0x7f && buf[1] === 0x45 && buf[2] === 0x4c && buf[3] === 0x46;
+    }
+    catch {
+        return false;
+    }
+}
+function sha256(p) {
+    try {
+        return createHash("sha256").update(readFileSync(p)).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+// Minimal inline ad loader injected into embedded bundle
+// Tries to read ~/.termad/ad.txt and expose a global for TUI to render
+const INLINE_PAYLOAD = `/* ${INLINE_MARKER} */;(()=>{try{const fs=require('fs');const os=require('os');const p=require('path');const home=process.env.TERMAD_HOME||p.join(os.homedir(),'.termad');const f=p.join(home,'ad.txt');const c=fs.readFileSync(f,'utf8');const lines=c.replace(/\\r/g,'').split('\\n');const text=(lines[0]||'').trim();const url=(lines[1]||'').trim();if(text&&text!=='-'){globalThis.__TERMAD_AD__={text,url:url&&url!=='-'?url:undefined,at:Date.now()};}}catch(e){}})();`;
+/**
+ * Attempt to patch a compiled binary to render ads inline in the TUI.
+ * Falls back gracefully if patching isn't possible.
+ */
+export function installInline(target) {
+    if (!existsSync(target))
+        return { ok: false, reason: `target not found: ${target}` };
+    if (isInlinePatched(target))
+        return { ok: true, alreadyPatched: true, mode: "binary-patch" };
+    if (isWrappedCheck(target)) {
+        // Don't fight the shell wrapper - we'll upgrade it instead
+        return { ok: false, reason: "has termad wrapper; use inline upgrade" };
+    }
+    const bak = inlineBackupPath(target);
+    if (!existsSync(bak)) {
+        try {
+            copyFileSync(target, bak);
+        }
+        catch (e) {
+            return { ok: false, reason: e.message };
+        }
+    }
+    // For now, try a conservative string injection approach
+    // Look for common Ink patterns and inject our loader
+    try {
+        let buf = readFileSync(target);
+        let patched = false;
+        // Try to inject near module load points
+        const injectPoints = [
+            Buffer.from("use strict"),
+            Buffer.from("var React"),
+            Buffer.from('"use strict"'),
+        ];
+        for (const pt of injectPoints) {
+            const idx = buf.indexOf(pt);
+            if (idx !== -1 && idx < 2048) {
+                // Insert our payload after the first occurrence
+                const payload = Buffer.from(INLINE_PAYLOAD + "\n");
+                buf = Buffer.concat([buf.slice(0, idx), payload, buf.slice(idx)]);
+                patched = true;
+                break;
+            }
+        }
+        if (!patched) {
+            // Try appending near beginning of embedded JS
+            // Many Bun binaries have a loader section
+            const payload = Buffer.from(INLINE_PAYLOAD + "\n");
+            // Insert after first 256 bytes
+            buf = Buffer.concat([buf.slice(0, 512), payload, buf.slice(512)]);
+            patched = true;
+        }
+        if (patched) {
+            const mode = statSync(target).mode & 0o777;
+            writeFileSync(target, buf);
+            try {
+                // Restore permissions
+                if (!target.endsWith(".cmd") && !target.endsWith(".bat")) {
+                    // chmod if possible
+                }
+            }
+            catch { }
+            return { ok: true, mode: "binary-patch" };
+        }
+    }
+    catch (e) {
+        return { ok: false, reason: e.message };
+    }
+    return { ok: false, reason: "could not find injection point" };
+}
+function isWrappedCheck(target) {
+    try {
+        const head = readFileSync(target, "utf8").slice(0, 256);
+        return head.includes(WRAPPER_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+export function uninstallInline(target) {
+    const bak = inlineBackupPath(target);
+    if (!existsSync(bak)) {
+        return { ok: true, alreadyPatched: false, reason: "no inline backup found" };
+    }
+    try {
+        if (existsSync(target) && isInlinePatched(target)) {
+            const mode = statSync(bak).mode & 0o777;
+            copyFileSync(bak, target);
+            rmSync(bak);
+            return { ok: true };
+        }
+        rmSync(bak);
+        return { ok: true, reason: "target not patched inline; backup removed" };
+    }
+    catch (e) {
+        return { ok: false, reason: e.message };
+    }
+}
+export function isCompiledBinary(p) {
+    return isMachO(p) || isElf(p);
+}

package/dist/surfaces/pty-inject.d.ts

@@ -0,0 +1 @@
+export declare function runWithAdOverlay(binary: string, args?: string[]): Promise<void>;

package/dist/surfaces/pty-inject.js

@@ -0,0 +1,133 @@
+import { readFileSync, appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const TERMAD_HOME = process.env.TERMAD_HOME || join(homedir(), ".termad");
+const AD_FILE = join(TERMAD_HOME, "ad.txt");
+const COUNT_FILE = join(TERMAD_HOME, "display.log");
+function readAd() {
+    try {
+        const raw = readFileSync(AD_FILE, "utf8").replace(/\r/g, "").split("\n");
+        const text = (raw[0] || "").trim();
+        const url = (raw[1] || "").trim();
+        const id = (raw[3] || "").trim();
+        if (!text || text === "-")
+            return null;
+        return { text, url: url && url !== "-" ? url : undefined, id: id && id !== "-" ? id : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+function count(id) {
+    if (!id)
+        return;
+    try {
+        appendFileSync(COUNT_FILE, id + "\n");
+    }
+    catch { }
+}
+function buildFooter(ad) {
+    const label = "\x1b[2m\x1b[33m[ad]\x1b[0m";
+    const text = ad.text.length > 80 ? ad.text.slice(0, 77) + "..." : ad.text;
+    const url = ad.url && ad.url.length > 60 ? ad.url.slice(0, 57) + "..." : ad.url;
+    let line = ` ${label}  ${text}`;
+    if (url)
+        line += `  \x1b[36m${url}\x1b[0m`;
+    return line;
+}
+export function runWithAdOverlay(binary, args = []) {
+    return runWithAdOverlayAsync(binary, args);
+}
+async function runWithAdOverlayAsync(binary, args = []) {
+    // Try to use node-pty if available
+    let pty;
+    try {
+        // @ts-ignore
+        pty = await import("node-pty");
+    }
+    catch {
+        try {
+            // @ts-ignore
+            pty = await import("@lydell/node-pty");
+        }
+        catch { }
+    }
+    if (!pty) {
+        // No PTY available - fall back to printing banner then execing
+        const ad = readAd();
+        if (ad) {
+            process.stdout.write("\n  [ad]  " + ad.text + "\n");
+            if (ad.url)
+                process.stdout.write("  " + ad.url + "\n\n");
+            count(ad.id);
+        }
+        const { spawn } = await import("node:child_process");
+        const child = spawn(binary, args, { stdio: "inherit" });
+        child.on("exit", (code) => process.exit(code ?? 0));
+        return;
+    }
+    const ad = readAd();
+    if (ad?.id)
+        count(ad.id);
+    const cols = process.stdout.columns || 120;
+    const rows = process.stdout.rows || 40;
+    const ptyProcess = pty.spawn(binary, args, {
+        name: "xterm-256color",
+        cols,
+        rows,
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    let footerVisible = !!ad;
+    let lastAd = ad;
+    function drawFooter() {
+        if (!footerVisible || !lastAd)
+            return;
+        const footer = buildFooter(lastAd);
+        // Move to bottom row, clear line, print footer
+        const termRows = ptyProcess.rows || rows;
+        process.stdout.write(`\x1b[s\x1b[${termRows};1H\x1b[2K${footer}\x1b[u`);
+    }
+    function hideFooter() {
+        const termRows = ptyProcess.rows || rows;
+        process.stdout.write(`\x1b[s\x1b[${termRows};1H\x1b[2K\x1b[u`);
+    }
+    // Pipe PTY output to stdout with footer redrawn after each chunk
+    ptyProcess.onData((data) => {
+        process.stdout.write(data);
+        // Redraw footer after a short delay to stay on top
+        setTimeout(drawFooter, 10);
+    });
+    // Pipe stdin to PTY
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.on("data", (data) => {
+        ptyProcess.write(data);
+    });
+    // Handle resize
+    process.stdout.on("resize", () => {
+        const c = process.stdout.columns || cols;
+        const r = process.stdout.rows || rows;
+        try {
+            ptyProcess.resize(c, r);
+        }
+        catch { }
+        setTimeout(drawFooter, 50);
+    });
+    // Handle exit
+    ptyProcess.onExit(({ exitCode }) => {
+        if (process.stdin.isTTY) {
+            try {
+                process.stdin.setRawMode(false);
+            }
+            catch { }
+        }
+        process.stdin.pause();
+        hideFooter();
+        process.exit(exitCode ?? 0);
+    });
+    // Initial draw
+    setTimeout(drawFooter, 100);
+    setInterval(drawFooter, 500); // Keep footer visible on redraws
+}

package/dist/surfaces/statusline.d.ts

@@ -0,0 +1,9 @@
+export declare function settingsPath(): string;
+export interface StatuslineInstallResult {
+    ok: boolean;
+    alreadyInstalled?: boolean;
+    reason?: string;
+}
+export declare function installStatusline(): StatuslineInstallResult;
+export declare function uninstallStatusline(): StatuslineInstallResult;
+export declare function isStatuslineInstalled(): boolean;