@geteigen/cli 0.0.0-stage → 3.0.0

package/dist/cli/src/agent.js

@@ -0,0 +1,260 @@
+import { killCli, spawnCli } from "./proc.js";
+import { createInterface } from "readline";
+import { existsSync, promises as fsPromises } from "fs";
+import { resolve, relative, isAbsolute } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { getBackend, isEditTool, } from "../../shared/backends/index.js";
+import { mountCursorProjectMcp } from "../../shared/cursorProjectMcp.js";
+import { opencodeSessionInDirectory } from "../../shared/opencodeSession.js";
+const execFileAsync = promisify(execFile);
+export { isEditTool };
+// ── Concurrent child registry ────────────────────────────────────────
+const activeChildren = new Map();
+export function abortRun(runKey) {
+    const child = activeChildren.get(runKey);
+    if (child) {
+        killCli(child);
+        activeChildren.delete(runKey);
+    }
+}
+export function abortAll() {
+    for (const [key, child] of activeChildren) {
+        killCli(child);
+        activeChildren.delete(key);
+    }
+}
+/** @deprecated Use abortRun(runKey) or abortAll(). */
+export function abortAgent(runKey) {
+    if (runKey)
+        abortRun(runKey);
+    else
+        abortAll();
+}
+export function runAgent(repoPath, prompt, modelId, onEvent, sessionId, runKey = `run_${Date.now()}`, backendKind = "cursor", mode = "agent") {
+    return runAgentWithHandle(repoPath, prompt, modelId, onEvent, sessionId, runKey, backendKind, mode).promise;
+}
+export function runAgentWithHandle(repoPath, prompt, modelId, onEvent, sessionId, runKey = `run_${Date.now()}`, backendKind = "cursor", mode = "agent", 
+/** Claude Code / Codex / OpenCode: MCP servers attached for this run (Cursor reads its own mcp.json). */
+mcpServers, 
+/** Extra env for this run only (team machines: workspace provider keys). Never logged or stored. */
+runEnv) {
+    const kind = backendKind === "claude-code" ||
+        backendKind === "codex" ||
+        backendKind === "opencode"
+        ? backendKind
+        : "cursor";
+    const backend = getBackend(kind);
+    const promise = new Promise((resolvePromise, reject) => {
+        const cursorMcp = kind === "cursor" && mcpServers && Object.keys(mcpServers).length
+            ? mcpServers
+            : undefined;
+        const start = async () => {
+            // OpenCode resolves its project from $PWD, not the spawn cwd.
+            const baseEnv = { ...process.env, ...(runEnv || {}), PWD: repoPath };
+            let resumeId = sessionId || null;
+            if (kind === "opencode" &&
+                resumeId &&
+                !(await opencodeSessionInDirectory(repoPath, resumeId, baseEnv))) {
+                resumeId = null;
+            }
+            const buildOpts = {
+                prompt,
+                modelId,
+                sessionId: resumeId,
+                mode,
+                cwd: repoPath,
+                mcpServers,
+            };
+            const args = backend.buildArgs(buildOpts);
+            const backendEnv = backend.buildEnv?.(buildOpts);
+            const mounted = await mountCursorProjectMcp(repoPath, cursorMcp);
+            const child = spawnCli(backend.command, args, {
+                cwd: repoPath,
+                env: { ...baseEnv, ...(backendEnv || {}), ...mounted.env },
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+            activeChildren.set(runKey, child);
+            let stderr = "";
+            let settled = false;
+            const ctx = {
+                assistantBuf: { value: "" },
+                thinkingBuf: { value: "" },
+                gotTerminalEvent: { value: false },
+                stderr: "",
+            };
+            let terminalFlushed = false;
+            const flushTerminal = () => {
+                const events = backend.flush?.(ctx) ?? [];
+                for (const event of events)
+                    onEvent(event);
+                return events.some((event) => event.kind === "done");
+            };
+            const terminalTimer = setInterval(() => {
+                if (settled)
+                    return;
+                if (flushTerminal()) {
+                    terminalFlushed = true;
+                    child.kill();
+                }
+            }, 2_500);
+            terminalTimer.unref?.();
+            const finish = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearInterval(terminalTimer);
+                if (activeChildren.get(runKey) === child) {
+                    activeChildren.delete(runKey);
+                }
+                void mounted.restore().finally(() => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolvePromise();
+                });
+            };
+            child.stderr.on("data", (chunk) => {
+                stderr += chunk.toString();
+                ctx.stderr = stderr;
+            });
+            const rl = createInterface({ input: child.stdout });
+            rl.on("line", (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                let ev;
+                try {
+                    ev = JSON.parse(trimmed);
+                }
+                catch {
+                    return;
+                }
+                for (const event of backend.parseLine(ev, ctx)) {
+                    onEvent(event);
+                }
+            });
+            child.on("error", (err) => {
+                const message = err.code === "ENOENT"
+                    ? `${backend.command} CLI not found — install it and ensure it is on PATH`
+                    : err.message;
+                if (!ctx.gotTerminalEvent.value) {
+                    onEvent({ kind: "error", message });
+                }
+                finish(new Error(message));
+            });
+            child.on("close", (code) => {
+                if (settled)
+                    return;
+                terminalFlushed = flushTerminal() || terminalFlushed;
+                if (code === 0 || (terminalFlushed && ctx.gotTerminalEvent.value)) {
+                    if (!ctx.gotTerminalEvent.value && ctx.assistantBuf.value) {
+                        onEvent({ kind: "done", result: ctx.assistantBuf.value });
+                    }
+                    finish();
+                }
+                else {
+                    const msg = stderr.trim() || `Agent exited with code ${code ?? "unknown"}`;
+                    if (!ctx.gotTerminalEvent.value) {
+                        onEvent({ kind: "error", message: msg });
+                    }
+                    finish(new Error(msg));
+                }
+            });
+        };
+        void start().catch((err) => {
+            reject(err instanceof Error ? err : new Error(String(err)));
+        });
+    });
+    return {
+        runKey,
+        abort: () => abortRun(runKey),
+        promise,
+    };
+}
+// ── File diff ────────────────────────────────────────────────────────
+function resolveInRepo(repoPath, filePath) {
+    const abs = isAbsolute(filePath) ? filePath : resolve(repoPath, filePath);
+    const rel = relative(repoPath, abs);
+    if (rel.startsWith("..") || rel === "")
+        return null;
+    return rel.replace(/\\/g, "/");
+}
+async function runGit(repoPath, args) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd: repoPath,
+            maxBuffer: 8 * 1024 * 1024,
+            encoding: "utf8",
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        return e.stdout || "";
+    }
+}
+async function isTracked(repoPath, rel) {
+    try {
+        await execFileAsync("git", ["ls-files", "--error-unmatch", "--", rel], {
+            cwd: repoPath,
+            encoding: "utf8",
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getFileDiff(repoPath, filePath) {
+    const rel = resolveInRepo(repoPath, filePath);
+    if (!rel)
+        return "";
+    const abs = resolve(repoPath, rel);
+    let patch = await runGit(repoPath, ["diff", "HEAD", "--", rel]);
+    if (!patch)
+        patch = await runGit(repoPath, ["diff", "--", rel]);
+    if (!patch)
+        patch = await runGit(repoPath, ["diff", "--cached", "--", rel]);
+    if (!patch && existsSync(abs) && !(await isTracked(repoPath, rel))) {
+        patch = await runGit(repoPath, [
+            "diff",
+            "--no-index",
+            "--",
+            "/dev/null",
+            rel,
+        ]);
+    }
+    return patch.trim();
+}
+export async function revertFiles(repoPath, filePaths) {
+    const reverted = [];
+    const errors = [];
+    for (const rawPath of filePaths) {
+        if (!rawPath || !rawPath.trim())
+            continue;
+        const rel = resolveInRepo(repoPath, rawPath.trim());
+        if (!rel)
+            continue;
+        const abs = resolve(repoPath, rel);
+        try {
+            const tracked = await isTracked(repoPath, rel);
+            if (tracked) {
+                await runGit(repoPath, ["reset", "HEAD", "--", rel]);
+                await runGit(repoPath, ["checkout", "HEAD", "--", rel]);
+                reverted.push(rel);
+            }
+            else if (existsSync(abs)) {
+                await fsPromises.rm(abs, { force: true, recursive: true });
+                reverted.push(rel);
+            }
+            else {
+                reverted.push(rel);
+            }
+        }
+        catch (err) {
+            errors.push(`Failed to revert ${rel}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { reverted, errors };
+}

package/dist/cli/src/agentTools.d.ts

@@ -0,0 +1,10 @@
+import type { MachineAgentTool } from "../../shared/machines.js";
+/**
+ * Which agent CLIs this machine can run. Shared by the CLI worker (reported
+ * to the server on connect) and the desktop app (Machines page).
+ */
+/** Built per call so a PATH merged after import (desktop login shell) is used. */
+export declare function noColorEnv(): NodeJS.ProcessEnv;
+/** Absolute path of `command` on the current PATH, like `which`. */
+export declare function findOnPath(command: string): string | null;
+export declare function detectAgentTools(): Promise<MachineAgentTool[]>;

package/dist/cli/src/agentTools.js

@@ -0,0 +1,70 @@
+import { accessSync, constants, statSync } from "fs";
+import { homedir } from "os";
+import { delimiter, join } from "path";
+import { execCli } from "./proc.js";
+/**
+ * Which agent CLIs this machine can run. Shared by the CLI worker (reported
+ * to the server on connect) and the desktop app (Machines page).
+ */
+/** Built per call so a PATH merged after import (desktop login shell) is used. */
+export function noColorEnv() {
+    return { ...process.env, NO_COLOR: "1", FORCE_COLOR: "0" };
+}
+const WINDOWS_EXTS = [".exe", ".cmd", ".bat", ""];
+/** Absolute path of `command` on the current PATH, like `which`. */
+export function findOnPath(command) {
+    const exts = process.platform === "win32" ? WINDOWS_EXTS : [""];
+    for (const dir of (process.env.PATH || "").split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const candidate = join(dir, command + ext);
+            try {
+                if (!statSync(candidate).isFile())
+                    continue;
+                if (process.platform !== "win32")
+                    accessSync(candidate, constants.X_OK);
+                return candidate;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return null;
+}
+function displayPath(path) {
+    const home = homedir();
+    return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+async function versionOf(command, args) {
+    try {
+        const { stdout } = await execCli(command, args, { timeout: 15_000, env: noColorEnv() });
+        return stdout.trim().split("\n")[0] || "installed";
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        // Installed but the version flag misbehaved — still usable.
+        return "installed";
+    }
+}
+const TOOLS = [
+    { id: "cursor", label: "Cursor", command: "cursor", args: ["agent", "--version"] },
+    { id: "claude", label: "Claude Code", command: "claude", args: ["--version"] },
+    { id: "codex", label: "Codex", command: "codex", args: ["--version"] },
+    { id: "opencode", label: "OpenCode", command: "opencode", args: ["--version"] },
+];
+export async function detectAgentTools() {
+    return Promise.all(TOOLS.map(async (tool) => {
+        const version = await versionOf(tool.command, tool.args);
+        const path = findOnPath(tool.command);
+        return {
+            id: tool.id,
+            label: tool.label,
+            installed: Boolean(version),
+            ...(version ? { version } : {}),
+            ...(path ? { path: displayPath(path) } : {}),
+        };
+    }));
+}

package/dist/cli/src/auth.d.ts

@@ -0,0 +1,5 @@
+import { type Config } from "./config.js";
+/** Pair CLI with a Clerk-authenticated web account via one-time code. */
+export declare function loginWithPairingCode(serverUrl: string, code: string): Promise<Config>;
+export declare function logout(): void;
+export declare function getAuthHeaders(): Record<string, string>;

package/dist/cli/src/auth.js

@@ -0,0 +1,33 @@
+import { saveConfig, clearConfig, loadConfig } from "./config.js";
+/** Pair CLI with a Clerk-authenticated web account via one-time code. */
+export async function loginWithPairingCode(serverUrl, code) {
+    const base = serverUrl.replace(/\/+$/, "");
+    const normalized = code.trim().toUpperCase().replace(/\s+/g, "");
+    const res = await fetch(`${base}/api/auth/pairing/claim`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code: normalized }),
+    });
+    if (!res.ok) {
+        const err = (await res.json().catch(() => ({})));
+        throw new Error(err.error || `Pairing failed (${res.status})`);
+    }
+    const data = (await res.json());
+    const config = {
+        serverUrl: base,
+        token: data.token,
+        email: data.user.email,
+    };
+    saveConfig(config);
+    return config;
+}
+export function logout() {
+    clearConfig();
+}
+export function getAuthHeaders() {
+    const config = loadConfig();
+    if (!config) {
+        throw new Error("Not logged in. Run `eigen login` first.");
+    }
+    return { Authorization: `Bearer ${config.token}` };
+}

package/dist/cli/src/config.d.ts

@@ -0,0 +1,11 @@
+export interface Config {
+    serverUrl: string;
+    token: string;
+    email: string;
+}
+/** Production API (override with STEER_SERVER_URL for local/dev). */
+export declare const DEFAULT_SERVER_URL: string;
+export declare function getConfigDir(): string;
+export declare function loadConfig(): Config | null;
+export declare function saveConfig(config: Config): void;
+export declare function clearConfig(): void;

package/dist/cli/src/config.js

@@ -0,0 +1,51 @@
+import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+/** Production API (override with STEER_SERVER_URL for local/dev). */
+export const DEFAULT_SERVER_URL = (process.env.STEER_SERVER_URL ||
+    "https://cursor-multiplayer-agent.onrender.com").replace(/\/+$/, "");
+const CONFIG_DIR_NAME = "steer";
+const LEGACY_CONFIG_DIR_NAME = "shared-agent";
+const CONFIG_FILE = "config.json";
+export function getConfigDir() {
+    const dir = join(homedir(), ".config", CONFIG_DIR_NAME);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function loadConfig() {
+    const filePath = join(getConfigDir(), CONFIG_FILE);
+    const legacyPath = join(homedir(), ".config", LEGACY_CONFIG_DIR_NAME, CONFIG_FILE);
+    const path = existsSync(filePath)
+        ? filePath
+        : existsSync(legacyPath)
+            ? legacyPath
+            : null;
+    if (!path)
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.serverUrl || !parsed.token || !parsed.email)
+            return null;
+        // Migrate legacy config into ~/.config/steer/
+        if (path === legacyPath) {
+            saveConfig(parsed);
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveConfig(config) {
+    const filePath = join(getConfigDir(), CONFIG_FILE);
+    writeFileSync(filePath, JSON.stringify(config, null, 2), "utf-8");
+}
+export function clearConfig() {
+    const filePath = join(getConfigDir(), CONFIG_FILE);
+    if (existsSync(filePath)) {
+        rmSync(filePath);
+    }
+}

package/dist/cli/src/cursorAuth.d.ts

@@ -0,0 +1,10 @@
+export declare function getCursorAuth(): Promise<{
+    authenticated: boolean;
+    email?: string;
+    error?: string;
+}>;
+/**
+ * Ensure the Cursor CLI is logged in before starting the worker.
+ * Prompts interactive `cursor agent login` if not authenticated.
+ */
+export declare function ensureCursorAuth(): Promise<void>;

package/dist/cli/src/cursorAuth.js

@@ -0,0 +1,92 @@
+import { execCli, spawnCli } from "./proc.js";
+import chalk from "chalk";
+import ora from "ora";
+export async function getCursorAuth() {
+    try {
+        const { stdout } = await execCli("cursor", ["agent", "whoami", "--format", "json"], {
+            timeout: 30_000,
+            maxBuffer: 1024 * 1024,
+            env: { ...process.env, NO_COLOR: "1" },
+        });
+        const data = JSON.parse(stdout.trim());
+        if (data.isAuthenticated || data.status === "authenticated") {
+            return {
+                authenticated: true,
+                email: data.userInfo?.email,
+            };
+        }
+        return { authenticated: false };
+    }
+    catch (err) {
+        const e = err;
+        // cursor sometimes prints JSON on stdout even with non-zero exit
+        if (e.stdout) {
+            try {
+                const data = JSON.parse(String(e.stdout).trim());
+                if (data.isAuthenticated || data.status === "authenticated") {
+                    return {
+                        authenticated: true,
+                        email: data.userInfo?.email,
+                    };
+                }
+                return { authenticated: false };
+            }
+            catch {
+                // fall through
+            }
+        }
+        if (e.code === "ENOENT") {
+            return {
+                authenticated: false,
+                error: "`cursor` CLI not found. Install Cursor CLI first: https://cursor.com",
+            };
+        }
+        return {
+            authenticated: false,
+            error: e.stderr?.trim() || e.message || "Failed to check Cursor auth",
+        };
+    }
+}
+function runCursorLogin() {
+    return new Promise((resolve) => {
+        const child = spawnCli("cursor", ["agent", "login"], {
+            stdio: "inherit",
+            env: process.env,
+        });
+        child.on("error", (err) => {
+            console.error(chalk.red(`Failed to start cursor login: ${err.message}`));
+            resolve(1);
+        });
+        child.on("close", (code) => resolve(code ?? 1));
+    });
+}
+/**
+ * Ensure the Cursor CLI is logged in before starting the worker.
+ * Prompts interactive `cursor agent login` if not authenticated.
+ */
+export async function ensureCursorAuth() {
+    const spinner = ora("Checking Cursor CLI login…").start();
+    let auth = await getCursorAuth();
+    if (auth.error && auth.error.includes("not found")) {
+        spinner.fail(auth.error);
+        process.exit(1);
+    }
+    if (auth.authenticated) {
+        spinner.succeed(`Cursor CLI logged in as ${chalk.cyan(auth.email || "unknown")}`);
+        return;
+    }
+    spinner.warn("Cursor CLI is not logged in");
+    console.log(chalk.yellow("\n  Local agents need Cursor CLI auth. Opening login…\n"));
+    const code = await runCursorLogin();
+    if (code !== 0) {
+        console.error(chalk.red("\nCursor login failed or was cancelled. Run `cursor agent login` and try again."));
+        process.exit(1);
+    }
+    const verify = ora("Verifying Cursor login…").start();
+    auth = await getCursorAuth();
+    if (!auth.authenticated) {
+        verify.fail("Still not logged into Cursor. Run `cursor agent login` and try again.");
+        process.exit(1);
+    }
+    verify.succeed(`Cursor CLI logged in as ${chalk.cyan(auth.email || "unknown")}`);
+}

package/dist/cli/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};