@ronana/mcp 0.3.1 → 0.4.0

package/README.md

@@ -39,6 +39,7 @@ ronana generate get <id> | wait <id> [--out dir]
 ronana generate list
 ronana upscale <id | file | url> --resolution 4k --out ./renders
 ronana folder list | add <folder> <id…>
+ronana listen [--with claude|codex|gemini|ollama|command] [--model m]
 ```
 
 Every field from `model get` is a flag (`--aspect_ratio 16:9`, `--seed 7`).
@@ -53,6 +54,14 @@ the full list.
 the same command run twice makes two generations. Pass `--idempotency-key` to
 make a retry bill once.
 
+`listen` lets the Ronana studio send work to an AI on your computer. While it
+runs, the studio's assistant and agent list it under their model menu, and
+Enhance, assistant messages and agent turns go to it instead of Ronana's own
+models, so they cost no credits. Renders still do, and agent cards wait for
+your Confirm. `--with` picks the AI (Claude Code by default); `--with command
+--command "…"` runs any program that reads the prompt on stdin and prints its
+answer.
+
 ## Use Ronana from an AI app
 
 Most AI apps connect to Ronana's remote MCP server directly. Add this URL as a
@@ -112,6 +121,7 @@ library.
 | --- | --- |
 | `list_models` | List the available models. |
 | `get_model` | Get one model's contract: its input schema. |
+| `get_prompt_guide` | Get the guide for writing a prompt for one model. |
 | `estimate_cost` | Estimate the credit cost of a generation. Takes the same `model` and `input` as `generate`. |
 | `generate` | Start an image or video generation. |
 | `get_generation` | Get one generation and its download link. Pass `wait_seconds` (up to 45) to wait for the result in one call. |
@@ -124,6 +134,11 @@ library.
 | `list_folders` | List the folders in the library. |
 | `add_to_folder` | File library items into a folder. |
 | `get_account` | Get the plan and credit balance. |
+| `wait_for_requests` | Wait for Enhance, assistant and agent work from the studio. While an app calls it, the studio lists it as listening. |
+| `get_request` | Read one request the studio sent, by its id. |
+| `request_progress` | Tell the studio you are still working on a request you took, so a slow answer is not treated as abandoned. |
+| `agent_tool` | Look up models, prompt guides and prices for an agent request. |
+| `reply` | Answer a request: a prompt for the composer, a message, or cards for the board. |
 
 A generate call takes a `model` and an `input`, exactly as `get_model` shows it
 in `input_schema`. A media field takes a public https URL or a Ronana id

package/dist/cli.js

@@ -14,6 +14,7 @@
 //   ronana generate list [--limit n]
 //   ronana upscale <id | file | https-url> [--resolution r] [--model m] [--wait] [--out dir]
 //   ronana folder list | add <folder> <id…>
+//   ronana listen [--with claude|codex|gemini|ollama|command] [--model m] [--command "…"]
 import { randomUUID } from "node:crypto";
 import { createWriteStream, existsSync, statSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
@@ -22,6 +23,7 @@ import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { login, logout, readCredentials } from "./oauth.js";
 import { callTool, remoteClient, ToolError, uploadFile } from "./remote.js";
+import { listen, runnerFor } from "./listen.js";
 import { buildInput, flag, has, isRemoteValue, parseArgs, replaceLocalMedia, typeOf } from "./input.js";
 const HELP = `Usage: ronana <command>
 
@@ -40,6 +42,9 @@ const HELP = `Usage: ronana <command>
   upscale <id|file|url>         Upscale a video (costs credits; --resolution, --model)
   folder list                   Your library folders
   folder add <folder> <id…>     File items into a folder (made if missing)
+  listen                        Let the studio send Enhance and agent work to an AI
+                                on this computer (--with claude|codex|gemini|ollama|command,
+                                --model m, --command "…", --app "name"). No credits.
 
 Generate flags:
   --<field> <value>             Any field from \`model get\`. Repeat for lists.
@@ -173,6 +178,14 @@ async function withRemote(fn) {
         await remote.close().catch(() => null);
     }
 }
+/** A queued job: print its id, or with --wait / --out follow it to the end. */
+async function queuedThenFinish(remote, queued, args) {
+    if (!has(args, "wait") && !has(args, "out")) {
+        return emit(queued, () => { print(queued.id); note(`Check it with \`ronana generate wait ${queued.id}\`.`); });
+    }
+    note(`Queued ${queued.id}.`);
+    await finish(await waitFor(remote, queued.id, args), args);
+}
 async function generateCommand(sub, args) {
     const [target] = args.positional;
     if (sub === "list") {
@@ -208,11 +221,7 @@ async function generateCommand(sub, args) {
            command run twice in ten minutes would return the first generation. */
         const idempotency_key = flag(args, "idempotency_key") ?? randomUUID();
         const queued = await callTool(remote, "generate", { model: contract.id, input, idempotency_key });
-        if (!has(args, "wait") && !has(args, "out")) {
-            return emit(queued, () => { print(queued.id); note(`Check it with \`ronana generate wait ${queued.id}\`.`); });
-        }
-        note(`Queued ${queued.id}.`);
-        await finish(await waitFor(remote, queued.id, args), args);
+        await queuedThenFinish(remote, queued, args);
     });
 }
 async function modelCommand(sub, args) {
@@ -263,11 +272,7 @@ async function upscaleCommand(args) {
             ...(flag(args, "resolution") ? { resolution: flag(args, "resolution") } : {}),
             idempotency_key: flag(args, "idempotency_key") ?? randomUUID(),
         });
-        if (!has(args, "wait") && !has(args, "out")) {
-            return emit(queued, () => { print(queued.id); note(`Check it with \`ronana generate wait ${queued.id}\`.`); });
-        }
-        note(`Queued ${queued.id}.`);
-        await finish(await waitFor(remote, queued.id, args), args);
+        await queuedThenFinish(remote, queued, args);
     });
 }
 async function folderCommand(sub, args) {
@@ -317,7 +322,12 @@ async function main() {
             }
             if (action === "status") {
                 const credentials = readCredentials();
-                return emit({ signed_in: !!credentials, base_url: credentials?.baseUrl ?? null }, () => print(credentials ? `Signed in to ${credentials.baseUrl}.` : "Not signed in."));
+                if (!credentials)
+                    return emit({ signed_in: false, base_url: null }, () => print("Not signed in."));
+                // Ask the server: a sign-in stored here may have been disconnected on
+                // the website or have expired, and only the server knows.
+                const problem = await withRemote((r) => callTool(r, "get_account")).then(() => null, (error) => error instanceof ToolError ? null : error instanceof Error ? error.message : String(error));
+                return emit({ signed_in: problem === null, base_url: credentials.baseUrl, ...(problem ? { error: problem } : {}) }, () => print(problem ?? `Signed in to ${credentials.baseUrl}.`));
             }
             throw new Error("Use auth login | logout | status.");
         }
@@ -342,6 +352,14 @@ async function main() {
         case "upscale": return upscaleCommand(args);
         case "folder":
         case "folders": return folderCommand(command === "folders" ? "list" : sub, args);
+        case "listen": {
+            const runner = runnerFor(flag(args, "with") ?? "claude", { model: flag(args, "model"), command: flag(args, "command"), app: flag(args, "app") });
+            const remote = await remoteClient();
+            const stop = () => { void remote.close().catch(() => null).finally(() => process.exit(0)); };
+            process.once("SIGINT", stop);
+            process.once("SIGTERM", stop);
+            return listen(remote, runner, (line) => process.stderr.write(`${line}\n`));
+        }
         default: throw new Error(`Unknown command "${command}". Run \`ronana --help\`.`);
     }
 }

package/dist/listen.d.ts

@@ -0,0 +1,56 @@
+import { type remoteClient } from "./remote.js";
+type Remote = Awaited<ReturnType<typeof remoteClient>>;
+export interface Runner {
+    app: string;
+    command: string;
+    args: string[];
+    shell: boolean;
+}
+/** The AIs `--with` knows. Each reads the prompt on stdin and prints its answer. */
+export declare function runnerFor(name: string, options: {
+    model?: string;
+    command?: string;
+    app?: string;
+}): Runner;
+/** Run the AI once. Resolves with what it printed. */
+export declare function runOnce(runner: Runner, prompt: string, timeoutMs: number): Promise<string>;
+interface EnhanceRequest {
+    id: string;
+    kind: "enhance";
+    model: {
+        id: string;
+        name: string;
+    };
+    draft: string;
+    brief?: string;
+    guide: string;
+    max_chars: number;
+}
+interface AgentRequest {
+    id: string;
+    kind: "agent";
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    references: {
+        target: unknown;
+        kind: string;
+        label: string;
+        duration_s?: number;
+    }[];
+    context?: string;
+    approval_mode: string;
+    max_cards: number;
+    card_schema: unknown;
+}
+export type StudioRequest = EnhanceRequest | AgentRequest;
+/** The prompt between <prompt> tags, or the whole answer when it has none. */
+export declare function extractPrompt(text: string): string;
+/** The first JSON object in the answer, fenced or bare. */
+export declare function extractJson(text: string): Record<string, unknown> | null;
+export declare function enhancePrompt(request: EnhanceRequest, refusal?: string): string;
+export declare function agentPrompt(request: AgentRequest, catalog: string, refusal?: string): string;
+/** Listen until Ctrl+C. */
+export declare function listen(remote: Remote, runner: Runner, log: (line: string) => void): Promise<never>;
+export {};

package/dist/listen.js

@@ -0,0 +1,186 @@
+// `ronana listen`: keep an AI on this computer listening for work from the
+// Ronana studio. While it runs, the studio lists it under its model menus and
+// sends it Enhance and agent requests instead of using Ronana's own models, so
+// the thinking runs on the user's own AI and costs no Ronana credits.
+//
+// The loop holds `wait_for_requests` open, runs the chosen AI once per request
+// with the prompt on stdin, and sends its answer with `reply`. The server
+// checks every reply; a refused one is handed back to the AI once to fix.
+import { spawn } from "node:child_process";
+import { callTool, ToolError } from "./remote.js";
+/** The AIs `--with` knows. Each reads the prompt on stdin and prints its answer. */
+export function runnerFor(name, options) {
+    const shell = process.platform === "win32";
+    const app = options.app?.trim();
+    switch (name) {
+        case "claude": return { app: app || "Claude Code", command: "claude", args: ["-p", "--output-format", "text", ...(options.model ? ["--model", options.model] : [])], shell };
+        case "codex": return { app: app || "Codex", command: "codex", args: ["exec", ...(options.model ? ["-m", options.model] : []), "-"], shell };
+        case "gemini": return { app: app || "Gemini CLI", command: "gemini", args: options.model ? ["-m", options.model] : [], shell };
+        case "ollama":
+            if (!options.model)
+                throw new Error("--with ollama needs --model <name>, e.g. --model llama3.1.");
+            return { app: app || `Ollama ${options.model}`, command: "ollama", args: ["run", options.model], shell };
+        case "command":
+            if (!options.command?.trim())
+                throw new Error("--with command needs --command \"<your command>\"; it gets the prompt on stdin.");
+            return { app: app || "Desktop AI", command: options.command, args: [], shell: true };
+        default: throw new Error(`Unknown --with "${name}". Use claude, codex, gemini, ollama or command.`);
+    }
+}
+/** Run the AI once. Resolves with what it printed. */
+export function runOnce(runner, prompt, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(runner.command, runner.args, { shell: runner.shell, stdio: ["pipe", "pipe", "pipe"] });
+        let out = "";
+        let err = "";
+        const timer = setTimeout(() => { child.kill(); reject(new Error(`${runner.app} took longer than ${Math.round(timeoutMs / 1000)}s.`)); }, timeoutMs);
+        child.stdout.on("data", (chunk) => { out += chunk.toString("utf8"); });
+        child.stderr.on("data", (chunk) => { err += chunk.toString("utf8"); });
+        child.on("error", (error) => { clearTimeout(timer); reject(new Error(`Could not start ${runner.command}: ${error.message}`)); });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve(out);
+            else
+                reject(new Error(`${runner.app} exited with code ${code}${err.trim() ? `: ${err.trim().split("\n").slice(-3).join(" ")}` : ""}`));
+        });
+        child.stdin.end(prompt);
+    });
+}
+/** The prompt between <prompt> tags, or the whole answer when it has none. */
+export function extractPrompt(text) {
+    const tagged = /<prompt>([\s\S]*?)(?:<\/prompt>|$)/i.exec(text);
+    return (tagged ? tagged[1] : text).trim();
+}
+/** The first JSON object in the answer, fenced or bare. */
+export function extractJson(text) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
+    const candidates = [fenced?.[1], text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1)];
+    for (const raw of candidates) {
+        if (!raw?.trim())
+            continue;
+        try {
+            const value = JSON.parse(raw);
+            if (value && typeof value === "object" && !Array.isArray(value))
+                return value;
+        }
+        catch { /* try the next shape */ }
+    }
+    return null;
+}
+export function enhancePrompt(request, refusal) {
+    return [
+        `Rewrite this draft into the best prompt for ${request.model.name}, following the guide.`,
+        "Keep every reference token exactly as the draft writes it (@image1, @video1, @audio1).",
+        `Answer with the final prompt only, between <prompt> and </prompt>, at most ${request.max_chars} characters.`,
+        "", "GUIDE:", request.guide,
+        ...(request.brief ? ["", "BRIEF:", request.brief] : []),
+        "", "DRAFT:", request.draft,
+        ...(refusal ? ["", `Your last answer was refused: ${refusal}`, "Fix that and answer again."] : []),
+    ].join("\n");
+}
+export function agentPrompt(request, catalog, refusal) {
+    const transcript = request.messages.map((m) => `${m.role === "user" ? "USER" : "AGENT"}: ${m.content}`).join("\n\n");
+    return [
+        "You are the agent on the user's Ronana board. Answer their latest message.",
+        `You may propose up to ${request.max_cards} generation cards; each waits for the user's Confirm and spends nothing until then.`,
+        "Answer with ONE JSON object and nothing else: {\"message\": \"what the user reads\", \"cards\": [ ... ]}.",
+        "Each card follows CARD SCHEMA; modelId must come from MODELS.",
+        "", "MODELS:", catalog,
+        "", "CARD SCHEMA:", JSON.stringify(request.card_schema),
+        ...(request.references.length ? ["", "ATTACHED:", JSON.stringify(request.references)] : []),
+        ...(request.context ? ["", "CONTEXT:", request.context] : []),
+        "", "CONVERSATION:", transcript,
+        ...(refusal ? ["", `Your last answer was refused: ${refusal}`, "Fix that and answer again."] : []),
+    ].join("\n");
+}
+const ENHANCE_TIMEOUT_MS = 120_000;
+/** The least time between two empty waits. */
+const IDLE_FLOOR_MS = 5_000;
+// Inside the board's own wait for an answer.
+const AGENT_TIMEOUT_MS = 150_000;
+/** "Still working" every 15s while the AI writes. The studio treats a taken
+ *  request that goes quiet for 45s as abandoned, so this is what lets a slow
+ *  answer take its time. Best effort: a missed beat is not an error. */
+const PROGRESS_EVERY_MS = 15_000;
+async function answer(remote, runner, request, log) {
+    const beat = setInterval(() => { void callTool(remote, "request_progress", { id: request.id }).catch(() => { }); }, PROGRESS_EVERY_MS);
+    try {
+        await answerOnce(remote, runner, request, log);
+    }
+    finally {
+        clearInterval(beat);
+    }
+}
+async function answerOnce(remote, runner, request, log) {
+    let catalog = "";
+    if (request.kind === "agent") {
+        catalog = JSON.stringify(await callTool(remote, "agent_tool", { id: request.id, name: "list_models", input: {} }));
+    }
+    let refusal;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const prompt = request.kind === "enhance" ? enhancePrompt(request, refusal) : agentPrompt(request, catalog, refusal);
+        const output = await runOnce(runner, prompt, request.kind === "enhance" ? ENHANCE_TIMEOUT_MS : AGENT_TIMEOUT_MS);
+        let args;
+        if (request.kind === "enhance") {
+            args = { id: request.id, prompt: extractPrompt(output) };
+        }
+        else {
+            const json = extractJson(output);
+            if (!json) {
+                refusal = "it was not one JSON object.";
+                continue;
+            }
+            args = { id: request.id, message: typeof json.message === "string" ? json.message : "", cards: Array.isArray(json.cards) ? json.cards : [] };
+        }
+        try {
+            await callTool(remote, "reply", args);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof ToolError) || error.error.code !== "INVALID_REPLY")
+                throw error;
+            refusal = error.message;
+            log(`  refused (${refusal}); asking ${runner.app} to fix it`);
+        }
+    }
+    throw new Error(`${runner.app} could not produce an answer the studio accepts${refusal ? `: ${refusal}` : "."}`);
+}
+/** Listen until Ctrl+C. */
+export async function listen(remote, runner, log) {
+    log(`Listening as ${runner.app}. Ronana's studio now sends Enhance and agent requests here (Ctrl+C to stop).`);
+    let backoff = 0;
+    for (;;) {
+        try {
+            const asked = Date.now();
+            const { request } = await callTool(remote, "wait_for_requests", { app: runner.app });
+            backoff = 0;
+            if (!request) {
+                // The server answers at once (not after holding) when its budget of
+                // held calls is spent: pause instead of asking again in a tight loop.
+                if (Date.now() - asked < IDLE_FLOOR_MS)
+                    await new Promise((resolve) => setTimeout(resolve, IDLE_FLOOR_MS));
+                continue;
+            }
+            const started = Date.now();
+            log(`● ${request.kind} ${request.id}${request.kind === "enhance" ? ` · ${request.model.name}` : ""}`);
+            try {
+                await answer(remote, runner, request, log);
+                log(`✓ sent · ${((Date.now() - started) / 1000).toFixed(1)}s`);
+            }
+            catch (error) {
+                log(`✗ ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        catch (error) {
+            // A refused sign-in or a missing plan will not fix itself: stop.
+            if (error instanceof ToolError && (error.error.code === "SCOPE_REQUIRED" || error.error.code === "UNAUTHORIZED"))
+                throw error;
+            if (error instanceof Error && /sign.?in|401|pricing/i.test(error.message))
+                throw error;
+            backoff = Math.min(30_000, backoff ? backoff * 2 : 2_000);
+            log(`Connection problem (${error instanceof Error ? error.message : String(error)}). Retrying in ${backoff / 1000}s.`);
+            await new Promise((resolve) => setTimeout(resolve, backoff));
+        }
+    }
+}

package/dist/oauth.d.ts

@@ -8,4 +8,6 @@ export interface StoredCredentials {
 export declare function readCredentials(): StoredCredentials | null;
 export declare function logout(): Promise<void>;
 export declare function login(baseUrl?: string, openInBrowser?: boolean): Promise<void>;
+/** What a user reads when the stored sign-in no longer works on the server. */
+export declare const SIGN_IN_ENDED = "Your Ronana sign-in has ended (disconnected or expired). Run `ronana auth login` again.";
 export declare function accessToken(): Promise<string>;

package/dist/oauth.js

@@ -84,24 +84,37 @@ export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ro
         let fail;
         const code = new Promise((ok, no) => { settle = ok; fail = no; });
         const timer = setTimeout(() => fail(new Error("Sign-in timed out. Run `ronana auth login` again.")), LOGIN_TIMEOUT_MS);
-        const close = () => { clearTimeout(timer); server.close(); };
+        /* The browser tab waits on this response until the code has been traded
+           for tokens, so it only says "connected" once that is true. */
+        let held = null;
+        let answered = false;
+        const finish = (text, status = 200) => {
+            if (!held)
+                return;
+            held.writeHead(status, { "Content-Type": "text/plain; charset=utf-8" }).end(text);
+            held = null;
+        };
+        const close = () => {
+            clearTimeout(timer);
+            finish("Sign-in did not finish. See your terminal for why.", 500);
+            server.close();
+        };
         const server = createServer((req, res) => {
             const url = new URL(req.url ?? "/", "http://127.0.0.1");
             // Anything but our own callback (a favicon, a prefetch, a stale tab from an
-            // earlier sign-in) is ignored, so it cannot end the sign-in it isn't part of.
-            if (url.pathname !== "/callback" || url.searchParams.get("state") !== state) {
+            // earlier sign-in, a repeat) is ignored, so it cannot end the sign-in.
+            if (answered || url.pathname !== "/callback" || url.searchParams.get("state") !== state) {
                 res.writeHead(404).end();
                 return;
             }
+            answered = true;
             if (url.searchParams.get("error")) {
-                res.writeHead(400).end("Authorization was not completed.");
+                res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" }).end("Authorization was not completed.");
                 fail(new Error(url.searchParams.get("error_description") ?? url.searchParams.get("error")));
+                return;
             }
-            else {
-                res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" }).end("Ronana is connected. You can close this window.");
-                settle(url.searchParams.get("code") ?? "");
-            }
-            close();
+            held = res;
+            settle(url.searchParams.get("code") ?? "");
         });
         server.once("error", (error) => { clearTimeout(timer); reject(error); });
         server.listen(0, "127.0.0.1", () => {
@@ -110,7 +123,7 @@ export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ro
                 close();
                 return reject(new Error("Loopback callback failed."));
             }
-            resolve({ redirectUri: `http://127.0.0.1:${address.port}/callback`, code, close });
+            resolve({ redirectUri: `http://127.0.0.1:${address.port}/callback`, code, finish, close });
         });
     });
     // Every exit below (refused registration, timeout, a refused token) frees the
@@ -170,7 +183,8 @@ ${authorize}
             refreshToken: tokens.refresh_token,
             expiresAt: Date.now() + Number(tokens.expires_in ?? 900) * 1000,
         });
-        if (previous && previous.clientId !== registered.client_id)
+        callback.finish("Ronana is connected. You can close this window.");
+        if (previous)
             await revoke(previous);
     }
     finally {
@@ -214,6 +228,8 @@ async function withRefreshLock(fn) {
             catch { /* Gone already. */ }
     }
 }
+/** What a user reads when the stored sign-in no longer works on the server. */
+export const SIGN_IN_ENDED = "Your Ronana sign-in has ended (disconnected or expired). Run `ronana auth login` again.";
 export async function accessToken() {
     const stored = readCredentials();
     if (!stored)
@@ -237,8 +253,15 @@ export async function accessToken() {
             // server's own words ("session not found") would read as something else.
             if (error instanceof TypeError)
                 throw error;
-            throw new Error("Your Ronana sign-in has ended (disconnected or expired). Run `ronana auth login` again.");
+            // A login in another process replaces the stored sign-in and revokes the
+            // one we were refreshing: carry on with the new one instead.
+            const replaced = readCredentials();
+            if (replaced && replaced.clientId !== current.clientId && fresh(replaced))
+                return { replaced: replaced.accessToken };
+            throw new Error(SIGN_IN_ENDED);
         });
+        if (typeof tokens.replaced === "string")
+            return tokens.replaced;
         if (typeof tokens.access_token !== "string")
             throw new Error("OAuth refresh failed.");
         const next = {

package/dist/remote.js

@@ -6,7 +6,7 @@ import { readFile } from "node:fs/promises";
 import { basename, extname } from "node:path";
 import { Readable } from "node:stream";
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
-import { accessToken, readCredentials } from "./oauth.js";
+import { accessToken, readCredentials, SIGN_IN_ENDED } from "./oauth.js";
 export async function remoteClient() {
     const credentials = readCredentials();
     if (!credentials)
@@ -20,6 +20,10 @@ export async function remoteClient() {
         await client.connect(transport);
     }
     catch (error) {
+        // A 401 on a token that was still in date: the server answers that for a
+        // connection disconnected on the website.
+        if (error instanceof Error && /\b401\b|unauthori[sz]ed|revoked/i.test(error.message))
+            throw new Error(SIGN_IN_ENDED);
         // A 404 means either an account outside the MCP rollout or a server with no
         // MCP at all (a wrong --base-url). Only a server that advertises the MCP
         // resource can be refusing the account.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronana/mcp",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Ronana command line and local MCP bridge.",
   "license": "MIT",
   "homepage": "https://ronana.ai",