@geteigen/cli 0.0.0-stage → 3.1.0

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

@@ -0,0 +1,10 @@
+import { type WorkspaceGitSnapshot, type WorkspacePathMatch, type WorkspaceRepoEntry, type WorkspaceRepoFile } from "../../shared/workspace.js";
+export declare function getWorkspaceGit(repoPath: string): Promise<WorkspaceGitSnapshot>;
+export declare function commitWorkspaceGit(repoPath: string, rawMessage: string): Promise<void>;
+export declare function pushWorkspaceGit(repoPath: string): Promise<void>;
+export declare function checkoutWorkspaceGit(repoPath: string, rawBranch: string): Promise<void>;
+export declare function createWorkspaceGitBranch(repoPath: string, rawBranch: string): Promise<void>;
+export declare function discardWorkspaceGit(repoPath: string, rawPath?: string): Promise<void>;
+export declare function listWorkspaceDir(repoPath: string, rawPath: string): Promise<WorkspaceRepoEntry[]>;
+export declare function readWorkspaceFile(repoPath: string, rawPath: string): Promise<WorkspaceRepoFile>;
+export declare function searchWorkspaceFiles(repoPath: string, query: string): Promise<WorkspacePathMatch[]>;

package/dist/cli/src/workspace.js

@@ -0,0 +1,329 @@
+import { existsSync, promises as fs } from "fs";
+import { isAbsolute, relative, resolve } from "path";
+import { execCli } from "./proc.js";
+import { storedGithubCredentialEnv } from "./gitAuthEnv.js";
+import { assertCommitMessage, assertGitBranchName, assertGitChangePath, parseGitBranches, } from "../../shared/workspace.js";
+const MAX_GIT_DIFF_CHARS = 400_000;
+const MAX_REPO_FILE_BYTES = 512 * 1024;
+const MAX_REPO_IMAGE_BYTES = 3 * 1024 * 1024;
+const MAX_SEARCH_PATHS = 50_000;
+const EXCLUDED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    "target",
+    "__pycache__",
+    ".venv",
+    "venv",
+    "coverage",
+    ".turbo",
+    ".cache",
+]);
+const IMAGE_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    avif: "image/avif",
+    bmp: "image/bmp",
+};
+async function git(repoPath, args) {
+    try {
+        const { stdout } = await execCli("git", args, {
+            cwd: repoPath,
+            timeout: 30_000,
+            maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, ...storedGithubCredentialEnv() },
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        return e.stdout || "";
+    }
+}
+function resolveInside(repoPath, rawPath) {
+    const abs = isAbsolute(rawPath) ? rawPath : resolve(repoPath, rawPath || "");
+    const rel = relative(repoPath, abs);
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new Error("Path is outside the repo");
+    }
+    return { abs, rel: rel.replace(/\\/g, "/") };
+}
+export async function getWorkspaceGit(repoPath) {
+    if (!repoPath || !existsSync(repoPath))
+        throw new Error("Repository folder not found");
+    const [branchRaw, statusRaw, logRaw, aheadCount, branchList, diffRaw] = await Promise.all([
+        git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"]),
+        git(repoPath, ["status", "--porcelain"]),
+        git(repoPath, ["log", "-n", "25", "--pretty=format:%h%x09%s%x09%an%x09%cr"]),
+        git(repoPath, ["rev-list", "--count", "@{u}..HEAD"]),
+        git(repoPath, ["branch", "-a", "--format=%(refname:short)"]),
+        git(repoPath, ["diff", "HEAD"]),
+    ]);
+    const aheadRaw = aheadCount.trim();
+    const changes = statusRaw
+        .split("\n")
+        .filter((line) => line.trim())
+        .map((line) => ({ status: line.slice(0, 2).trim() || "?", path: line.slice(3) }));
+    const commits = logRaw
+        .split("\n")
+        .filter((line) => line.trim())
+        .map((line) => {
+        const [sha = "", subject = "", author = "", relativeTime = ""] = line.split("\t");
+        return { sha, subject, author, relativeTime };
+    });
+    const ahead = Number(aheadRaw);
+    return {
+        branch: branchRaw.trim() || null,
+        changes,
+        diff: diffRaw.slice(0, MAX_GIT_DIFF_CHARS),
+        diffTruncated: diffRaw.length > MAX_GIT_DIFF_CHARS,
+        commits,
+        ahead: Number.isFinite(ahead) ? ahead : null,
+        branches: parseGitBranches(branchList, branchRaw.trim() || null),
+    };
+}
+async function gitChecked(repoPath, args, timeout = 60_000) {
+    try {
+        const { stdout } = await execCli("git", args, {
+            cwd: repoPath,
+            timeout,
+            maxBuffer: 8 * 1024 * 1024,
+            env: { ...process.env, ...storedGithubCredentialEnv() },
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        throw new Error((e.stderr || e.message || "Git failed").trim().slice(0, 800));
+    }
+}
+async function githubCliIdentity() {
+    try {
+        const { stdout } = await execCli("gh", ["api", "user"], { timeout: 15_000 });
+        const user = JSON.parse(stdout);
+        const login = String(user.login || "").trim();
+        if (!login)
+            return null;
+        const email = typeof user.email === "string" && user.email.includes("@")
+            ? user.email.trim()
+            : `${user.id ? `${user.id}+` : ""}${login}@users.noreply.github.com`;
+        return { name: String(user.name || "").trim() || login, email };
+    }
+    catch {
+        return null;
+    }
+}
+/** Prefer the machine git identity, then the signed-in GitHub CLI user. */
+async function resolveCommitIdentity(repoPath) {
+    const name = (await git(repoPath, ["config", "--get", "user.name"])).trim();
+    const email = (await git(repoPath, ["config", "--get", "user.email"])).trim();
+    if (name && email)
+        return { name, email };
+    const gh = await githubCliIdentity();
+    if (gh)
+        return { name: name || gh.name, email: email || gh.email };
+    throw new Error("Set git user.name and user.email, or sign in with GitHub CLI (gh auth login)");
+}
+export async function commitWorkspaceGit(repoPath, rawMessage) {
+    const message = assertCommitMessage(rawMessage);
+    const author = await resolveCommitIdentity(repoPath);
+    await gitChecked(repoPath, ["add", "-A"]);
+    const status = await git(repoPath, ["status", "--porcelain"]);
+    if (!status.trim())
+        throw new Error("Nothing to commit");
+    await gitChecked(repoPath, [
+        "-c",
+        `user.name=${author.name}`,
+        "-c",
+        `user.email=${author.email}`,
+        "commit",
+        "-m",
+        message,
+    ]);
+}
+export async function pushWorkspaceGit(repoPath) {
+    const branch = (await git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    if (!branch || branch === "HEAD")
+        throw new Error("Checkout a branch before pushing");
+    await gitChecked(repoPath, ["fetch", "origin"], 180_000).catch(() => undefined);
+    await gitChecked(repoPath, ["push", "-u", "origin", "HEAD"], 180_000);
+}
+export async function checkoutWorkspaceGit(repoPath, rawBranch) {
+    const branch = assertGitBranchName(rawBranch);
+    const known = parseGitBranches(await git(repoPath, ["branch", "-a", "--format=%(refname:short)"]), null);
+    if (!known.includes(branch))
+        throw new Error("That branch is not in this repository");
+    if ((await git(repoPath, ["status", "--porcelain"])).trim()) {
+        throw new Error("Commit or discard changes before switching branches");
+    }
+    try {
+        await gitChecked(repoPath, ["checkout", branch]);
+    }
+    catch {
+        await gitChecked(repoPath, ["checkout", "-B", branch, `origin/${branch}`]);
+    }
+}
+export async function createWorkspaceGitBranch(repoPath, rawBranch) {
+    const branch = assertGitBranchName(rawBranch);
+    const current = (await git(repoPath, ["rev-parse", "--abbrev-ref", "HEAD"])).trim();
+    if (current === branch)
+        return;
+    const known = parseGitBranches(await git(repoPath, ["branch", "-a", "--format=%(refname:short)"]), current);
+    if (known.includes(branch))
+        throw new Error("That branch already exists");
+    await gitChecked(repoPath, ["checkout", "-b", branch]);
+}
+export async function discardWorkspaceGit(repoPath, rawPath = "") {
+    const path = assertGitChangePath(rawPath);
+    if (!path) {
+        await gitChecked(repoPath, ["reset", "--hard", "HEAD"]);
+        await gitChecked(repoPath, ["clean", "-fd"]);
+        return;
+    }
+    const tracked = await git(repoPath, ["ls-files", "--error-unmatch", "--", path]);
+    if (tracked.trim()) {
+        await gitChecked(repoPath, ["restore", "--source=HEAD", "--staged", "--worktree", "--", path]).catch(async () => {
+            await gitChecked(repoPath, ["checkout", "HEAD", "--", path]);
+        });
+        return;
+    }
+    const { abs } = resolveInside(repoPath, path);
+    await fs.rm(abs, { recursive: true, force: true });
+}
+export async function listWorkspaceDir(repoPath, rawPath) {
+    const { abs, rel } = resolveInside(repoPath, rawPath);
+    let dir;
+    try {
+        dir = await fs.readdir(abs, { withFileTypes: true });
+    }
+    catch {
+        throw new Error("Folder not found");
+    }
+    const entries = await Promise.all(dir
+        .filter((entry) => entry.name !== ".git")
+        .map(async (entry) => {
+        if (entry.isSymbolicLink())
+            return null;
+        const entryPath = rel ? `${rel}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            return { name: entry.name, path: entryPath, type: "dir" };
+        }
+        if (!entry.isFile())
+            return null;
+        let sizeBytes = 0;
+        try {
+            sizeBytes = (await fs.stat(resolve(abs, entry.name))).size;
+        }
+        catch {
+            // keep 0
+        }
+        return { name: entry.name, path: entryPath, type: "file", sizeBytes };
+    }));
+    return entries
+        .filter((entry) => Boolean(entry))
+        .sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name) : a.type === "dir" ? -1 : 1));
+}
+export async function readWorkspaceFile(repoPath, rawPath) {
+    if (!rawPath)
+        throw new Error("Invalid path");
+    const { abs, rel } = resolveInside(repoPath, rawPath);
+    let stat;
+    try {
+        stat = await fs.stat(abs);
+    }
+    catch {
+        throw new Error("File not found");
+    }
+    if (!stat.isFile())
+        throw new Error("Not a file");
+    const ext = abs.slice(abs.lastIndexOf(".") + 1).toLowerCase();
+    const imageMime = abs.includes(".") ? IMAGE_MIME[ext] : undefined;
+    const cap = imageMime ? MAX_REPO_IMAGE_BYTES : MAX_REPO_FILE_BYTES;
+    const handle = await fs.open(abs, "r");
+    try {
+        const length = Math.min(stat.size, cap);
+        const bytes = Buffer.alloc(length);
+        if (length)
+            await handle.read(bytes, 0, length, 0);
+        const truncated = stat.size > length;
+        if (imageMime) {
+            return {
+                path: rel,
+                sizeBytes: stat.size,
+                content: null,
+                binary: true,
+                truncated,
+                imageDataUrl: truncated ? undefined : `data:${imageMime};base64,${bytes.toString("base64")}`,
+            };
+        }
+        const binary = bytes.subarray(0, 8192).includes(0);
+        return {
+            path: rel,
+            sizeBytes: stat.size,
+            content: binary ? null : bytes.toString("utf8"),
+            binary,
+            truncated,
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+function searchScore(path, query) {
+    const lower = path.toLowerCase();
+    const base = lower.slice(lower.lastIndexOf("/") + 1);
+    if (base === query)
+        return 1000;
+    if (base.startsWith(query))
+        return 800;
+    if (base.includes(query))
+        return 600;
+    if (lower.includes(query))
+        return 400;
+    let last = -1;
+    let score = 0;
+    for (const ch of query) {
+        const at = lower.indexOf(ch, last + 1);
+        if (at < 0)
+            return null;
+        score += at === last + 1 ? 3 : 1;
+        last = at;
+    }
+    return 200 + score;
+}
+export async function searchWorkspaceFiles(repoPath, query) {
+    const q = query.trim().toLowerCase().slice(0, 200);
+    if (!q)
+        return [];
+    const tracked = await git(repoPath, ["ls-files", "-co", "--exclude-standard"]);
+    const paths = new Set();
+    for (const raw of tracked.split("\n")) {
+        const path = raw.trim();
+        if (!path)
+            continue;
+        const parts = path.split("/");
+        if (parts.some((part) => EXCLUDED_DIRS.has(part)))
+            continue;
+        for (let i = 1; i < parts.length; i += 1) {
+            paths.add(`${parts.slice(0, i).join("/")}/`);
+        }
+        paths.add(path);
+        if (paths.size >= MAX_SEARCH_PATHS)
+            break;
+    }
+    return [...paths]
+        .map((path) => ({ path, score: searchScore(path, q) }))
+        .filter((item) => item.score !== null)
+        .sort((a, b) => b.score - a.score || a.path.localeCompare(b.path))
+        .slice(0, 60)
+        .map(({ path }) => ({
+        path: path.replace(/\/+$/, ""),
+        type: path.endsWith("/") ? "dir" : "file",
+    }));
+}

package/dist/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/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/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/cursorAuth.js

@@ -0,0 +1,95 @@
+import { spawn, execFile } from "child_process";
+import { promisify } from "util";
+import chalk from "chalk";
+import ora from "ora";
+const execFileAsync = promisify(execFile);
+export async function getCursorAuth() {
+    try {
+        const { stdout } = await execFileAsync("cursor", ["agent", "whoami", "--format", "json"], {
+            timeout: 30_000,
+            encoding: "utf8",
+            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 = spawn("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/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { createInterface } from "readline";
+import { loginWithPairingCode, logout } from "./auth.js";
+import { DEFAULT_SERVER_URL, loadConfig } from "./config.js";
+import { ensureCursorAuth } from "./cursorAuth.js";
+import { startWorker } from "./worker.js";
+const program = new Command();
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+program
+    .name("steer")
+    .description("CLI worker for Steer — run local Cursor agents")
+    .version("0.2.0");
+program
+    .command("login")
+    .description("Pair CLI with your Steer account (Clerk via web pairing code)")
+    .action(async () => {
+    try {
+        console.log(chalk.gray("\n  1. Sign in on the web app\n  2. Open /cli-pair and generate a code\n  3. Enter that code below\n"));
+        const serverUrlRaw = await prompt(`Server URL [${DEFAULT_SERVER_URL}]: `);
+        const serverUrl = serverUrlRaw || DEFAULT_SERVER_URL;
+        const code = await prompt("Pairing code: ");
+        if (!code) {
+            console.error(chalk.red("Pairing code is required."));
+            process.exit(1);
+        }
+        const spinner = ora("Pairing…").start();
+        try {
+            const config = await loginWithPairingCode(serverUrl, code);
+            spinner.succeed(`Paired as ${chalk.cyan(config.email)}`);
+        }
+        catch (err) {
+            spinner.fail(err.message);
+            process.exit(1);
+        }
+    }
+    catch {
+        process.exit(1);
+    }
+});
+program
+    .command("logout")
+    .description("Clear stored credentials")
+    .action(() => {
+    logout();
+    console.log(chalk.green("Logged out."));
+});
+program
+    .command("status")
+    .description("Show connection status and logged-in user")
+    .action(async () => {
+    const config = loadConfig();
+    if (!config) {
+        console.log(chalk.yellow("Not logged in."));
+        return;
+    }
+    console.log(chalk.blue("Logged in as:"), chalk.cyan(config.email));
+    console.log(chalk.blue("Server:"), config.serverUrl);
+    const spinner = ora("Checking server…").start();
+    try {
+        const res = await fetch(`${config.serverUrl}/api/rooms`, {
+            headers: { Authorization: `Bearer ${config.token}` },
+        });
+        if (!res.ok) {
+            spinner.fail(`Server returned ${res.status}`);
+            return;
+        }
+        const rooms = (await res.json());
+        spinner.succeed(`Server online — ${rooms.length} room(s)`);
+        for (const room of rooms) {
+            console.log(chalk.gray(`  • ${room.name || room.id}`));
+        }
+    }
+    catch (err) {
+        spinner.fail(`Cannot reach server: ${err.message}`);
+    }
+});
+program
+    .command("start")
+    .description("Start the worker daemon")
+    .option("--repo <path>", "Override repository path for all prompts")
+    .action(async (opts) => {
+    const config = loadConfig();
+    if (!config) {
+        console.error(chalk.red("Not logged in. Run `steer login` first."));
+        process.exit(1);
+    }
+    // Require Cursor CLI login before accepting Local prompts
+    await ensureCursorAuth();
+    console.log(chalk.blue.bold("\n  Steer Worker\n"));
+    console.log(chalk.gray(`  Server: ${config.serverUrl}`));
+    console.log(chalk.gray(`  User:   ${config.email}`));
+    if (opts.repo)
+        console.log(chalk.gray(`  Repo:   ${opts.repo}`));
+    console.log();
+    startWorker(opts.repo);
+});
+program.parse();

package/dist/listModels.d.ts

@@ -0,0 +1,6 @@
+export interface ModelInfo {
+    id: string;
+    displayName: string;
+}
+/** Models available to the logged-in Cursor CLI on this machine. */
+export declare function listLocalModels(): Promise<ModelInfo[]>;