@geteigen/cli 0.0.0-stage → 3.1.0

package/dist/shared/workspace.d.ts

@@ -0,0 +1,49 @@
+/** Git / file browsing data shared by cloud sandboxes and local machines. */
+export interface WorkspaceGitChange {
+    status: string;
+    path: string;
+}
+export interface WorkspaceGitCommit {
+    sha: string;
+    subject: string;
+    author: string;
+    relativeTime: string;
+}
+export interface WorkspaceGitSnapshot {
+    branch: string | null;
+    changes: WorkspaceGitChange[];
+    /** Uncommitted diff against HEAD (truncated). */
+    diff: string;
+    diffTruncated: boolean;
+    commits: WorkspaceGitCommit[];
+    ahead: number | null;
+    prUrl?: string | null;
+    /** Local and remote-tracking branch names, for the git panel switcher. */
+    branches?: string[];
+}
+/** Branch names from `git branch -a --format=%(refname:short)`. */
+export declare function parseGitBranches(raw: string, current: string | null): string[];
+export declare function assertGitBranchName(raw: string): string;
+export declare function assertCommitMessage(raw: string): string;
+/** Repo-relative path from `git status --porcelain` (or an empty string to discard everything). */
+export declare function assertGitChangePath(raw: string): string;
+export interface WorkspaceRepoEntry {
+    name: string;
+    /** Repo-relative path. */
+    path: string;
+    type: "dir" | "file";
+    sizeBytes?: number;
+}
+export interface WorkspaceRepoFile {
+    path: string;
+    sizeBytes: number;
+    content: string | null;
+    binary: boolean;
+    truncated: boolean;
+    /** Inline preview for raster images (base64 data URL). */
+    imageDataUrl?: string;
+}
+export interface WorkspacePathMatch {
+    path: string;
+    type: "dir" | "file";
+}

package/dist/shared/workspace.js

@@ -0,0 +1,53 @@
+/** Git / file browsing data shared by cloud sandboxes and local machines. */
+/** Branch names from `git branch -a --format=%(refname:short)`. */
+export function parseGitBranches(raw, current) {
+    const names = new Set();
+    for (const line of raw.split("\n")) {
+        let name = line.trim();
+        if (!name || name === "HEAD" || name.includes("->"))
+            continue;
+        if (name.startsWith("origin/"))
+            name = name.slice("origin/".length);
+        if (!name || name === "HEAD")
+            continue;
+        names.add(name);
+    }
+    if (current && current !== "HEAD")
+        names.add(current);
+    return [...names].sort((a, b) => a.localeCompare(b)).slice(0, 200);
+}
+export function assertGitBranchName(raw) {
+    const branch = raw.trim();
+    if (!branch ||
+        branch.length > 200 ||
+        branch.startsWith("-") ||
+        branch.includes("..") ||
+        branch.endsWith("/") ||
+        branch.endsWith(".lock") ||
+        branch.includes("@{") ||
+        !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(branch)) {
+        throw new Error("Invalid branch name");
+    }
+    return branch;
+}
+export function assertCommitMessage(raw) {
+    const message = raw.replace(/\r\n/g, "\n").trim();
+    if (!message)
+        throw new Error("Write a commit message");
+    if (message.length > 5_000)
+        throw new Error("Commit message is too long");
+    return message;
+}
+/** Repo-relative path from `git status --porcelain` (or an empty string to discard everything). */
+export function assertGitChangePath(raw) {
+    const path = raw.trim().replace(/\\/g, "/").replace(/^"+|"+$/g, "");
+    if (!path)
+        return "";
+    if (path.length > 1_000 ||
+        path.startsWith("/") ||
+        path.includes("\0") ||
+        path.split("/").some((part) => part === "..")) {
+        throw new Error("Invalid path");
+    }
+    return path;
+}

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export declare function startWorker(repoPathOverride?: string): void;

package/dist/worker.js

@@ -0,0 +1,266 @@
+import { io } from "socket.io-client";
+import { hostname } from "os";
+import { createHash } from "crypto";
+import chalk from "chalk";
+import { loadConfig } from "./config.js";
+import { pickFolder } from "./pickFolder.js";
+import { listLocalModels } from "./listModels.js";
+import { runAgent, abortAgent, isEditTool, getFileDiff, } from "./agent.js";
+import { listChatSessions } from "./listSessions.js";
+function generateWorkerId(email) {
+    const raw = `${hostname()}-${email}`;
+    return createHash("sha256").update(raw).digest("hex").slice(0, 16);
+}
+export function startWorker(repoPathOverride) {
+    const config = loadConfig();
+    if (!config) {
+        console.error(chalk.red("Not logged in. Run `steer login` first."));
+        process.exit(1);
+    }
+    const workerId = generateWorkerId(config.email);
+    const serverUrl = config.serverUrl;
+    console.log(chalk.blue("Connecting to"), serverUrl);
+    console.log(chalk.gray(`Worker ID: ${workerId}`));
+    let activeRoomId = null;
+    let runSeq = 0;
+    /** Events produced while offline — flushed on reconnect (agent keeps running). */
+    const offlineQueue = [];
+    const MAX_QUEUE = 500;
+    const socket = io(`${serverUrl}/worker`, {
+        auth: { token: config.token },
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2000,
+        reconnectionDelayMax: 30000,
+        transports: ["websocket", "polling"],
+    });
+    const emitOrQueue = (event, payload) => {
+        if (socket.connected) {
+            socket.emit(event, payload);
+            return;
+        }
+        if (offlineQueue.length >= MAX_QUEUE)
+            offlineQueue.shift();
+        offlineQueue.push({ event, payload });
+    };
+    const flushQueue = () => {
+        if (!offlineQueue.length)
+            return;
+        console.log(chalk.gray(`  Flushing ${offlineQueue.length} buffered event(s)…`));
+        const batch = offlineQueue.splice(0, offlineQueue.length);
+        for (const item of batch) {
+            socket.emit(item.event, item.payload);
+        }
+    };
+    const announceReady = () => {
+        socket.emit("worker:ready", {
+            workerId,
+            machineName: hostname(),
+            activeRoomId,
+            busy: Boolean(activeRoomId),
+        });
+    };
+    socket.on("connect", () => {
+        console.log(chalk.green("✓ Connected to server"));
+        if (activeRoomId) {
+            console.log(chalk.cyan(`  Agent still running for room ${activeRoomId} — resuming stream`));
+        }
+        announceReady();
+        flushQueue();
+    });
+    socket.on("disconnect", (reason) => {
+        console.log(chalk.yellow(`Disconnected: ${reason}`));
+        if (activeRoomId) {
+            console.log(chalk.yellow(`  Agent keeps running locally for room ${activeRoomId} (will sync on reconnect)`));
+        }
+        // Do NOT abortAgent() — Cursor should finish even if the socket drops.
+    });
+    socket.on("connect_error", (err) => {
+        console.error(chalk.red(`Connection error: ${err.message}`));
+    });
+    socket.on("worker:run-prompt", (payload) => {
+        const { roomId, prompt, repoPath: payloadRepoPath, modelId, sessionId, } = payload;
+        const repoPath = repoPathOverride || payloadRepoPath;
+        if (activeRoomId) {
+            console.log(chalk.yellow(`  Rejecting new prompt — already running for room ${activeRoomId}`));
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                event: {
+                    kind: "error",
+                    message: "Worker is already running another prompt",
+                },
+            });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                event: { kind: "done", result: "" },
+            });
+            return;
+        }
+        const thisRun = ++runSeq;
+        activeRoomId = roomId;
+        console.log(chalk.cyan(`\n━━━ Running prompt in room ${roomId} ━━━`));
+        console.log(chalk.gray(`Repo: ${repoPath}`));
+        console.log(chalk.gray(`Model: ${modelId}`));
+        console.log(chalk.gray(`Prompt: ${prompt.slice(0, 100)}${prompt.length > 100 ? "…" : ""}`));
+        const editedPaths = new Set();
+        let lastMsgId = "";
+        let emittedTerminal = false;
+        const onEvent = (event) => {
+            if (thisRun !== runSeq)
+                return;
+            if (event.kind === "done" || event.kind === "error") {
+                emittedTerminal = true;
+            }
+            emitOrQueue("worker:agent-event", { roomId, event });
+            if (event.kind === "tool_start") {
+                console.log(chalk.yellow(`  ▸ ${event.name} ${event.detail}`));
+            }
+            else if (event.kind === "tool_done") {
+                console.log(chalk.green(`  ✓ ${event.name} ${event.detail}`));
+                if (isEditTool(event.name) && event.path) {
+                    editedPaths.add(event.path);
+                    lastMsgId = event.callId;
+                }
+            }
+            else if (event.kind === "assistant_final") {
+                console.log(chalk.white(`  Assistant: ${event.text.slice(0, 120)}…`));
+            }
+            else if (event.kind === "error") {
+                console.error(chalk.red(`  ✗ Error: ${event.message}`));
+            }
+            else if (event.kind === "done") {
+                console.log(chalk.green("  ✓ Agent finished"));
+            }
+        };
+        const finishRun = (terminal) => {
+            if (thisRun !== runSeq)
+                return;
+            if (terminal && !emittedTerminal) {
+                emitOrQueue("worker:agent-event", { roomId, event: terminal });
+                emittedTerminal = true;
+            }
+            else if (!emittedTerminal) {
+                emitOrQueue("worker:agent-event", {
+                    roomId,
+                    event: { kind: "done", result: "" },
+                });
+                emittedTerminal = true;
+            }
+            if (activeRoomId === roomId)
+                activeRoomId = null;
+        };
+        runAgent(repoPath, prompt, modelId, onEvent, sessionId)
+            .then(async () => {
+            if (thisRun !== runSeq)
+                return;
+            for (const filePath of editedPaths) {
+                try {
+                    const patch = await getFileDiff(repoPath, filePath);
+                    if (patch) {
+                        emitOrQueue("worker:file-diff", {
+                            roomId,
+                            msgId: lastMsgId,
+                            toolName: "edit",
+                            path: filePath,
+                            patch,
+                        });
+                    }
+                }
+                catch {
+                    // diff failures are non-fatal
+                }
+            }
+            finishRun({ kind: "done", result: "" });
+        })
+            .catch((err) => {
+            if (thisRun !== runSeq)
+                return;
+            const message = err.message || "Agent error";
+            console.error(chalk.red(`Agent error: ${message}`));
+            finishRun({ kind: "error", message });
+            emitOrQueue("worker:agent-event", {
+                roomId,
+                event: { kind: "done", result: "" },
+            });
+        });
+    });
+    socket.on("worker:abort", (_payload) => {
+        console.log(chalk.yellow("  ⚠ Abort requested"));
+        abortAgent();
+    });
+    socket.on("worker:pick-folder", async (payload) => {
+        console.log(chalk.cyan("  📂 Opening folder picker…"));
+        try {
+            const path = await pickFolder();
+            if (path) {
+                console.log(chalk.green(`  ✓ Selected: ${path}`));
+            }
+            else {
+                console.log(chalk.yellow("  Folder pick cancelled"));
+            }
+            emitOrQueue("worker:folder-picked", {
+                requestId: payload.requestId,
+                path,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            console.error(chalk.red(`  ✗ Folder picker error: ${message}`));
+            emitOrQueue("worker:folder-picked", {
+                requestId: payload.requestId,
+                path: null,
+                error: message,
+            });
+        }
+    });
+    socket.on("worker:list-models", async (payload) => {
+        console.log(chalk.cyan("  Listing Cursor models…"));
+        try {
+            const models = await listLocalModels();
+            console.log(chalk.green(`  ✓ ${models.length} models`));
+            emitOrQueue("worker:models-listed", {
+                requestId: payload.requestId,
+                models,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            console.error(chalk.red(`  ✗ List models error: ${message}`));
+            emitOrQueue("worker:models-listed", {
+                requestId: payload.requestId,
+                error: message,
+            });
+        }
+    });
+    socket.on("worker:list-sessions", (payload) => {
+        console.log(chalk.cyan(`  Listing Cursor chats for ${payload.repoPath}…`));
+        try {
+            const sessions = listChatSessions(payload.repoPath);
+            console.log(chalk.green(`  ✓ ${sessions.length} chat(s)`));
+            emitOrQueue("worker:sessions-listed", {
+                requestId: payload.requestId,
+                sessions,
+            });
+        }
+        catch (err) {
+            const message = err.message;
+            console.error(chalk.red(`  ✗ List sessions error: ${message}`));
+            emitOrQueue("worker:sessions-listed", {
+                requestId: payload.requestId,
+                sessions: [],
+                error: message,
+            });
+        }
+    });
+    process.on("SIGINT", () => {
+        console.log(chalk.gray("\nShutting down worker…"));
+        abortAgent();
+        socket.disconnect();
+        process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+        abortAgent();
+        socket.disconnect();
+        process.exit(0);
+    });
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@geteigen/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.1.0",
+  "description": "CLI worker for Eigen — run local Cursor/ Claude Code/Codex AI agents for multiplayer sessions",
+  "type": "module",
+  "bin": {
+    "eigen": "./dist/cli/src/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "cursor",
+    "claude",
+    "claude-code",
+    "agent",
+    "cli",
+    "steer",
+    "multiplayer",
+    "codex"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "^5.4.0",
+    "commander": "^13.0.0",
+    "cross-spawn": "^7",
+    "ora": "^8.0.0",
+    "socket.io-client": "^4.8.0"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}