@expitc/termad 0.0.0-stage → 0.1.0

package/dist/surfaces/statusline.js

@@ -0,0 +1,115 @@
+/**
+ * Claude CLI surface: uses the PUBLIC statusLine feature in
+ * ~/.claude/settings.json. No binary patching, no wrapper.
+ *
+ * Chain-capture pattern: if the user already has a statusLine, we save it and
+ * our launcher prints the ad, then runs their original with the same stdin.
+ * Uninstall restores the captured statusLine verbatim.
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { paths } from "../core/paths.js";
+export function settingsPath() {
+    const home = process.env.TERMAD_CLAUDE_HOME || `${process.env.HOME}/.claude`;
+    return `${home}/settings.json`;
+}
+function readSettings() {
+    try {
+        return JSON.parse(readFileSync(settingsPath(), "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeSettings(s) {
+    mkdirSync(dirname(settingsPath()), { recursive: true });
+    writeFileSync(settingsPath(), JSON.stringify(s, null, 2) + "\n");
+}
+const LAUNCHER = `// termad statusline launcher (safe to delete; \`termad uninstall\` restores your config)
+import { readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+
+const AD = "__AD__";
+const PREV = "__PREV__";
+
+let input = "";
+try { input = readFileSync(0, "utf8"); } catch {}
+
+let prev = "";
+try {
+  const cfg = JSON.parse(readFileSync(PREV, "utf8"));
+  if (cfg && cfg.statusLine && cfg.statusLine.command) {
+    prev = execSync(cfg.statusLine.command, {
+      input,
+      timeout: 2000,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trimEnd();
+  }
+} catch {}
+
+let ad = "";
+try { ad = readFileSync(AD, "utf8").split("\\n")[0].trim(); } catch {}
+
+if (ad) {
+  console.log(\`  [ad]  \${ad}\`);
+  if (prev) console.log(prev);
+} else {
+  console.log(prev);
+}
+`;
+export function installStatusline() {
+    const s = readSettings();
+    const current = s.statusLine;
+    if (current?.command?.includes("termad")) {
+        return { ok: true, alreadyInstalled: true };
+    }
+    try {
+        mkdirSync(dirname(paths.statuslineScript()), { recursive: true });
+        // Chain-capture the user's statusLine before replacing it.
+        if (current)
+            writeFileSync(paths.prevStatusline(), JSON.stringify({ statusLine: current }, null, 2));
+        else if (existsSync(paths.prevStatusline()))
+            rmSync(paths.prevStatusline());
+        const script = LAUNCHER.split("__AD__").join(paths.adCache())
+            .split("__PREV__").join(paths.prevStatusline());
+        writeFileSync(paths.statuslineScript(), script);
+        s.statusLine = { type: "command", command: `node "${paths.statuslineScript()}"` };
+        writeSettings(s);
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e) };
+    }
+}
+export function uninstallStatusline() {
+    const s = readSettings();
+    const current = s.statusLine;
+    if (!current?.command?.includes("termad")) {
+        return { ok: true, alreadyInstalled: false, reason: "statusline not installed by termad" };
+    }
+    try {
+        let prev = {};
+        try {
+            prev = JSON.parse(readFileSync(paths.prevStatusline(), "utf8"));
+        }
+        catch { }
+        if (prev.statusLine)
+            s.statusLine = prev.statusLine;
+        else
+            delete s.statusLine;
+        writeSettings(s);
+        if (existsSync(paths.prevStatusline()))
+            rmSync(paths.prevStatusline());
+        if (existsSync(paths.statuslineScript()))
+            rmSync(paths.statuslineScript());
+        return { ok: true, alreadyInstalled: true };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e) };
+    }
+}
+export function isStatuslineInstalled() {
+    const current = readSettings().statusLine;
+    return !!current?.command?.includes("termad");
+}

package/dist/surfaces/surfaces.d.ts

@@ -0,0 +1,10 @@
+export interface Surface {
+    id: "claude" | "codex" | "opencode" | "gemini";
+    label: string;
+    /** How the ad gets in front of the user. */
+    mechanism: "statusline" | "wrapper";
+    /** Best-effort executable discovery. Null = not installed. */
+    locate(): string | null;
+}
+export declare const surfaces: Surface[];
+export declare function getSurface(id: string): Surface | undefined;

package/dist/surfaces/surfaces.js

@@ -0,0 +1,47 @@
+/**
+ * Surface registry: each CLI knows how to locate itself and whether it needs
+ * a wrapper (binaries/shims) or config injection (claude statusline).
+ */
+import { locateCli } from "./wrap.js";
+export const surfaces = [
+    {
+        id: "claude",
+        label: "Claude CLI",
+        mechanism: "statusline",
+        // claude is wrapped via ~/.claude/settings.json statusLine — no binary
+        // patching. locate() is just for the doctor/status report.
+        locate: () => locateCli("TERMAD_CLAUDE_BIN", ["claude"], [".local/bin/claude"]),
+    },
+    {
+        id: "codex",
+        label: "Codex CLI",
+        mechanism: "wrapper",
+        locate: () => locateCli("TERMAD_CODEX_BIN", ["codex", "codex.cmd"], [
+            ".codex/bin/codex",
+            ".npm-global/bin/codex",
+            ".bun/bin/codex",
+            ".volta/bin/codex",
+            ".asdf/shims/codex",
+        ]),
+    },
+    {
+        id: "opencode",
+        label: "OpenCode CLI",
+        mechanism: "wrapper",
+        locate: () => locateCli("TERMAD_OPENCODE_BIN", ["opencode", "opencode.cmd"], [
+            ".opencode/bin/opencode",
+            ".local/bin/opencode",
+            ".npm-global/bin/opencode",
+            ".bun/bin/opencode",
+        ]),
+    },
+    {
+        id: "gemini",
+        label: "Gemini CLI",
+        mechanism: "wrapper",
+        locate: () => locateCli("TERMAD_GEMINI_BIN", ["gemini", "gemini.cmd"], [".local/bin/gemini", ".npm-global/bin/gemini", ".bun/bin/gemini", ".volta/bin/gemini"]),
+    },
+];
+export function getSurface(id) {
+    return surfaces.find((s) => s.id === id);
+}

package/dist/surfaces/wrap.d.ts

@@ -0,0 +1,16 @@
+export interface WrapResult {
+    ok: boolean;
+    alreadyInstalled?: boolean;
+    reason?: string;
+}
+export declare function isWrapped(target: string): boolean;
+/** Wrap a binary/shim with the ad-printing wrapper. Idempotent.
+ *  `force` re-bakes an existing wrapper (e.g. after a template upgrade)
+ *  while keeping the pristine backup untouched. */
+export declare function installWrapper(target: string, adCachePath: string, force?: boolean): WrapResult;
+/** Restore the pristine binary and remove wrapper + ad cache. Idempotent. */
+export declare function uninstallWrapper(target: string, adCachePath: string): WrapResult;
+/**
+ * Locate a CLI executable: explicit env override → known install dirs → PATH.
+ */
+export declare function locateCli(envVar: string, names: string[], relPaths: string[]): string | null;

package/dist/surfaces/wrap.js

@@ -0,0 +1,108 @@
+/**
+ * Shared wrapper mechanics for the CLI surfaces that need a shim in front of
+ * a binary (codex, opencode, gemini): move the original aside to
+ * `<bin>.termad-orig`, write a marker-tagged wrapper script that prints the
+ * ad cache then execs the backup. Fully reversible, idempotent, and the
+ * marker makes it self-detecting after CLI self-updates.
+ */
+import { chmodSync, copyFileSync, existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { WRAPPER_MARKER, backupPath, paths } from "../core/paths.js";
+const SH_TEMPLATE = "wrapper.sh.asset";
+const CMD_TEMPLATE = "wrapper.cmd.asset";
+function templatePath(isWin) {
+    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);
+}
+export function isWrapped(target) {
+    try {
+        return readFileSync(target, "utf8").includes(WRAPPER_MARKER);
+    }
+    catch {
+        return false;
+    }
+}
+/** Wrap a binary/shim with the ad-printing wrapper. Idempotent.
+ *  `force` re-bakes an existing wrapper (e.g. after a template upgrade)
+ *  while keeping the pristine backup untouched. */
+export function installWrapper(target, adCachePath, force = false) {
+    if (!existsSync(target))
+        return { ok: false, reason: `target not found: ${target}` };
+    if (isWrapped(target) && !force)
+        return { ok: true, alreadyInstalled: true };
+    const isWin = /\.(cmd|bat)$/i.test(target);
+    const bak = backupPath(target);
+    try {
+        // First install: stash the pristine original. Re-wraps (force) and
+        // subsequent installs keep the original backup — never overwrite it
+        // with a wrapper.
+        if (!existsSync(bak)) {
+            if (isWrapped(target))
+                return { ok: false, reason: "wrapped target without backup — run `termad audit`" };
+            copyFileSync(target, bak);
+        }
+        const template = readFileSync(templatePath(isWin), "utf8");
+        const wrapper = template
+            .split("__TERMAD_AD__").join(adCachePath)
+            .split("__TERMAD_COUNT__").join(paths.displayLog())
+            .split("__TERMAD_BACKUP__").join(bak);
+        if (wrapper.includes("__TERMAD_"))
+            return { ok: false, reason: "unbaked template token" };
+        const mode = statSync(target).mode & 0o777;
+        writeFileSync(target, wrapper);
+        if (!isWin)
+            chmodSync(target, 0o755);
+        else
+            chmodSync(target, mode);
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e) };
+    }
+}
+/** Restore the pristine binary and remove wrapper + ad cache. Idempotent. */
+export function uninstallWrapper(target, adCachePath) {
+    const bak = backupPath(target);
+    if (!existsSync(bak))
+        return { ok: true, alreadyInstalled: false, reason: "no backup (not installed)" };
+    try {
+        // Only restore over our own wrapper — never clobber a self-updated CLI.
+        if (existsSync(target) && !isWrapped(target)) {
+            rmSync(bak);
+            return { ok: true, reason: "target changed outside termad; backup discarded, left target alone" };
+        }
+        const mode = statSync(bak).mode & 0o777;
+        copyFileSync(bak, target);
+        chmodSync(target, mode);
+        rmSync(bak);
+        if (existsSync(adCachePath))
+            rmSync(adCachePath);
+        return { ok: true, alreadyInstalled: true };
+    }
+    catch (e) {
+        return { ok: false, reason: String(e) };
+    }
+}
+/**
+ * Locate a CLI executable: explicit env override → known install dirs → PATH.
+ */
+export function locateCli(envVar, names, relPaths) {
+    const explicit = process.env[envVar];
+    if (explicit && existsSync(explicit))
+        return explicit;
+    const home = homedir();
+    const candidates = relPaths.map((p) => join(home, p));
+    for (const c of candidates)
+        if (existsSync(c))
+            return c;
+    for (const dir of (process.env.PATH ?? "").split(delimiter).filter(Boolean)) {
+        for (const name of names) {
+            const p = join(dir, name);
+            if (existsSync(p))
+                return p;
+        }
+    }
+    return null;
+}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@expitc/termad",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "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",
+  "author": "EXPITC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EXPITC/termad.git"
+  },
+  "bugs": {
+    "url": "https://github.com/EXPITC/termad/issues"
+  },
+  "homepage": "https://github.com/EXPITC/termad#readme",
+  "keywords": [
+    "cli",
+    "ads",
+    "terminal",
+    "claude",
+    "codex",
+    "opencode",
+    "gemini",
+    "statusline"
+  ],
+  "bin": {
+    "termad": "dist/cli.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "assets",
+    "README.md",
+    "POLICY.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && node scripts/copy-assets.mjs",
+    "dev": "tsc --watch",
+    "server": "node server/server.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  }
+}