@ronana/mcp 0.1.0 → 0.2.0

package/README.md

@@ -38,6 +38,9 @@ ronana generate cost   google/nano-banana-2-lite/edit --prompt "make it dusk" --
 ronana generate create google/nano-banana-2-lite/edit --prompt "make it dusk" --image ./photo.png --out ./renders
 ronana generate get <id> | wait <id> [--out dir]
 ronana generate list
+ronana upscale <id | file | url> --resolution 4k --out ./renders
+ronana improve google/nano-banana-2-lite/edit --prompt "make it dusk"
+ronana folder list | add <folder> <id…>
 ```
 
 Every field from `model get` is a flag (`--aspect_ratio 16:9`, `--seed 7`).
@@ -95,18 +98,23 @@ library.
 | `get_model` | Get one model's contract: its input schema. |
 | `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. |
+| `get_generation` | Get one generation and its download link. Pass `wait_seconds` (up to 45) to wait for the result in one call. |
+| `upscale` | Upscale a video to a higher resolution. |
+| `improve_prompt` | Rewrite a prompt so it works better on one model. |
 | `list_generations` | List recent generations. |
 | `list_references` | List library references. |
 | `upload_reference` | Add a file to the library from a URL (up to 25 MB) or from base64 (under 3 MB). |
 | `create_upload` | Get a private upload link for a larger local file (up to 200 MB). |
 | `finish_upload` | Add a file uploaded with `create_upload` to the 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. |
 
 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
-(`ref_…`, `img_…`, `gen_…`). Generation tools return an id immediately. Poll
-`get_generation` until the status is `completed` or `failed`.
+(`ref_…`, `img_…`, `gen_…`). Generation tools return an id immediately. Call
+`get_generation` with `wait_seconds` until the status is `completed` or
+`failed`. Apps that support MCP Apps show the image or video right in the chat.
 
 ```json
 { "model": "google/nano-banana-2/edit", "input": { "prompt": "a lantern shop at dusk", "images": ["https://example.com/ref.png"] } }

package/dist/cli.js

@@ -12,6 +12,9 @@
 //   ronana generate cost <model> [same flags as create]
 //   ronana generate get | wait <id> [--out dir]
 //   ronana generate list [--limit n]
+//   ronana upscale <id | file | https-url> [--resolution r] [--model m] [--wait] [--out dir]
+//   ronana improve <model> --prompt "…"
+//   ronana folder list | add <folder> <id…>
 import { randomUUID } from "node:crypto";
 import { createWriteStream } from "node:fs";
 import { mkdir } from "node:fs/promises";
@@ -20,7 +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 { buildInput, flag, has, parseArgs, replaceLocalMedia, typeOf } from "./input.js";
+import { buildInput, flag, has, isRemoteValue, parseArgs, replaceLocalMedia, typeOf } from "./input.js";
 const HELP = `Usage: ronana <command>
 
   auth login                    Sign in with your browser (--base-url, --no-browser)
@@ -35,6 +38,10 @@ const HELP = `Usage: ronana <command>
   generate get <id>             Status and download links
   generate wait <id>            Wait for a generation to finish
   generate list                 Recent generations (--limit n)
+  upscale <id|file|url>         Upscale a video (costs credits; --resolution, --model)
+  improve <model> --prompt "…"  Rewrite a prompt for a model (costs a little)
+  folder list                   Your library folders
+  folder add <folder> <id…>     File items into a folder (made if missing)
 
 Generate flags:
   --<field> <value>             Any field from \`model get\`. Repeat for lists.
@@ -80,8 +87,12 @@ async function waitFor(remote, id, args) {
     let last = "";
     for (;;) {
         let gen;
+        const asked = Date.now();
         try {
-            gen = await callTool(remote, "get_generation", { id });
+            // The server holds the call until the job settles (up to 25s), so this
+            // loop makes one request per 25s rather than one every few seconds.
+            const wait_seconds = Math.max(0, Math.min(25, Math.floor((deadline - asked) / 1000)));
+            gen = await callTool(remote, "get_generation", { id, wait_seconds });
         }
         catch (error) {
             // A server answer (not found, no access) is final; anything else is the
@@ -99,7 +110,11 @@ ${id} is still running. Resume with \`ronana generate wait ${id}\`.`);
             return gen;
         if (Date.now() > deadline)
             throw new Error(`Still ${gen.status} after ${timeoutMs / 1000}s. Check later with \`ronana generate wait ${id}\`.`);
-        await new Promise((r) => setTimeout(r, intervalMs));
+        // A server that answered at once (an older one, or a short wait) still gets
+        // the local pause, so the loop never spins.
+        const left = intervalMs - (Date.now() - asked);
+        if (left > 0)
+            await new Promise((r) => setTimeout(r, left));
     }
 }
 const EXT_BY_TYPE = {
@@ -202,7 +217,7 @@ async function modelCommand(sub, args) {
         const filter = args.positional[0]?.toLowerCase();
         const models = (await withRemote((r) => callTool(r, "list_models", kind ? { kind } : {})))
             .filter((m) => !filter || m.id.toLowerCase().includes(filter) || m.name.toLowerCase().includes(filter));
-        return emit(models, () => models.forEach((m) => print(`${m.id.padEnd(52)} ${m.kind.padEnd(6)} ${m.name}`)));
+        return emit(models, () => models.forEach((m) => print(`${m.id.padEnd(52)} ${m.kind.padEnd(6)} ${m.name}${m.best_for ? `  ${m.best_for}` : ""}`)));
     }
     if (sub !== "get")
         throw new Error("Use model list | get.");
@@ -225,9 +240,42 @@ async function modelCommand(sub, args) {
             print(`Priced by: ${contract.priced_fields.join(", ")}`);
     });
 }
+async function upscaleCommand(args) {
+    const [source] = args.positional;
+    if (!source)
+        throw new Error("Usage: ronana upscale <gen_…|ref_… id | file | https-url> [--resolution 4k] [--out dir]");
+    await withRemote(async (remote) => {
+        // A local file uploads first; an id or a URL goes as-is.
+        const resolved = isRemoteValue(source) ? source : (note(`Uploading ${basename(source)}…`), (await uploadFile(remote, resolve(source))).id);
+        const queued = await callTool(remote, "upscale", {
+            source: resolved,
+            ...(flag(args, "model") ? { model: flag(args, "model") } : {}),
+            ...(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);
+    });
+}
+async function folderCommand(sub, args) {
+    if (sub === "list" || sub === undefined) {
+        const folders = await withRemote((r) => callTool(r, "list_folders"));
+        return emit(folders, () => folders.forEach((f) => print(`${f.id.padEnd(28)} ${String(f.count).padStart(5)}  ${f.name}`)));
+    }
+    if (sub !== "add")
+        throw new Error("Use folder list | add.");
+    const [folder, ...ids] = args.positional;
+    if (!folder || ids.length === 0)
+        throw new Error("Usage: ronana folder add <folder> <id…>");
+    const filed = await withRemote((r) => callTool(r, "add_to_folder", { ids, folder, create: true }));
+    return emit(filed, () => print(`Filed ${filed.filed.length} in "${filed.folder.name}".`));
+}
 async function main() {
     const [command, sub, ...rest] = process.argv.slice(2);
-    const takesSub = command === "auth" || command === "model" || command === "generate";
+    const takesSub = command === "auth" || command === "model" || command === "generate" || command === "folder";
     const args = parseArgs(takesSub ? rest : [sub, ...rest].filter((v) => v !== undefined));
     JSON_OUT = has(args, "json");
     if (!command || ["help", "--help", "-h"].includes(command) || has(args, "help"))
@@ -268,6 +316,17 @@ async function main() {
             return emit(ref, () => print(ref.id));
         }
         case "generate": return generateCommand(sub, args);
+        case "upscale": return upscaleCommand(args);
+        case "improve": {
+            const model = args.positional[0];
+            const prompt = flag(args, "prompt");
+            if (!model || !prompt)
+                throw new Error("Usage: ronana improve <model> --prompt \"…\"");
+            const improved = await withRemote((r) => callTool(r, "improve_prompt", { model, prompt }));
+            return emit(improved, () => print(improved.prompt));
+        }
+        case "folder":
+        case "folders": return folderCommand(command === "folders" ? "list" : sub, args);
         default: throw new Error(`Unknown command "${command}". Run \`ronana --help\`.`);
     }
 }

package/dist/oauth.js

@@ -8,6 +8,9 @@ import { Entry } from "@napi-rs/keyring";
 const SERVICE = "Ronana MCP";
 const ACCOUNT = "oauth";
 const SCOPES = "mcp:read mcp:upload mcp:generate offline_access";
+/** How long a sign-in may sit in the browser. An AI agent often runs login for
+ *  the user, and a closed tab must end the command rather than hang it. */
+const LOGIN_TIMEOUT_MS = 5 * 60_000;
 const entry = () => new Entry(SERVICE, ACCOUNT);
 export function readCredentials() {
     const value = entry().getPassword();
@@ -68,6 +71,8 @@ export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ro
         let settle;
         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(); };
         const server = createServer((req, res) => {
             const url = new URL(req.url ?? "/", "http://127.0.0.1");
             if (url.searchParams.get("state") !== state) {
@@ -82,65 +87,74 @@ export async function login(baseUrl = process.env.RONANA_BASE_URL ?? "https://ro
                 res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" }).end("Ronana is connected. You can close this window.");
                 settle(url.searchParams.get("code") ?? "");
             }
-            server.close();
+            close();
         });
-        server.once("error", reject);
+        server.once("error", (error) => { clearTimeout(timer); reject(error); });
         server.listen(0, "127.0.0.1", () => {
             const address = server.address();
-            if (!address || typeof address === "string")
+            if (!address || typeof address === "string") {
+                close();
                 return reject(new Error("Loopback callback failed."));
-            resolve({ redirectUri: `http://127.0.0.1:${address.port}/callback`, code });
+            }
+            resolve({ redirectUri: `http://127.0.0.1:${address.port}/callback`, code, close });
         });
     });
-    const registration = await fetch(`${baseUrl}/api/auth/oauth2/register`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            client_name: "Ronana CLI",
-            redirect_uris: [callback.redirectUri],
-            token_endpoint_auth_method: "none",
-            grant_types: ["authorization_code", "refresh_token"],
-            response_types: ["code"],
+    // Every exit below (refused registration, timeout, a refused token) frees the
+    // loopback port and the timer, so the process can end.
+    try {
+        const registration = await fetch(`${baseUrl}/api/auth/oauth2/register`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                client_name: "Ronana CLI",
+                redirect_uris: [callback.redirectUri],
+                token_endpoint_auth_method: "none",
+                grant_types: ["authorization_code", "refresh_token"],
+                response_types: ["code"],
+                scope: SCOPES,
+            }),
+        });
+        const registered = await registration.json();
+        if (!registration.ok || typeof registered.client_id !== "string")
+            throw new Error("OAuth client registration failed.");
+        const authorize = new URL(`${baseUrl}/api/auth/oauth2/authorize`);
+        authorize.search = new URLSearchParams({
+            response_type: "code",
+            client_id: registered.client_id,
+            redirect_uri: callback.redirectUri,
             scope: SCOPES,
-        }),
-    });
-    const registered = await registration.json();
-    if (!registration.ok || typeof registered.client_id !== "string")
-        throw new Error("OAuth client registration failed.");
-    const authorize = new URL(`${baseUrl}/api/auth/oauth2/authorize`);
-    authorize.search = new URLSearchParams({
-        response_type: "code",
-        client_id: registered.client_id,
-        redirect_uri: callback.redirectUri,
-        scope: SCOPES,
-        resource: `${baseUrl}/mcp`,
-        code_challenge: challenge,
-        code_challenge_method: "S256",
-        state,
-    }).toString();
-    process.stderr.write(`${openInBrowser ? "Opening your browser to sign in. If it does not open, visit" : "Open this link to sign in"}:
+            resource: `${baseUrl}/mcp`,
+            code_challenge: challenge,
+            code_challenge_method: "S256",
+            state,
+        }).toString();
+        process.stderr.write(`${openInBrowser ? "Opening your browser to sign in. If it does not open, visit" : "Open this link to sign in"}:
 ${authorize}
 `);
-    if (openInBrowser)
-        openBrowser(authorize.toString());
-    const code = await callback.code;
-    const tokens = await tokenRequest(baseUrl, {
-        grant_type: "authorization_code",
-        client_id: registered.client_id,
-        redirect_uri: callback.redirectUri,
-        code,
-        code_verifier: verifier,
-        resource: `${baseUrl}/mcp`,
-    });
-    if (typeof tokens.access_token !== "string" || typeof tokens.refresh_token !== "string")
-        throw new Error("OAuth response did not contain tokens.");
-    writeCredentials({
-        baseUrl,
-        clientId: registered.client_id,
-        accessToken: tokens.access_token,
-        refreshToken: tokens.refresh_token,
-        expiresAt: Date.now() + Number(tokens.expires_in ?? 900) * 1000,
-    });
+        if (openInBrowser)
+            openBrowser(authorize.toString());
+        const code = await callback.code;
+        const tokens = await tokenRequest(baseUrl, {
+            grant_type: "authorization_code",
+            client_id: registered.client_id,
+            redirect_uri: callback.redirectUri,
+            code,
+            code_verifier: verifier,
+            resource: `${baseUrl}/mcp`,
+        });
+        if (typeof tokens.access_token !== "string" || typeof tokens.refresh_token !== "string")
+            throw new Error("OAuth response did not contain tokens.");
+        writeCredentials({
+            baseUrl,
+            clientId: registered.client_id,
+            accessToken: tokens.access_token,
+            refreshToken: tokens.refresh_token,
+            expiresAt: Date.now() + Number(tokens.expires_in ?? 900) * 1000,
+        });
+    }
+    finally {
+        callback.close();
+    }
 }
 const fresh = (c) => c.expiresAt > Date.now() + 60_000;
 /** Several CLI runs (and the MCP bridge) share one stored refresh token, and the

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ronana/mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ronana command line and local MCP bridge.",
   "license": "UNLICENSED",
   "homepage": "https://ronana.ai",
   "keywords": ["ronana", "mcp", "cli", "image generation", "video generation"],
   "type": "module",
-  "bin": { "ronana": "./dist/cli.js", "ronana-mcp": "./dist/server.js" },
+  "bin": { "ronana": "dist/cli.js", "ronana-mcp": "dist/server.js" },
   "files": ["dist", "README.md"],
   "publishConfig": { "access": "public" },
   "scripts": {