@expitc/termad 0.1.0 → 0.1.1

package/assets/pty-overlay.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { runWithAdOverlay } from "@expitc/termad/dist/surfaces/pty-inject.js";
+const binary = process.argv[2];
+const args = process.argv.slice(3);
+runWithAdOverlay(binary, args);

package/assets/wrapper.sh.overlay

@@ -0,0 +1,45 @@
+#!/bin/sh
+# ===== TERMAD-OVERLAY =====
+# Reversible termad PTY wrapper. Renders ads INSIDE the TUI as a footer
+# overlay (not above it). Reads ad from "__TERMAD_AD__" and displays as
+# persistent footer. Falls back to pre-banner if node-pty unavailable.
+# Original binary backed up at "__TERMAD_BACKUP__".
+# Restore: copy the backup over this file, or run `termad uninstall`.
+
+TERMAD_AD_FILE="__TERMAD_AD__"
+TERMAD_BACKUP="__TERMAD_BACKUP__"
+TERMAD_COUNT="__TERMAD_COUNT__"
+TERMAD_HOME_DIR="$(dirname "$(dirname "$TERMAD_AD_FILE")")"
+
+# Try PTY overlay via node script bundled with termad
+OVERLAY_SCRIPT="$TERMAD_HOME_DIR/pty-overlay.mjs"
+if [ ! -f "$OVERLAY_SCRIPT" ]; then
+  # Try to find in node_modules or global install
+  OVERLAY_SCRIPT="$(npm root -g 2>/dev/null)/@expitc/termad/dist/surfaces/pty-inject.mjs"
+fi
+
+if [ -f "$OVERLAY_SCRIPT" ] && command -v node >/dev/null 2>&1; then
+  export TERMAD_AD_FILE TERMAD_BACKUP TERMAD_COUNT
+  exec node "$OVERLAY_SCRIPT" "$TERMAD_BACKUP" "$@"
+fi
+
+# Fallback: pre-banner
+AD_TEXT=""
+AD_URL=""
+AD_ID=""
+if [ -r "$TERMAD_AD_FILE" ]; then
+  AD_TEXT=$(head -n 1 "$TERMAD_AD_FILE" 2>/dev/null)
+  AD_URL=$(sed -n 2p "$TERMAD_AD_FILE" 2>/dev/null)
+  AD_ID=$(sed -n 4p "$TERMAD_AD_FILE" 2>/dev/null)
+fi
+if [ -n "$AD_TEXT" ]; then
+  printf '\n  [ad]  %s\n' "$AD_TEXT"
+  case "$AD_URL" in
+    http://*|https://*) printf '  %s\n\n' "$AD_URL" ;;
+    *) printf '\n' ;;
+  esac
+  if [ -n "$AD_ID" ]; then
+    printf '%s\n' "$AD_ID" >> "$TERMAD_COUNT" 2>/dev/null || true
+  fi
+fi
+exec "$TERMAD_BACKUP" "$@"

package/dist/assets/pty-overlay.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { runWithAdOverlay } from "@expitc/termad/dist/surfaces/pty-inject.js";
+const binary = process.argv[2];
+const args = process.argv.slice(3);
+runWithAdOverlay(binary, args);

package/dist/assets/wrapper.sh.overlay

@@ -0,0 +1,45 @@
+#!/bin/sh
+# ===== TERMAD-OVERLAY =====
+# Reversible termad PTY wrapper. Renders ads INSIDE the TUI as a footer
+# overlay (not above it). Reads ad from "__TERMAD_AD__" and displays as
+# persistent footer. Falls back to pre-banner if node-pty unavailable.
+# Original binary backed up at "__TERMAD_BACKUP__".
+# Restore: copy the backup over this file, or run `termad uninstall`.
+
+TERMAD_AD_FILE="__TERMAD_AD__"
+TERMAD_BACKUP="__TERMAD_BACKUP__"
+TERMAD_COUNT="__TERMAD_COUNT__"
+TERMAD_HOME_DIR="$(dirname "$(dirname "$TERMAD_AD_FILE")")"
+
+# Try PTY overlay via node script bundled with termad
+OVERLAY_SCRIPT="$TERMAD_HOME_DIR/pty-overlay.mjs"
+if [ ! -f "$OVERLAY_SCRIPT" ]; then
+  # Try to find in node_modules or global install
+  OVERLAY_SCRIPT="$(npm root -g 2>/dev/null)/@expitc/termad/dist/surfaces/pty-inject.mjs"
+fi
+
+if [ -f "$OVERLAY_SCRIPT" ] && command -v node >/dev/null 2>&1; then
+  export TERMAD_AD_FILE TERMAD_BACKUP TERMAD_COUNT
+  exec node "$OVERLAY_SCRIPT" "$TERMAD_BACKUP" "$@"
+fi
+
+# Fallback: pre-banner
+AD_TEXT=""
+AD_URL=""
+AD_ID=""
+if [ -r "$TERMAD_AD_FILE" ]; then
+  AD_TEXT=$(head -n 1 "$TERMAD_AD_FILE" 2>/dev/null)
+  AD_URL=$(sed -n 2p "$TERMAD_AD_FILE" 2>/dev/null)
+  AD_ID=$(sed -n 4p "$TERMAD_AD_FILE" 2>/dev/null)
+fi
+if [ -n "$AD_TEXT" ]; then
+  printf '\n  [ad]  %s\n' "$AD_TEXT"
+  case "$AD_URL" in
+    http://*|https://*) printf '  %s\n\n' "$AD_URL" ;;
+    *) printf '\n' ;;
+  esac
+  if [ -n "$AD_ID" ]; then
+    printf '%s\n' "$AD_ID" >> "$TERMAD_COUNT" 2>/dev/null || true
+  fi
+fi
+exec "$TERMAD_BACKUP" "$@"

package/dist/core/paths.d.ts

@@ -21,3 +21,4 @@ export declare const paths: {
 /** Wrapper backup for a binary/shim lives next to it: <bin>.termad-orig. */
 export declare function backupPath(target: string): string;
 export declare const WRAPPER_MARKER = "===== TERMAD-CLI =====";
+export declare const OVERLAY_MARKER = "===== TERMAD-OVERLAY =====";

package/dist/core/paths.js

@@ -27,3 +27,4 @@ export function backupPath(target) {
     return target + ".termad-orig";
 }
 export const WRAPPER_MARKER = "===== TERMAD-CLI =====";
+export const OVERLAY_MARKER = "===== TERMAD-OVERLAY =====";

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/wrap.js

@@ -9,12 +9,15 @@ import { chmodSync, copyFileSync, existsSync, readFileSync, rmSync, statSync, wr
 import { delimiter, dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { WRAPPER_MARKER, backupPath, paths } from "../core/paths.js";
+const SH_TEMPLATE_OVERLAY = "wrapper.sh.overlay";
 const SH_TEMPLATE = "wrapper.sh.asset";
 const CMD_TEMPLATE = "wrapper.cmd.asset";
-function templatePath(isWin) {
+function templatePath(isWin, useOverlay = true) {
     const here = dirname(new URL(import.meta.url).pathname);
     // dist/surfaces → ../assets (copy-assets.mjs mirrors assets/ into dist/)
-    return join(here, "..", "assets", isWin ? CMD_TEMPLATE : SH_TEMPLATE);
+    if (isWin)
+        return join(here, "..", "assets", CMD_TEMPLATE);
+    return join(here, "..", "assets", useOverlay ? SH_TEMPLATE_OVERLAY : SH_TEMPLATE);
 }
 export function isWrapped(target) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expitc/termad",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Opt-in, fully reversible text ads for terminal AI CLIs (claude, codex, opencode, gemini). Consent-first, tamper-evident audit, 50% runner revenue share.",
   "type": "module",
   "license": "MIT",