@hasna/terminal 2.3.1 → 2.3.2

package/dist/economy.js

@@ -0,0 +1,123 @@
+// Token economy tracker — tracks token savings across all interactions
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const DIR = join(homedir(), ".terminal");
+const ECONOMY_FILE = join(DIR, "economy.json");
+let stats = null;
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+function loadStats() {
+    if (stats)
+        return stats;
+    ensureDir();
+    if (existsSync(ECONOMY_FILE)) {
+        try {
+            const saved = JSON.parse(readFileSync(ECONOMY_FILE, "utf8"));
+            stats = {
+                totalTokensSaved: saved.totalTokensSaved ?? 0,
+                totalTokensUsed: saved.totalTokensUsed ?? 0,
+                savingsByFeature: {
+                    structured: saved.savingsByFeature?.structured ?? 0,
+                    compressed: saved.savingsByFeature?.compressed ?? 0,
+                    diff: saved.savingsByFeature?.diff ?? 0,
+                    cache: saved.savingsByFeature?.cache ?? 0,
+                    search: saved.savingsByFeature?.search ?? 0,
+                },
+                sessionStart: Date.now(),
+                sessionSaved: 0,
+                sessionUsed: 0,
+            };
+            return stats;
+        }
+        catch { }
+    }
+    stats = {
+        totalTokensSaved: 0,
+        totalTokensUsed: 0,
+        savingsByFeature: { structured: 0, compressed: 0, diff: 0, cache: 0, search: 0 },
+        sessionStart: Date.now(),
+        sessionSaved: 0,
+        sessionUsed: 0,
+    };
+    return stats;
+}
+function saveStats() {
+    ensureDir();
+    if (stats) {
+        writeFileSync(ECONOMY_FILE, JSON.stringify(stats, null, 2));
+    }
+}
+/** Record token savings from a feature */
+export function recordSaving(feature, tokensSaved) {
+    const s = loadStats();
+    s.totalTokensSaved += tokensSaved;
+    s.sessionSaved += tokensSaved;
+    s.savingsByFeature[feature] += tokensSaved;
+    saveStats();
+}
+/** Record tokens used (for AI calls) */
+export function recordUsage(tokens) {
+    const s = loadStats();
+    s.totalTokensUsed += tokens;
+    s.sessionUsed += tokens;
+    saveStats();
+}
+/** Get current economy stats */
+export function getEconomyStats() {
+    return { ...loadStats() };
+}
+/** Format token count for display */
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return `${n}`;
+}
+// ── Weighted economics ──────────────────────────────────────────────────────
+// Saved input tokens are repeated across multiple turns before compaction.
+// Weighted pricing accounts for the actual billing impact.
+/** Provider pricing per million tokens */
+const PROVIDER_PRICING = {
+    cerebras: { input: 0.60, output: 1.20 },
+    groq: { input: 0.15, output: 0.60 },
+    xai: { input: 0.20, output: 1.50 },
+    anthropic: { input: 0.80, output: 4.00 }, // Haiku
+    "anthropic-sonnet": { input: 3.00, output: 15.00 },
+    "anthropic-opus": { input: 5.00, output: 25.00 },
+};
+/** Estimate USD savings from compressed tokens */
+export function estimateSavingsUsd(tokensSaved, consumerModel = "anthropic-opus", avgTurnsBeforeCompaction = 5) {
+    const pricing = PROVIDER_PRICING[consumerModel] ?? PROVIDER_PRICING["anthropic-opus"];
+    const multipliedTokens = tokensSaved * avgTurnsBeforeCompaction;
+    const savingsUsd = (multipliedTokens * pricing.input) / 1_000_000;
+    return { savingsUsd, multipliedTokens, ratePerMillion: pricing.input };
+}
+/** Format a full economics summary */
+export function formatEconomicsSummary() {
+    const s = loadStats();
+    const opus = estimateSavingsUsd(s.totalTokensSaved, "anthropic-opus");
+    const sonnet = estimateSavingsUsd(s.totalTokensSaved, "anthropic-sonnet");
+    const haiku = estimateSavingsUsd(s.totalTokensSaved, "anthropic");
+    return [
+        `Token Economy:`,
+        `  Tokens saved:  ${formatTokens(s.totalTokensSaved)}`,
+        `  Tokens used:   ${formatTokens(s.totalTokensUsed)}`,
+        `  Ratio:         ${s.totalTokensUsed > 0 ? (s.totalTokensSaved / s.totalTokensUsed).toFixed(1) : "∞"}x return`,
+        ``,
+        `  Estimated USD savings (×5 turns before compaction):`,
+        `    Opus ($5/M):   $${opus.savingsUsd.toFixed(2)} (${formatTokens(opus.multipliedTokens)} billable tokens)`,
+        `    Sonnet ($3/M): $${sonnet.savingsUsd.toFixed(2)}`,
+        `    Haiku ($0.8/M): $${haiku.savingsUsd.toFixed(2)}`,
+        ``,
+        `  By feature:`,
+        `    Compressed: ${formatTokens(s.savingsByFeature.compressed)}`,
+        `    Structured: ${formatTokens(s.savingsByFeature.structured)}`,
+        `    Diff cache: ${formatTokens(s.savingsByFeature.diff)}`,
+        `    NL cache:   ${formatTokens(s.savingsByFeature.cache)}`,
+        `    Search:     ${formatTokens(s.savingsByFeature.search)}`,
+    ].join("\n");
+}

package/dist/expand-store.js

@@ -0,0 +1,38 @@
+// Expand store — keeps full output for progressive disclosure
+// Agents get summary first, call expand(key) only if they need details
+const MAX_ENTRIES = 50;
+const store = new Map();
+let counter = 0;
+/** Store full output and return a retrieval key */
+export function storeOutput(command, output) {
+    const key = `out_${++counter}`;
+    // Evict oldest if over limit
+    if (store.size >= MAX_ENTRIES) {
+        const oldest = store.keys().next().value;
+        if (oldest)
+            store.delete(oldest);
+    }
+    store.set(key, { command, output, timestamp: Date.now() });
+    return key;
+}
+/** Retrieve full output by key, optionally filtered */
+export function expandOutput(key, grep) {
+    const entry = store.get(key);
+    if (!entry)
+        return { found: false };
+    let output = entry.output;
+    if (grep) {
+        const pattern = new RegExp(grep, "i");
+        output = output.split("\n").filter(l => pattern.test(l)).join("\n");
+    }
+    return { found: true, output, lines: output.split("\n").length };
+}
+/** List available stored outputs */
+export function listStored() {
+    return [...store.entries()].map(([key, entry]) => ({
+        key,
+        command: entry.command.slice(0, 60),
+        lines: entry.output.split("\n").length,
+        age: Date.now() - entry.timestamp,
+    }));
+}

package/dist/file-cache.js

@@ -0,0 +1,72 @@
+// Universal session file cache — cache any file read, serve from memory on repeat
+import { statSync, readFileSync } from "fs";
+const cache = new Map();
+/** Read a file with session caching. Returns content + cache metadata. */
+export function cachedRead(filePath, options = {}) {
+    const { offset, limit } = options;
+    try {
+        const stat = statSync(filePath);
+        const mtime = stat.mtimeMs;
+        const existing = cache.get(filePath);
+        // Cache hit — file unchanged
+        if (existing && existing.mtime === mtime) {
+            existing.readCount++;
+            existing.lastReadAt = Date.now();
+            const lines = existing.content.split("\n");
+            if (offset !== undefined || limit !== undefined) {
+                const start = offset ?? 0;
+                const end = limit !== undefined ? start + limit : lines.length;
+                return {
+                    content: lines.slice(start, end).join("\n"),
+                    cached: true,
+                    readCount: existing.readCount,
+                };
+            }
+            return { content: existing.content, cached: true, readCount: existing.readCount };
+        }
+        // Cache miss or stale — read from disk
+        const content = readFileSync(filePath, "utf8");
+        cache.set(filePath, {
+            content,
+            mtime,
+            readCount: 1,
+            firstReadAt: Date.now(),
+            lastReadAt: Date.now(),
+        });
+        const lines = content.split("\n");
+        if (offset !== undefined || limit !== undefined) {
+            const start = offset ?? 0;
+            const end = limit !== undefined ? start + limit : lines.length;
+            return { content: lines.slice(start, end).join("\n"), cached: false, readCount: 1 };
+        }
+        return { content, cached: false, readCount: 1 };
+    }
+    catch (e) {
+        return { content: `Error: ${e.message}`, cached: false, readCount: 0 };
+    }
+}
+/** Invalidate cache for a file (call after writes) */
+export function invalidateFile(filePath) {
+    cache.delete(filePath);
+}
+/** Invalidate all files matching a pattern */
+export function invalidatePattern(pattern) {
+    for (const key of cache.keys()) {
+        if (pattern.test(key))
+            cache.delete(key);
+    }
+}
+/** Get cache stats */
+export function cacheStats() {
+    let totalReads = 0;
+    let cacheHits = 0;
+    for (const entry of cache.values()) {
+        totalReads += entry.readCount;
+        cacheHits += Math.max(0, entry.readCount - 1); // first read is never cached
+    }
+    return { files: cache.size, totalReads, cacheHits };
+}
+/** Clear the entire cache */
+export function clearFileCache() {
+    cache.clear();
+}

package/dist/file-index.js

@@ -0,0 +1,62 @@
+// Pre-computed file index — build once, serve search from memory
+// Eliminates subprocess spawning for repeat file queries
+import { spawn } from "child_process";
+let index = null;
+let indexCwd = "";
+let indexTime = 0;
+let watcher = null;
+const INDEX_TTL = 30_000; // 30 seconds
+function exec(command, cwd) {
+    return new Promise((resolve) => {
+        const proc = spawn("/bin/zsh", ["-c", command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
+        let out = "";
+        proc.stdout?.on("data", (d) => { out += d.toString(); });
+        proc.on("close", () => resolve(out));
+    });
+}
+/** Build or return cached file index */
+export async function getFileIndex(cwd) {
+    // Return cached if fresh
+    if (index && indexCwd === cwd && Date.now() - indexTime < INDEX_TTL) {
+        return index;
+    }
+    const raw = await exec("find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' -not -path '*/dist/*' -not -path '*/.next/*' -not -path '*/build/*' 2>/dev/null", cwd);
+    index = raw.split("\n").filter(l => l.trim()).map(p => {
+        const path = p.trim();
+        const parts = path.split("/");
+        const name = parts[parts.length - 1] ?? path;
+        const dir = parts.slice(0, -1).join("/") || ".";
+        const ext = name.includes(".") ? "." + name.split(".").pop() : "";
+        return { path, dir, name, ext };
+    });
+    indexCwd = cwd;
+    indexTime = Date.now();
+    return index;
+}
+/** Search file index by glob pattern (in-memory, no subprocess) */
+export async function searchIndex(cwd, pattern) {
+    const idx = await getFileIndex(cwd);
+    // Convert glob to regex
+    const regex = new RegExp("^" + pattern
+        .replace(/\./g, "\\.")
+        .replace(/\*/g, ".*")
+        .replace(/\?/g, ".")
+        + "$", "i");
+    return idx.filter(e => regex.test(e.name) || regex.test(e.path)).map(e => e.path);
+}
+/** Get file index stats */
+export async function indexStats(cwd) {
+    const idx = await getFileIndex(cwd);
+    const byExt = {};
+    const byDir = {};
+    for (const e of idx) {
+        byExt[e.ext || "(none)"] = (byExt[e.ext || "(none)"] ?? 0) + 1;
+        const topDir = e.dir.split("/").slice(0, 2).join("/");
+        byDir[topDir] = (byDir[topDir] ?? 0) + 1;
+    }
+    return { totalFiles: idx.length, byExtension: byExt, byDir };
+}
+/** Invalidate index */
+export function invalidateIndex() {
+    index = null;
+}

package/dist/history.js

@@ -0,0 +1,62 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const DIR = join(homedir(), ".terminal");
+const HISTORY_FILE = join(DIR, "history.json");
+const CONFIG_FILE = join(DIR, "config.json");
+export const DEFAULT_PERMISSIONS = {
+    destructive: true,
+    network: true,
+    sudo: true,
+    write_outside_cwd: true,
+    install: true,
+};
+export const DEFAULT_CONFIG = {
+    onboarded: false,
+    confirm: false,
+    permissions: DEFAULT_PERMISSIONS,
+};
+function ensureDir() {
+    if (!existsSync(DIR))
+        mkdirSync(DIR, { recursive: true });
+}
+export function loadHistory() {
+    ensureDir();
+    if (!existsSync(HISTORY_FILE))
+        return [];
+    try {
+        return JSON.parse(readFileSync(HISTORY_FILE, "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+export function saveHistory(entries) {
+    ensureDir();
+    writeFileSync(HISTORY_FILE, JSON.stringify(entries.slice(-500), null, 2));
+}
+export function appendHistory(entry) {
+    const existing = loadHistory();
+    saveHistory([...existing, entry]);
+}
+export function loadConfig() {
+    ensureDir();
+    if (!existsSync(CONFIG_FILE))
+        return { ...DEFAULT_CONFIG };
+    try {
+        const saved = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+        return {
+            ...DEFAULT_CONFIG,
+            ...saved,
+            confirm: saved.confirm ?? false,
+            permissions: { ...DEFAULT_PERMISSIONS, ...(saved.permissions ?? {}) },
+        };
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function saveConfig(config) {
+    ensureDir();
+    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/dist/lazy-executor.js

@@ -0,0 +1,54 @@
+// Lazy execution — for large result sets, return count + sample + categories
+// instead of full output. Agent requests slices on demand.
+import { dirname } from "path";
+const LAZY_THRESHOLD = 200; // lines before switching to lazy mode (was 100, too aggressive)
+// Commands where the user explicitly wants full output — never lazify
+const PASSTHROUGH_COMMANDS = [
+    // File reading — user explicitly wants content
+    /\bcat\b/, /\bhead\b/, /\btail\b/, /\bbat\b/, /\bless\b/, /\bmore\b/,
+    // Git review commands — truncating diffs/patches loses semantic meaning
+    /\bgit\s+diff\b/, /\bgit\s+show\b/, /\bgit\s+log\s+-p\b/, /\bgit\s+log\s+--patch\b/,
+    // Summary/report commands — summarizing a summary is pointless
+    /\bsummary\b/i, /\bstatus\b/i, /\breport\b/i, /\bstats\b/i,
+    /\bweek\b/i, /\btoday\b/i, /\bdashboard\b/i,
+];
+/** Check if output should use lazy mode */
+export function shouldBeLazy(output, command) {
+    // Never lazify explicit read commands or summary commands
+    if (command && PASSTHROUGH_COMMANDS.some(p => p.test(command)))
+        return false;
+    return output.split("\n").filter(l => l.trim()).length > LAZY_THRESHOLD;
+}
+/** Convert large output to lazy format: count + sample + categories */
+export function toLazy(output, command) {
+    const lines = output.split("\n").filter(l => l.trim());
+    const sample = lines.slice(0, 20);
+    // Try to categorize by directory (for file-like output)
+    const categories = {};
+    const isFilePaths = lines.filter(l => l.includes("/")).length > lines.length * 0.5;
+    if (isFilePaths) {
+        for (const line of lines) {
+            const dir = dirname(line.trim()) || ".";
+            // Group by top-level dir
+            const topDir = dir.split("/").slice(0, 2).join("/");
+            categories[topDir] = (categories[topDir] ?? 0) + 1;
+        }
+    }
+    return {
+        lazy: true,
+        count: lines.length,
+        sample,
+        categories: Object.keys(categories).length > 1 ? categories : undefined,
+        hint: `${lines.length} results. Showing first 20. Use a more specific query to narrow results.`,
+    };
+}
+/** Get a slice of output */
+export function getSlice(output, offset, limit) {
+    const allLines = output.split("\n").filter(l => l.trim());
+    const slice = allLines.slice(offset, offset + limit);
+    return {
+        lines: slice,
+        total: allLines.length,
+        hasMore: offset + limit < allLines.length,
+    };
+}

package/dist/line-dedup.js

@@ -0,0 +1,59 @@
+// Cross-command line deduplication — track lines already shown to agent
+// When new output contains >50% already-seen lines, suppress them
+const seenLines = new Set();
+const MAX_SEEN = 5000;
+function normalize(line) {
+    return line.trim().toLowerCase();
+}
+/** Deduplicate output lines against session history */
+export function dedup(output) {
+    const lines = output.split("\n");
+    if (lines.length < 5) {
+        // Short output — add to seen, don't dedup
+        for (const l of lines) {
+            if (l.trim())
+                seenLines.add(normalize(l));
+        }
+        return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+    }
+    let novelCount = 0;
+    let seenCount = 0;
+    const novel = [];
+    for (const line of lines) {
+        const norm = normalize(line);
+        if (!norm) {
+            novel.push(line);
+            continue;
+        }
+        if (seenLines.has(norm)) {
+            seenCount++;
+        }
+        else {
+            novelCount++;
+            novel.push(line);
+            seenLines.add(norm);
+        }
+    }
+    // Evict oldest if too large
+    if (seenLines.size > MAX_SEEN) {
+        const entries = [...seenLines];
+        for (let i = 0; i < entries.length - MAX_SEEN; i++) {
+            seenLines.delete(entries[i]);
+        }
+    }
+    // Only dedup if >50% were already seen
+    if (seenCount > lines.length * 0.5) {
+        const result = novel.join("\n");
+        return { output: result + `\n(${seenCount} lines already shown, omitted)`, novelCount, seenCount, deduplicated: true };
+    }
+    // Add all to seen but return full output
+    for (const l of lines) {
+        if (l.trim())
+            seenLines.add(normalize(l));
+    }
+    return { output, novelCount: lines.length, seenCount: 0, deduplicated: false };
+}
+/** Clear dedup history */
+export function clearDedup() {
+    seenLines.clear();
+}

package/dist/loop-detector.js

@@ -0,0 +1,75 @@
+// Edit-test loop detector — detects repetitive test→edit→test patterns
+// and suggests narrowing to specific test files
+const history = [];
+const MAX_HISTORY = 20;
+// Detect test commands
+const TEST_PATTERNS = [
+    /\bbun\s+test\b/, /\bnpm\s+test\b/, /\bnpx\s+jest\b/, /\bnpx\s+vitest\b/,
+    /\bpnpm\s+test\b/, /\byarn\s+test\b/, /\bpytest\b/, /\bgo\s+test\b/,
+    /\bcargo\s+test\b/, /\brspec\b/, /\bphpunit\b/, /\bmocha\b/,
+];
+function isTestCommand(cmd) {
+    return TEST_PATTERNS.some(p => p.test(cmd));
+}
+function isFullSuiteCommand(cmd) {
+    // Full suite = test command without specific file/pattern
+    if (!isTestCommand(cmd))
+        return false;
+    // If it has a specific file or --grep, it's already narrowed
+    if (/\.(test|spec)\.(ts|tsx|js|jsx|py|rs|go)/.test(cmd))
+        return false;
+    if (/--grep|--filter|-t\s/.test(cmd))
+        return false;
+    return true;
+}
+/** Record a command execution and detect loops */
+export function detectLoop(command) {
+    history.push({ command, timestamp: Date.now() });
+    if (history.length > MAX_HISTORY)
+        history.shift();
+    if (!isTestCommand(command)) {
+        return { detected: false, iteration: 0, testCommand: command };
+    }
+    // Count consecutive test runs (allowing non-test commands between them)
+    let testCount = 0;
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (isTestCommand(history[i].command))
+            testCount++;
+        // If we hit a non-test, non-edit command, stop counting
+        // (edits are invisible to us since we only see exec'd commands)
+    }
+    if (testCount < 3 || !isFullSuiteCommand(command)) {
+        return { detected: false, iteration: testCount, testCommand: command };
+    }
+    // Detected loop — suggest narrowing
+    // Try to find a recently-mentioned test file in recent commands
+    let suggestedNarrow;
+    // Look for file paths in recent history that could be test targets
+    for (let i = history.length - 2; i >= Math.max(0, history.length - 10); i--) {
+        const cmd = history[i].command;
+        // Look for edited/touched files
+        const fileMatch = cmd.match(/(\S+\.(ts|tsx|js|jsx|py|rs|go))\b/);
+        if (fileMatch && !isTestCommand(cmd)) {
+            const file = fileMatch[1];
+            // Suggest corresponding test file
+            const testFile = file.replace(/\.(ts|tsx|js|jsx)$/, ".test.$1");
+            suggestedNarrow = command.replace(/\b(test)\b/, `test ${testFile}`);
+            break;
+        }
+    }
+    // Fallback: suggest adding --grep or specific file
+    if (!suggestedNarrow) {
+        suggestedNarrow = undefined; // Can't determine which file
+    }
+    return {
+        detected: true,
+        iteration: testCount,
+        testCommand: command,
+        suggestedNarrow,
+        reason: `Full test suite run ${testCount} times. Consider narrowing to specific test file.`,
+    };
+}
+/** Reset loop detection (e.g., on session start) */
+export function resetLoopDetector() {
+    history.length = 0;
+}

package/dist/mcp/install.js

@@ -0,0 +1,98 @@
+// MCP installation helper — register open-terminal as MCP server for various agents
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+const TERMINAL_BIN = "terminal"; // the CLI binary name
+function which(cmd) {
+    try {
+        return execSync(`which ${cmd}`, { encoding: "utf8" }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+export function installClaude() {
+    try {
+        execSync(`claude mcp add --transport stdio --scope user open-terminal -- ${which(TERMINAL_BIN) ?? "npx"} ${which(TERMINAL_BIN) ? "mcp serve" : "@hasna/terminal mcp serve"}`, { stdio: "inherit" });
+        console.log("✓ Installed open-terminal MCP server for Claude Code");
+        return true;
+    }
+    catch (e) {
+        console.error("Failed to install for Claude Code:", e);
+        return false;
+    }
+}
+export function installCodex() {
+    const configPath = join(homedir(), ".codex", "config.toml");
+    try {
+        let content = existsSync(configPath) ? readFileSync(configPath, "utf8") : "";
+        if (content.includes("[mcp_servers.open-terminal]")) {
+            console.log("✓ open-terminal already configured for Codex");
+            return true;
+        }
+        const bin = which(TERMINAL_BIN) ?? "npx @hasna/terminal";
+        content += `\n[mcp_servers.open-terminal]\ncommand = "${bin}"\nargs = ["mcp", "serve"]\n`;
+        writeFileSync(configPath, content);
+        console.log("✓ Installed open-terminal MCP server for Codex");
+        return true;
+    }
+    catch (e) {
+        console.error("Failed to install for Codex:", e);
+        return false;
+    }
+}
+export function installGemini() {
+    const configPath = join(homedir(), ".gemini", "settings.json");
+    try {
+        let config = {};
+        if (existsSync(configPath)) {
+            config = JSON.parse(readFileSync(configPath, "utf8"));
+        }
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        const bin = which(TERMINAL_BIN) ?? "npx";
+        const args = which(TERMINAL_BIN) ? ["mcp", "serve"] : ["@hasna/terminal", "mcp", "serve"];
+        config.mcpServers["open-terminal"] = { command: bin, args };
+        writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log("✓ Installed open-terminal MCP server for Gemini");
+        return true;
+    }
+    catch (e) {
+        console.error("Failed to install for Gemini:", e);
+        return false;
+    }
+}
+export function installAll() {
+    installClaude();
+    installCodex();
+    installGemini();
+}
+export function handleMcpInstall(args) {
+    const flags = new Set(args);
+    if (flags.has("--all")) {
+        installAll();
+        return;
+    }
+    if (flags.has("--claude")) {
+        installClaude();
+        return;
+    }
+    if (flags.has("--codex")) {
+        installCodex();
+        return;
+    }
+    if (flags.has("--gemini")) {
+        installGemini();
+        return;
+    }
+    console.log("Usage: t mcp install [--claude|--codex|--gemini|--all]");
+    console.log("");
+    console.log("Install open-terminal as an MCP server for AI coding agents.");
+    console.log("");
+    console.log("Options:");
+    console.log("  --claude    Install for Claude Code");
+    console.log("  --codex     Install for OpenAI Codex");
+    console.log("  --gemini    Install for Gemini CLI");
+    console.log("  --all       Install for all agents");
+}