howtofixcli 0.7.13 → 0.7.14

package/dist/acp.js

@@ -0,0 +1,234 @@
+/**
+ * `howtofix acp`: the Agent Client Protocol over stdio.
+ *
+ * ACP is how an editor (Zed and others) or any other host drives a coding agent:
+ * JSON-RPC 2.0, one message per line, the host as client and this process as the
+ * agent. Speaking it means the CLI plugs into those hosts without each one
+ * needing its own adapter — and it is also the seam the hosted Roblox workspace
+ * uses to steer a local session.
+ *
+ * What is implemented is the part a host needs to hold a conversation:
+ * `initialize`, `session/new`, `session/prompt` (with streamed `session/update`
+ * notifications for text, thinking and tool calls) and `session/cancel`. Anything
+ * else is answered `-32601` rather than ignored, so a host finds out a capability
+ * is missing instead of waiting on a reply that never comes.
+ *
+ * ## Per-turn context
+ *
+ * A host can attach `_meta.howtofix.context` to a prompt: the Studio place, the
+ * selection, what is connected. It is rendered into a `<session_context>` block
+ * ahead of the user's words *each turn*, not once at session start, because the
+ * selection the user had when they typed is the one that matters, and a context
+ * frozen at `session/new` would describe a place that has since changed.
+ *
+ * The agent is reached through `AcpAgent` so this file does not import the SDK:
+ * the protocol layer is testable with a fake, and `main.ts` supplies the real one.
+ */
+import { createInterface } from "node:readline";
+export const ACP_PROTOCOL_VERSION = 1;
+/**
+ * Render per-turn context as text the model reads before the prompt.
+ *
+ * Returns an empty string for no context, so a plain prompt is passed through
+ * untouched. Values are JSON-encoded rather than interpolated: a place named
+ * `</session_context>` must not be able to close the block and speak as the user.
+ */
+export function renderSessionContext(context) {
+    if (!context || Object.keys(context).length === 0)
+        return "";
+    // JSON quoting alone does not stop `</session_context>` inside a string from
+    // reading as the closing tag, so `<` is escaped too. `\u003c` is still valid
+    // JSON and decodes to the same text; it just cannot be mistaken for markup.
+    const encode = (value) => JSON.stringify(value).replace(/</g, "\\u003c");
+    const lines = [];
+    if (context.place)
+        lines.push(`place: ${encode(context.place)}`);
+    if (context.selection && context.selection.length > 0)
+        lines.push(`selection: ${encode(context.selection)}`);
+    if (context.connected)
+        lines.push(`connected: ${encode(context.connected)}`);
+    for (const [key, value] of Object.entries(context)) {
+        if (key === "place" || key === "selection" || key === "connected")
+            continue;
+        lines.push(`${key.replace(/[^\w.-]/g, "_")}: ${encode(value)}`);
+    }
+    return `<session_context>\n${lines.join("\n")}\n</session_context>\n\n`;
+}
+/** A tool's kind for the host's icon, from its name. */
+function toolKind(name) {
+    if (/^(get_|list_|read_|snapshot|diff_|audit|datastore_get|datastore_list|roblox_status)/.test(name))
+        return "read";
+    if (/^(search|grep|find)/.test(name))
+        return "search";
+    if (/(execute|run_|luau)/.test(name))
+        return "execute";
+    if (/^(set_|create_|delete_|clone_|reparent_|edit_|insert_|send_|publish_|upload_|generate_|datastore_set|datastore_delete)/.test(name))
+        return "edit";
+    return "other";
+}
+function resultText(result) {
+    if (typeof result === "string")
+        return result;
+    const content = result?.content;
+    if (Array.isArray(content))
+        return content.map((block) => (block.type === "text" ? (block.text ?? "") : `[${block.type ?? "?"}]`)).join("\n");
+    return JSON.stringify(result ?? null);
+}
+/** Run the protocol until the input closes. Resolves when it has. */
+export function runAcp(options) {
+    const sessions = new Map();
+    const running = new Map();
+    let counter = 0;
+    const write = (message) => {
+        options.output.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}\n`);
+    };
+    const reply = (id, result) => write({ id, result });
+    const fail = (id, code, message) => write({ id, error: { code, message } });
+    const update = (sessionId, body) => write({ method: "session/update", params: { sessionId, update: body } });
+    async function handle(request) {
+        const params = request.params ?? {};
+        const isNotification = request.id === undefined;
+        switch (request.method) {
+            case "initialize":
+                return reply(request.id, {
+                    protocolVersion: ACP_PROTOCOL_VERSION,
+                    agentCapabilities: { loadSession: false, promptCapabilities: { image: false, audio: false, embeddedContext: true } },
+                    authMethods: [],
+                    agentInfo: { name: options.name ?? "howtofix", title: "HowToFix", version: options.version },
+                });
+            case "session/new": {
+                const cwd = typeof params.cwd === "string" ? params.cwd : process.cwd();
+                try {
+                    const agent = await options.createAgent(cwd);
+                    counter += 1;
+                    const sessionId = `sess_${Date.now().toString(36)}_${counter}`;
+                    sessions.set(sessionId, agent);
+                    return reply(request.id, { sessionId });
+                }
+                catch (error) {
+                    return fail(request.id, -32000, error instanceof Error ? error.message : String(error));
+                }
+            }
+            case "session/prompt": {
+                const sessionId = String(params.sessionId ?? "");
+                const agent = sessions.get(sessionId);
+                if (!agent)
+                    return fail(request.id, -32602, `unknown session ${sessionId}`);
+                if (running.has(sessionId))
+                    return fail(request.id, -32000, "a prompt is already running in this session");
+                const blocks = Array.isArray(params.prompt) ? params.prompt : [];
+                const text = blocks
+                    .map((block) => {
+                    if (block.type === "text")
+                        return block.text ?? "";
+                    if (block.type === "resource" && block.resource?.text !== undefined)
+                        return `<file uri=${JSON.stringify(block.resource.uri ?? "")}>\n${block.resource.text}\n</file>`;
+                    return "";
+                })
+                    .filter((part) => part !== "")
+                    .join("\n\n");
+                if (text === "")
+                    return fail(request.id, -32602, "the prompt has no text");
+                const meta = params._meta;
+                const full = renderSessionContext(meta?.howtofix?.context) + text;
+                let cancelled = false;
+                const unsubscribe = agent.subscribe((event) => {
+                    if (event.type === "message_update") {
+                        const inner = event.assistantMessageEvent;
+                        if (inner?.type === "text_delta" && inner.delta) {
+                            update(sessionId, { sessionUpdate: "agent_message_chunk", content: { type: "text", text: inner.delta } });
+                        }
+                        else if (inner?.type === "thinking_delta" && inner.delta) {
+                            update(sessionId, { sessionUpdate: "agent_thought_chunk", content: { type: "text", text: inner.delta } });
+                        }
+                    }
+                    else if (event.type === "tool_execution_start") {
+                        const e = event;
+                        update(sessionId, {
+                            sessionUpdate: "tool_call",
+                            toolCallId: e.toolCallId,
+                            title: e.toolName,
+                            kind: toolKind(e.toolName),
+                            status: "in_progress",
+                            rawInput: e.args ?? {},
+                        });
+                    }
+                    else if (event.type === "tool_execution_end") {
+                        const e = event;
+                        update(sessionId, {
+                            sessionUpdate: "tool_call_update",
+                            toolCallId: e.toolCallId,
+                            status: e.isError ? "failed" : "completed",
+                            content: [{ type: "content", content: { type: "text", text: resultText(e.result) } }],
+                        });
+                    }
+                });
+                const turn = agent
+                    .prompt(full)
+                    .then(() => {
+                    const stop = agent.lastStopReason?.();
+                    const stopReason = cancelled || stop === "aborted" ? "cancelled" : stop === "length" ? "max_tokens" : "end_turn";
+                    reply(request.id, { stopReason });
+                })
+                    .catch((error) => {
+                    if (cancelled)
+                        reply(request.id, { stopReason: "cancelled" });
+                    else
+                        fail(request.id, -32000, error instanceof Error ? error.message : String(error));
+                })
+                    .finally(() => {
+                    unsubscribe();
+                    running.delete(sessionId);
+                });
+                running.set(sessionId, turn);
+                // `cancel` needs to reach this turn's flag, so it is looked up by session.
+                cancels.set(sessionId, () => {
+                    cancelled = true;
+                });
+                return;
+            }
+            case "session/cancel": {
+                const sessionId = String(params.sessionId ?? "");
+                cancels.get(sessionId)?.();
+                await sessions.get(sessionId)?.abort();
+                return;
+            }
+            default:
+                // A notification has no reply to carry an error, so it is dropped.
+                if (!isNotification)
+                    fail(request.id, -32601, `method not found: ${request.method}`);
+        }
+    }
+    const cancels = new Map();
+    return new Promise((resolve) => {
+        const lines = createInterface({ input: options.input });
+        const pending = new Set();
+        lines.on("line", (line) => {
+            if (line.trim() === "")
+                return;
+            let request;
+            try {
+                request = JSON.parse(line);
+            }
+            catch {
+                fail(null, -32700, "parse error");
+                return;
+            }
+            const task = handle(request)
+                .catch((error) => {
+                if (request.id !== undefined)
+                    fail(request.id, -32603, error instanceof Error ? error.message : String(error));
+            })
+                .finally(() => pending.delete(task));
+            pending.add(task);
+        });
+        lines.on("close", () => {
+            // Let in-flight turns finish writing before sessions are torn down: closing
+            // stdin after sending a prompt is how a one-shot host says "and then stop".
+            void Promise.allSettled([...pending, ...running.values()]).then(async () => {
+                await Promise.allSettled([...sessions.values()].map((agent) => agent.dispose()));
+                resolve();
+            });
+        });
+    });
+}

package/dist/args.js

@@ -1,4 +1,5 @@
 import { APP_TITLE, APP_VERSION } from "./brand.js";
+const SERVER_MODES = { rpc: true, acp: true };
 const THINKING = { off: true, minimal: true, low: true, medium: true, high: true, xhigh: true, max: true };
 const APPROVAL = { suggest: true, "auto-edit": true, "full-auto": true };
 /**
@@ -84,6 +85,15 @@ export function parseArgs(argv) {
         else if (token === "--max-budget-usd" || token.startsWith("--max-budget-usd=")) {
             args.maxBudgetUsd = parseBudget(takeValue(tokens, i, "--max-budget-usd"));
         }
+        else if (token === "--mode" || token.startsWith("--mode=")) {
+            const mode = takeValue(tokens, i, "--mode");
+            if (!SERVER_MODES[mode])
+                throw new Error(`--mode must be one of: ${Object.keys(SERVER_MODES).join(", ")}`);
+            args.mode = mode;
+        }
+        else if (token === "--acp") {
+            args.mode = "acp";
+        }
         else if (token === "--dangerously-skip-permissions") {
             args.dangerouslySkipPermissions = true;
         }
@@ -135,6 +145,12 @@ export function parseArgs(argv) {
     if (args.print && (args.continueSession || args.sessionPath)) {
         throw new Error("--print runs one prompt in a throwaway session; it cannot be combined with --continue or --session");
     }
+    if (args.mode && (args.print || args.prompt)) {
+        throw new Error(`--mode ${args.mode} is a protocol server: prompts arrive over the protocol, not the command line`);
+    }
+    if (args.mode && (args.continueSession || args.sessionPath)) {
+        throw new Error(`--mode ${args.mode} opens its own sessions; it cannot be combined with --continue or --session`);
+    }
     if (args.sessionPath && !args.sessionPath.endsWith(".jsonl")) {
         throw new Error(`--session expects a session file, got '${args.sessionPath}'`);
     }
@@ -147,6 +163,8 @@ coding agent. layout is a workbench, not a chat log.
 usage:
   howtofix [options] [prompt]
   howtofix -p "explain this repo"
+  howtofix acp                       serve the Agent Client Protocol on stdio
+  howtofix --mode rpc                serve JSON-line commands on stdio
   howtofix preset new|check|pack     author a preset
   howtofix doctor|models|sessions    inspect the installation
   howtofix sessions --search <text> find a session by what was said in it
@@ -165,6 +183,8 @@ options:
                        text for a person; json writes the final result only;
                        stream-json writes every event as it happens
       --max-budget-usd <n> stop the run once it has spent n dollars
+      --mode <m>       rpc | acp: serve a protocol on stdin/stdout, no terminal
+      --acp            same as --mode acp
       --sandbox        run the whole session inside a filesystem sandbox:
                        the project is writable, the rest is read-only.
                        needs bubblewrap (Linux) or sandbox-exec (macOS)
@@ -198,6 +218,8 @@ commands:
   /dcp /context /decompress /sweep
   /update /usage /sync
   /skills /preset /settings /proxy /roblox
+/roblox login|logout|status|tunnel manages the Roblox connection: sign in with Roblox
+(no API key), see what is connected, and link this machine to the hosted workspace.
 
 /stats shows session tokens, cost, and the prompt-cache hit rate; a high read
 total alone hides re-billed context, so the rate is what tells you the truth.

package/dist/brand.js

@@ -1,5 +1,5 @@
 export const APP_TITLE = "HowToFix";
-export const APP_VERSION = "0.7.13";
+export const APP_VERSION = "0.7.14";
 export const SYSTEM_APPEND = [
     // House style: RFC 2119 keywords in caps, one claim per line, the
     // highest-stakes rules at

package/dist/main.js

@@ -121,9 +121,12 @@ async function main() {
     // Arguments are read and checked before the start-up repairs. A typo must not
     // rewrite settings.json, print a hint about a file the user never mentioned,
     // or reach the network: the answer to "you forgot the prompt" is one line.
+    // `howtofix acp` is the subcommand spelling of `--acp`, dispatched here rather
+    // than in `parseArgs` so the word is not mistaken for the start of a prompt.
+    const argvForParse = subArgv[0] === "acp" ? ["--acp", ...subArgv.slice(1)] : subArgv;
     let earlyArgs;
     try {
-        earlyArgs = parseArgs(process.argv.slice(2));
+        earlyArgs = parseArgs(argvForParse);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -300,6 +303,14 @@ async function main() {
             `fork bombs, host shutdown) and the repeated-call guard are NOT enforced for this run. ` +
             `Turn it off with /settings, or by removing skipPermissions from settings.json.`);
     }
+    // A protocol server owns stdin and stdout from here on. It opens its own
+    // sessions (ACP opens one per `session/new`), so it returns before the one
+    // below is created.
+    if (args.mode) {
+        const { serveProtocol } = await import("./serve.js");
+        await serveProtocol(args.mode, { cwd, model: args.model, thinking: args.thinking });
+        return;
+    }
     const open = (options) => openSession({
         cwd,
         model: args.model,

package/dist/roblox-connect.js

@@ -0,0 +1,125 @@
+/**
+ * `/roblox login | logout | status | tunnel` — the CLI's side of the Roblox
+ * connection.
+ *
+ * The bridge (`@netrodev/howtofix-roblox-bridge`) runs beside the agent and owns
+ * the Roblox sign-in, the virtual place and the tunnel. This module is a thin
+ * client for its loopback REST surface: it finds the bridge through the state file
+ * the bridge writes, asks it to do the thing, and reports what happened. Nothing
+ * Roblox-specific lives here, so the CLI stays small and the logic stays where the
+ * tests are.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { openInBrowser } from "./browser.js";
+/** Where the bridge recorded its port and token, or undefined when none runs. */
+export function readBridgeEndpoint(stateDir) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(stateDir, "roblox-bridge.json"), "utf8"));
+        if (typeof parsed.port === "number" && typeof parsed.token === "string")
+            return { port: parsed.port, token: parsed.token };
+    }
+    catch {
+        /* no bridge has started here */
+    }
+    return undefined;
+}
+const NO_BRIDGE = "the Roblox bridge is not running. Install RoToolbox with /preset, restart, and it starts with the agent.";
+export class RobloxConnect {
+    endpoint;
+    fetcher;
+    open;
+    constructor(endpoint, fetcher = fetch, open = (url) => openInBrowser(url)) {
+        this.endpoint = endpoint;
+        this.fetcher = fetcher;
+        this.open = open;
+    }
+    base() {
+        if (!this.endpoint)
+            throw new Error(NO_BRIDGE);
+        return `http://127.0.0.1:${this.endpoint.port}`;
+    }
+    async get(path) {
+        const response = await this.fetcher(`${this.base()}${path}`);
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            throw new Error(body.error ?? `the bridge answered ${response.status}`);
+        return body;
+    }
+    async status() {
+        return this.get("/roblox/status");
+    }
+    /**
+     * Open Roblox's consent page and wait until the bridge reports a sign-in.
+     *
+     * The URL is always returned too: a machine with no browser (SSH, a container)
+     * cannot open it, and the person has to be able to paste it somewhere that can.
+     */
+    async login(options = {}) {
+        const status = await this.status();
+        if (!status.oauth.configured) {
+            throw new Error("no Roblox OAuth app is configured. Set HOWTOFIX_ROBLOX_CLIENT_ID (or use ROBLOX_API_KEY for an API key).");
+        }
+        const { url } = await this.get("/oauth/start");
+        options.onUrl?.(url);
+        const opened = await this.open(url);
+        const deadline = Date.now() + (options.timeoutMs ?? 5 * 60_000);
+        while (Date.now() < deadline) {
+            await new Promise((resolve) => setTimeout(resolve, options.pollMs ?? 1000));
+            const now = await this.status();
+            if (now.oauth.signedIn) {
+                return { ok: true, message: `signed in${now.oauth.userName ? ` as ${now.oauth.userName}` : ""}`, url };
+            }
+        }
+        return {
+            ok: false,
+            message: opened ? "timed out waiting for the Roblox consent screen" : "could not open a browser; open the URL yourself, then run /roblox status",
+            url,
+        };
+    }
+    async logout() {
+        if (!this.endpoint)
+            throw new Error(NO_BRIDGE);
+        await this.get(`/oauth/logout?token=${encodeURIComponent(this.endpoint.token)}`);
+    }
+    async tunnel(action) {
+        if (!this.endpoint)
+            throw new Error(NO_BRIDGE);
+        const response = await this.fetcher(`${this.base()}/tunnel`, {
+            method: "POST",
+            headers: { "content-type": "application/json", "x-howtofix-token": this.endpoint.token },
+            body: JSON.stringify({ action }),
+        });
+        const body = (await response.json().catch(() => ({})));
+        if (!response.ok)
+            throw new Error(body.error ?? `the bridge answered ${response.status}`);
+        return body;
+    }
+}
+/** The sentence(s) `/roblox status` shows. */
+export function describeStatus(status, tunnel) {
+    const lines = [];
+    if (status.oauth.signedIn) {
+        lines.push(`Roblox: signed in${status.oauth.userName ? ` as ${status.oauth.userName}` : ""}`);
+        lines.push(status.oauth.universeIds.length > 0
+            ? `experiences: ${status.oauth.universeIds.join(", ")}`
+            : "experiences: none granted yet (sign in again and tick one)");
+    }
+    else if (status.openCloud) {
+        lines.push("Roblox: using an API key (ROBLOX_API_KEY)");
+    }
+    else {
+        lines.push(`Roblox: not signed in${status.oauth.configured ? " — run /roblox login" : " — set HOWTOFIX_ROBLOX_CLIENT_ID to enable sign-in"}`);
+    }
+    lines.push(`virtual places: ${status.places.join(", ") || "none"} (answer tools when Studio is closed)`);
+    if (tunnel)
+        lines.push(`workspace tunnel: ${tunnel.open ? "connected" : tunnel.running ? "connecting" : "off"}`);
+    return lines.join("\n");
+}
+/** Parse `/roblox <sub> [args]`; undefined means the legacy RoToolbox status. */
+export function parseRobloxSubcommand(arg) {
+    const [first = "", ...rest] = arg.trim().split(/\s+/);
+    if (first === "login" || first === "logout" || first === "status" || first === "tunnel")
+        return { sub: first, rest: rest.join(" ") };
+    return undefined;
+}

package/dist/rpc.js

@@ -0,0 +1,91 @@
+/**
+ * `howtofix --mode rpc`: drive a session from another process, one JSON object
+ * per line.
+ *
+ * The same contract the harness's own RPC mode speaks for the commands that make
+ * a session useful from outside — `prompt`, `abort`, `get_state`,
+ * `get_last_assistant_text` — with every session event streamed on stdout in the
+ * `--output-format stream-json` shape. A host that already parses that stream
+ * needs nothing new, and a host that wants a conversation gets one without a
+ * terminal.
+ *
+ * The CLI opens sessions through `createAgentSession`, which the harness's
+ * `runRpcMode` does not accept (it wants a full runtime host with session
+ * switching and forking). Rather than rebuild the CLI around a different
+ * constructor, this drives the session the CLI already has, so every extension it
+ * loads — MCP, code mode, the Roblox bridge — is present in RPC mode too.
+ *
+ * stdout carries only protocol lines. Anything a person should read goes to
+ * stderr, because one stray line would corrupt the stream for the host.
+ */
+import { createInterface } from "node:readline";
+/** Run until the input closes. Resolves when in-flight work has finished. */
+export function runRpc(options) {
+    const { agent } = options;
+    const write = (message) => options.output.write(`${JSON.stringify(message)}\n`);
+    const respond = (id, command, success, extra = {}) => write({ ...(id !== undefined ? { id } : {}), type: "response", command, success, ...extra });
+    const unsubscribe = agent.subscribe((event) => {
+        const encoded = options.encodeEvent ? options.encodeEvent(event) : `${JSON.stringify(event)}\n`;
+        if (encoded !== undefined)
+            options.output.write(encoded);
+    });
+    let running = null;
+    return new Promise((resolve) => {
+        const lines = createInterface({ input: options.input });
+        lines.on("line", (line) => {
+            if (line.trim() === "")
+                return;
+            let command;
+            try {
+                command = JSON.parse(line);
+            }
+            catch {
+                respond(undefined, "parse", false, { error: "a command must be one JSON object per line" });
+                return;
+            }
+            const { id, type } = command;
+            if (type === "prompt") {
+                if (typeof command.message !== "string" || command.message.trim() === "") {
+                    respond(id, "prompt", false, { error: "prompt needs a message" });
+                    return;
+                }
+                if (running) {
+                    respond(id, "prompt", false, { error: "a prompt is already running; abort it or wait" });
+                    return;
+                }
+                // Acknowledged before it runs: the host learns the command was accepted
+                // immediately and follows the work through the event stream.
+                respond(id, "prompt", true);
+                running = agent
+                    .prompt(command.message)
+                    .catch((error) => {
+                    write({ type: "error", message: error instanceof Error ? error.message : String(error) });
+                })
+                    .finally(() => {
+                    running = null;
+                });
+                return;
+            }
+            if (type === "abort") {
+                void agent.abort().then(() => respond(id, "abort", true));
+                return;
+            }
+            if (type === "get_state") {
+                respond(id, "get_state", true, { data: { running: running !== null, ...(options.state?.() ?? {}) } });
+                return;
+            }
+            if (type === "get_last_assistant_text") {
+                respond(id, "get_last_assistant_text", true, { data: { text: agent.getLastAssistantText() ?? null } });
+                return;
+            }
+            respond(id, String(type ?? "unknown"), false, { error: `unknown command ${String(type)}` });
+        });
+        lines.on("close", () => {
+            void (running ?? Promise.resolve()).then(async () => {
+                unsubscribe();
+                await agent.dispose();
+                resolve();
+            });
+        });
+    });
+}

package/dist/serve.js

@@ -0,0 +1,50 @@
+import { APP_VERSION } from "./brand.js";
+/** Adapt an opened session to the slice of it the protocol layers use. */
+export function agentFromSession(opened) {
+    return {
+        prompt: (text) => opened.session.prompt(text),
+        abort: () => opened.session.abort(),
+        subscribe: (listener) => opened.session.subscribe((event) => listener(event)),
+        getLastAssistantText: () => opened.session.getLastAssistantText(),
+        lastStopReason: () => {
+            const last = opened.session.state.messages.at(-1);
+            return last?.role === "assistant" ? last.stopReason : undefined;
+        },
+        dispose: () => opened.dispose(),
+    };
+}
+/** Run the chosen protocol on stdin/stdout until stdin closes. */
+export async function serveProtocol(mode, options) {
+    const { openSession } = await import("./session.js");
+    const open = (cwd) => openSession({
+        cwd,
+        model: options.model,
+        thinking: options.thinking,
+        continueSession: false,
+        noSession: false,
+        sessionPath: undefined,
+        // No terminal: a skill that asks a question must say so instead of waiting
+        // on a person who is not there.
+        interactive: false,
+    });
+    if (mode === "acp") {
+        const { runAcp } = await import("./acp.js");
+        await runAcp({
+            input: process.stdin,
+            output: process.stdout,
+            version: APP_VERSION,
+            createAgent: async (cwd) => agentFromSession(await open(cwd)),
+        });
+        return;
+    }
+    const { runRpc } = await import("./rpc.js");
+    const { jsonLine } = await import("./json-events.js");
+    const opened = await open(options.cwd);
+    await runRpc({
+        input: process.stdin,
+        output: process.stdout,
+        agent: agentFromSession(opened),
+        encodeEvent: (event) => jsonLine(event),
+        state: () => ({ sessionId: opened.session.sessionId, model: opened.modelLabel, cwd: options.cwd }),
+    });
+}

package/dist/ui.js

@@ -502,7 +502,7 @@ export function slashCommands(session) {
         ["tools", "list active tools"],
         ["skills", "list loaded skills"],
         ["preset", "browse, install and remove preset skill bundles"],
-        ["roblox", "show RoToolbox activation, MCP and manager status"],
+        ["roblox", "login | logout | status | tunnel on/off — Roblox sign-in and workspace link (alone: RoToolbox status)"],
         ["proxy", "route requests through a proxy, or show the current one"],
         ["export", "write the transcript to a markdown file"],
         ["copy", "copy the last answer to the clipboard"],
@@ -4673,6 +4673,42 @@ export async function runWorkbench(options) {
             return;
         }
         if (name === "roblox") {
+            const { RobloxConnect, readBridgeEndpoint, describeStatus, parseRobloxSubcommand } = await import("./roblox-connect.js");
+            const subcommand = parseRobloxSubcommand(arg);
+            if (subcommand) {
+                const connect = new RobloxConnect(readBridgeEndpoint(AGENT_DIR));
+                try {
+                    if (subcommand.sub === "status") {
+                        const tunnel = await connect.tunnel("status").catch(() => undefined);
+                        note("roblox", describeStatus(await connect.status(), tunnel));
+                    }
+                    else if (subcommand.sub === "login") {
+                        note("roblox", "opening Roblox in your browser to sign in…");
+                        const result = await connect.login({
+                            onUrl: (url) => note("roblox", `if the browser did not open, go to:\n${url}`),
+                        });
+                        note("roblox", result.message);
+                    }
+                    else if (subcommand.sub === "logout") {
+                        await connect.logout();
+                        note("roblox", "signed out of Roblox");
+                    }
+                    else {
+                        const action = subcommand.rest === "off" ? "stop" : subcommand.rest === "on" || subcommand.rest === "" ? "start" : undefined;
+                        if (!action) {
+                            note("roblox", "usage: /roblox tunnel on | off");
+                        }
+                        else {
+                            const result = await connect.tunnel(action);
+                            note("roblox", result.message ?? "done");
+                        }
+                    }
+                }
+                catch (cause) {
+                    note("roblox", cause instanceof Error ? cause.message : String(cause));
+                }
+                return;
+            }
             const entry = listCatalog(options.cwd).entries.find((candidate) => candidate.manifest.name === "rotoolbox");
             if (!entry || entry.source !== "installed") {
                 note("roblox", "RoToolbox is not installed. Run /preset and install RoToolbox first.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "howtofixcli",
-  "version": "0.7.13",
+  "version": "0.7.14",
   "description": "HowToFix coding agent. Workbench TUI, sessions, background agents.",
   "type": "module",
   "bin": {