@geteigen/cli 0.0.0-stage → 3.0.0

package/README.md

@@ -1,3 +1,155 @@
-# Temporary Holding Version
+# @geteigen/cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+CLI worker for **Eigen** — runs local **Cursor**, **Claude Code**, **Codex**, and **OpenCode** agents on your machine for multiplayer sessions hosted in the web app.
+
+When you create a **Local** session in Eigen, prompts are relayed to this worker, which executes `cursor agent`, `claude`, `codex`, or `opencode` against a folder on your machine.
+
+**Protocol 10** is required for OpenCode, **Protocol 5** for Codex, and **Protocol 4** to forward chat images/files into the local workspace. Install/update:
+
+```bash
+npm i -g @geteigen/cli@latest
+```
+
+## Requirements
+
+- Node.js 18+
+- [Cursor CLI](https://cursor.com) on your `PATH` (`cursor` command) for Cursor agents
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) (`claude`) for Claude Code agents
+- [Codex CLI](https://github.com/openai/codex) (`codex`) for Codex agents
+- [OpenCode](https://opencode.ai) (`opencode`) for OpenCode agents
+- A Eigen account (sign in on the web app)
+
+## Install
+
+```bash
+npm install -g @geteigen/cli
+```
+
+Or from this repo:
+
+```bash
+cd cli
+pnpm install
+pnpm build
+npm link
+```
+
+## Quick start
+
+1. Sign in on the Eigen web app and open **Pair CLI** (`/cli-pair`).
+2. Generate a pairing code.
+3. On your machine:
+
+```bash
+eigen login
+# Server URL defaults to https://cursor-multiplayer-agent.onrender.com — press Enter
+# Paste the pairing code
+
+cursor agent login   # if not already logged into Cursor CLI
+# For Claude Code / OpenCode local agents, ensure `claude` / `opencode` work in your shell
+
+eigen start
+```
+
+4. Keep `eigen start` running while you use Local sessions in the browser.
+
+Credentials are stored at `~/.config/steer/config.json`.
+
+## Commands
+
+| Command | Description |
+|----------------|-------------|
+| `eigen login` | Pair with your Eigen account via a one-time web code |
+| `eigen logout` | Clear stored credentials |
+| `eigen status` | Show logged-in user, server URL, and your rooms |
+| `eigen start` | Start the worker (connects to the API over WebSocket) |
+| `eigen start --repo <path>` | Same, but force every prompt to use this repo path |
+
+## Server URL
+
+`eigen login` defaults to:
+
+```
+https://cursor-multiplayer-agent.onrender.com
+```
+
+Override per login at the prompt, or with:
+
+```bash
+export STEER_SERVER_URL=http://localhost:3000
+eigen login
+```
+
+Use the local URL when developing against a local API.
+
+## Run agents on a server or VM
+
+Headless machines connect with a **setup token** instead of a browser login.
+In Eigen, open **Machines → Add machine**, choose personal or team (team
+machines can only be added by workspace owners/admins), and copy one of the
+commands it shows. Tokens are single-use by default and expire after 7 days.
+
+**One-line script** (Linux/macOS — needs Node 20+ and git):
+
+```bash
+curl -fsSL https://www.geteigen.space/install.sh | sh -s -- --token mt_…
+# optional: --agents claude,codex,opencode,cursor  --name build-vm  --no-service
+```
+
+**Manual:**
+
+```bash
+npm install -g @geteigen/cli
+eigen connect --token mt_…      # trades the token for this machine's credential
+eigen service install           # systemd (Linux) / launchd (macOS); starts at boot
+```
+
+**Docker** (Claude Code, Codex, OpenCode, and Cursor CLIs preinstalled):
+
+```bash
+docker run -d --name eigen-worker --restart=always \
+  -e EIGEN_MACHINE_TOKEN=mt_… \
+  -v eigen-worker:/root/.config/steer -v eigen-work:/work \
+  ghcr.io/adityaraj-09/eigen-worker:latest
+```
+
+Agents still need provider access on the machine: set `ANTHROPIC_API_KEY` /
+`OPENAI_API_KEY` / `CURSOR_API_KEY` (or sign the CLIs in), or — on team
+machines — keep the "use team keys" policy and Eigen sends the workspace's
+keys with each run without storing them.
+
+**Managing it**
+
+- `eigen service status` / `eigen service logs` / `eigen service uninstall`
+- `eigen start --daemon` runs in the background without a service
+- **Work roots:** sessions clone repos under the work root (`--root <dir>`,
+  `EIGEN_WORK_ROOT`, `/work` in Docker). Admins can also limit agents to
+  allowed folders in Eigen → Machines; the worker refuses anything outside them.
+- **Revoking:** remove the machine in Eigen → Machines. It disconnects at once
+  and its credential stops working; reconnecting needs a new setup token.
+
+## What the worker does
+
+While `eigen start` is connected, the API can ask your machine to:
+
+- List models for each installed agent (`cursor agent --list-models`, `opencode models`, …)
+- Open a native folder picker for Local session create
+- Run **Cursor**, **Claude Code**, **Codex**, or **OpenCode** prompts in the selected repo and stream events back to the room
+- Stream tool results (including file paths and edit diffs) as each tool finishes so the web chat can group and inspect them
+- **Protocol 4+**: write chat images/files into `.steer-uploads/` in the repo so local agents can Read them
+- **Protocol 3+**: Claude Code backend + exclusive file locks before edit tools run (multi-agent conflict resolution)
+- **Protocol 10+**: OpenCode backend (Anthropic / OpenAI provider keys or local CLI login)
+
+## Development
+
+```bash
+pnpm install
+pnpm dev          # run via tsx without building
+pnpm build        # compile to dist/
+```
+
+The published binary is `dist/index.js` (`bin`: `steer`).
+
+## License
+
+MIT

package/dist/agent.d.ts

@@ -0,0 +1,32 @@
+export type AgentStreamEvent = {
+    kind: "session";
+    sessionId: string;
+} | {
+    kind: "assistant_delta";
+    text: string;
+} | {
+    kind: "assistant_final";
+    text: string;
+} | {
+    kind: "tool_start";
+    callId: string;
+    name: string;
+    detail: string;
+    path?: string;
+} | {
+    kind: "tool_done";
+    callId: string;
+    name: string;
+    detail: string;
+    path?: string;
+} | {
+    kind: "error";
+    message: string;
+} | {
+    kind: "done";
+    result: string;
+};
+export declare function isEditTool(name: string): boolean;
+export declare function abortAgent(): void;
+export declare function runAgent(repoPath: string, prompt: string, modelId: string, onEvent: (event: AgentStreamEvent) => void, sessionId?: string | null): Promise<void>;
+export declare function getFileDiff(repoPath: string, filePath: string): Promise<string>;

package/dist/agent.js

@@ -0,0 +1,246 @@
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { existsSync } from "fs";
+import { resolve, relative, isAbsolute } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+const execFileAsync = promisify(execFile);
+// ── Helpers (from server/agentRunner.ts) ─────────────────────────────
+function extractText(message) {
+    if (!message || typeof message !== "object")
+        return "";
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((part) => {
+        if (part && typeof part === "object" && "text" in part) {
+            return String(part.text ?? "");
+        }
+        return "";
+    })
+        .join("");
+}
+function toolInfo(toolCall) {
+    if (!toolCall)
+        return { name: "tool", detail: "" };
+    const key = Object.keys(toolCall).find((k) => k.endsWith("ToolCall") ||
+        (!["hookAdditionalContexts", "toolCallId", "startedAtMs", "completedAtMs"].includes(k) &&
+            typeof toolCall[k] === "object"));
+    const name = key ? key.replace(/ToolCall$/, "") : "tool";
+    const body = key ? toolCall[key] : undefined;
+    const args = body?.args && typeof body.args === "object"
+        ? body.args
+        : undefined;
+    let detail = "";
+    let path;
+    if (args) {
+        for (const k of ["path", "filePath", "file_path", "target_file", "targetFile"]) {
+            if (typeof args[k] === "string" && String(args[k]).trim()) {
+                path = String(args[k]).trim();
+                break;
+            }
+        }
+        detail =
+            String(args.command ?? args.globPattern ?? path ?? args.targetDirectory ?? "") ||
+                JSON.stringify(args).slice(0, 120);
+    }
+    return { name, detail, path };
+}
+// ── Edit-tool detection (from server/gitDiff.ts) ─────────────────────
+const EDIT_TOOL_RE = /^(write|edit|strreplace|searchreplace|delete|applypatch|editnotebook|create|updatefile|deletefile|writefile)/i;
+export function isEditTool(name) {
+    return EDIT_TOOL_RE.test(name.replace(/ToolCall$/i, ""));
+}
+// ── Agent runner ─────────────────────────────────────────────────────
+let activeChild = null;
+export function abortAgent() {
+    activeChild?.kill("SIGTERM");
+    activeChild = null;
+}
+export function runAgent(repoPath, prompt, modelId, onEvent, sessionId) {
+    return new Promise((resolve, reject) => {
+        const args = [
+            "agent",
+            "--print",
+            "--output-format",
+            "stream-json",
+            "--stream-partial-output",
+            "--force",
+            "--trust",
+        ];
+        if (modelId && modelId !== "auto") {
+            args.push("--model", modelId);
+        }
+        if (sessionId) {
+            args.push("--resume", sessionId);
+        }
+        args.push(prompt);
+        const child = spawn("cursor", args, {
+            cwd: repoPath,
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        activeChild = child;
+        let stderr = "";
+        let settled = false;
+        let assistantBuf = "";
+        let gotTerminalEvent = false;
+        const finish = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            activeChild = null;
+            if (err)
+                reject(err);
+            else
+                resolve();
+        };
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        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;
+            }
+            const type = ev.type;
+            if (type === "system" && ev.subtype === "init" && ev.session_id) {
+                onEvent({ kind: "session", sessionId: String(ev.session_id) });
+                return;
+            }
+            if (type === "assistant") {
+                const text = extractText(ev.message);
+                if (!text)
+                    return;
+                if ("timestamp_ms" in ev) {
+                    assistantBuf += text;
+                    onEvent({ kind: "assistant_delta", text: assistantBuf });
+                }
+                else {
+                    assistantBuf = text;
+                    onEvent({ kind: "assistant_final", text });
+                }
+                return;
+            }
+            if (type === "tool_call") {
+                const callId = String(ev.call_id ?? "");
+                const info = toolInfo(ev.tool_call);
+                if (ev.subtype === "started") {
+                    onEvent({
+                        kind: "tool_start",
+                        callId,
+                        name: info.name,
+                        detail: info.detail,
+                        path: info.path,
+                    });
+                }
+                else if (ev.subtype === "completed") {
+                    onEvent({
+                        kind: "tool_done",
+                        callId,
+                        name: info.name,
+                        detail: info.detail,
+                        path: info.path,
+                    });
+                }
+                return;
+            }
+            if (type === "result") {
+                gotTerminalEvent = true;
+                if (ev.session_id) {
+                    onEvent({ kind: "session", sessionId: String(ev.session_id) });
+                }
+                if (ev.is_error) {
+                    const msg = String(ev.result != null && ev.result !== "" ? ev.result : stderr || "Agent error");
+                    onEvent({ kind: "error", message: msg });
+                }
+                else {
+                    const result = String(ev.result ?? assistantBuf);
+                    onEvent({ kind: "done", result });
+                }
+            }
+        });
+        child.on("error", (err) => {
+            if (!gotTerminalEvent) {
+                onEvent({ kind: "error", message: err.message });
+            }
+            finish(err);
+        });
+        child.on("close", (code) => {
+            if (settled)
+                return;
+            if (code === 0) {
+                if (!gotTerminalEvent && assistantBuf) {
+                    onEvent({ kind: "done", result: assistantBuf });
+                }
+                finish();
+            }
+            else {
+                const msg = stderr.trim() || `Agent exited with code ${code ?? "unknown"}`;
+                if (!gotTerminalEvent) {
+                    onEvent({ kind: "error", message: msg });
+                }
+                finish(new Error(msg));
+            }
+        });
+    });
+}
+// ── File diff (from server/gitDiff.ts) ───────────────────────────────
+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();
+}

package/dist/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/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 `steer login` first.");
+    }
+    return { Authorization: `Bearer ${config.token}` };
+}

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

@@ -0,0 +1,24 @@
+import { isEditTool, type AgentBackendKind, type NormalizedAgentEvent } from "../../shared/backends/index.js";
+import type { BuildArgsOptions } from "../../shared/backends/types.js";
+export type AgentStreamEvent = NormalizedAgentEvent;
+export { isEditTool };
+export declare function abortRun(runKey: string): void;
+export declare function abortAll(): void;
+/** @deprecated Use abortRun(runKey) or abortAll(). */
+export declare function abortAgent(runKey?: string): void;
+export interface RunHandle {
+    runKey: string;
+    abort: () => void;
+    promise: Promise<void>;
+}
+export declare function runAgent(repoPath: string, prompt: string, modelId: string, onEvent: (event: AgentStreamEvent) => void, sessionId?: string | null, runKey?: string, backendKind?: AgentBackendKind, mode?: "agent" | "plan"): Promise<void>;
+export declare function runAgentWithHandle(repoPath: string, prompt: string, modelId: string, onEvent: (event: AgentStreamEvent) => void, sessionId?: string | null, runKey?: string, backendKind?: AgentBackendKind, mode?: "agent" | "plan", 
+/** Claude Code / Codex / OpenCode: MCP servers attached for this run (Cursor reads its own mcp.json). */
+mcpServers?: BuildArgsOptions["mcpServers"], 
+/** Extra env for this run only (team machines: workspace provider keys). Never logged or stored. */
+runEnv?: Record<string, string>): RunHandle;
+export declare function getFileDiff(repoPath: string, filePath: string): Promise<string>;
+export declare function revertFiles(repoPath: string, filePaths: string[]): Promise<{
+    reverted: string[];
+    errors: string[];
+}>;