@oblivihon/steer 0.1.0

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): Promise<void>;
+export declare function getFileDiff(repoPath: string, filePath: string): Promise<string>;

package/dist/agent.js

@@ -0,0 +1,243 @@
+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) {
+    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);
+        }
+        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,4 @@
+import { type Config } from "./config.js";
+export declare function login(serverUrl: string, email: string, password: string): Promise<Config>;
+export declare function logout(): void;
+export declare function getAuthHeaders(): Record<string, string>;

package/dist/auth.js

@@ -0,0 +1,34 @@
+import { loadConfig, saveConfig, clearConfig } from "./config.js";
+export async function login(serverUrl, email, password) {
+    const url = `${serverUrl.replace(/\/+$/, "")}/api/auth/login`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Login failed (${res.status}): ${body}`);
+    }
+    const data = (await res.json());
+    if (!data.token) {
+        throw new Error("Server did not return a token");
+    }
+    const config = {
+        serverUrl: serverUrl.replace(/\/+$/, ""),
+        token: data.token,
+        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/config.d.ts

@@ -0,0 +1,9 @@
+export interface Config {
+    serverUrl: string;
+    token: string;
+    email: 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,48 @@
+import { mkdirSync, readFileSync, writeFileSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+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,138 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import ora from "ora";
+import { createInterface } from "readline";
+import { login, logout } from "./auth.js";
+import { 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());
+        });
+    });
+}
+function promptSecret(question) {
+    return new Promise((resolve) => {
+        process.stdout.write(question);
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (stdin.isTTY)
+            stdin.setRawMode(true);
+        let input = "";
+        const onData = (ch) => {
+            const c = ch.toString();
+            if (c === "\n" || c === "\r") {
+                stdin.removeListener("data", onData);
+                if (stdin.isTTY)
+                    stdin.setRawMode(wasRaw ?? false);
+                process.stdout.write("\n");
+                resolve(input);
+            }
+            else if (c === "\u0003") {
+                process.exit(1);
+            }
+            else if (c === "\u007F" || c === "\b") {
+                input = input.slice(0, -1);
+            }
+            else {
+                input += c;
+            }
+        };
+        stdin.resume();
+        stdin.on("data", onData);
+    });
+}
+program
+    .name("steer")
+    .description("CLI worker for Steer — run local Cursor agents")
+    .version("0.1.0");
+program
+    .command("login")
+    .description("Log in to the Steer server")
+    .action(async () => {
+    try {
+        const serverUrl = await prompt("Server URL: ");
+        const email = await prompt("Email: ");
+        const password = await promptSecret("Password: ");
+        if (!serverUrl || !email || !password) {
+            console.error(chalk.red("All fields are required."));
+            process.exit(1);
+        }
+        const spinner = ora("Logging in…").start();
+        try {
+            const config = await login(serverUrl, email, password);
+            spinner.succeed(`Logged in 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/worker.d.ts

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

package/dist/worker.js

@@ -0,0 +1,113 @@
+import { io } from "socket.io-client";
+import { hostname } from "os";
+import { createHash } from "crypto";
+import chalk from "chalk";
+import { loadConfig } from "./config.js";
+import { runAgent, abortAgent, isEditTool, getFileDiff, } from "./agent.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}`));
+    const socket = io(`${serverUrl}/worker`, {
+        auth: { token: config.token },
+        reconnection: true,
+        reconnectionAttempts: Infinity,
+        reconnectionDelay: 2000,
+        reconnectionDelayMax: 30000,
+        transports: ["websocket", "polling"],
+    });
+    socket.on("connect", () => {
+        console.log(chalk.green("✓ Connected to server"));
+        socket.emit("worker:ready", { workerId });
+    });
+    socket.on("disconnect", (reason) => {
+        console.log(chalk.yellow(`Disconnected: ${reason}`));
+    });
+    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 } = payload;
+        const repoPath = repoPathOverride || payloadRepoPath;
+        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 = "";
+        const onEvent = (event) => {
+            socket.emit("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"));
+            }
+        };
+        runAgent(repoPath, prompt, modelId, onEvent)
+            .then(async () => {
+            for (const filePath of editedPaths) {
+                try {
+                    const patch = await getFileDiff(repoPath, filePath);
+                    if (patch) {
+                        socket.emit("worker:file-diff", {
+                            roomId,
+                            msgId: lastMsgId,
+                            toolName: "edit",
+                            path: filePath,
+                            patch,
+                        });
+                    }
+                }
+                catch {
+                    // diff failures are non-fatal
+                }
+            }
+        })
+            .catch((err) => {
+            console.error(chalk.red(`Agent error: ${err.message}`));
+            socket.emit("worker:agent-event", {
+                roomId,
+                event: { kind: "error", message: err.message },
+            });
+        });
+    });
+    socket.on("worker:abort", (_payload) => {
+        console.log(chalk.yellow("  ⚠ Abort requested"));
+        abortAgent();
+    });
+    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

@@ -0,0 +1,42 @@
+{
+  "name": "@oblivihon/steer",
+  "version": "0.1.0",
+  "description": "CLI worker for Steer — run local Cursor agents for multiplayer sessions",
+  "type": "module",
+  "bin": {
+    "steer": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "cursor",
+    "agent",
+    "cli",
+    "steer",
+    "multiplayer"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "socket.io-client": "^4.8.0",
+    "chalk": "^5.4.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  }
+}