@ronana/mcp 0.0.0-stage → 0.1.0

package/dist/server.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { realpath, stat } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { fromJsonSchema, McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { z } from "zod4";
+import { login, logout, readCredentials } from "./oauth.js";
+import { remoteClient, ToolError, uploadFile } from "./remote.js";
+const UPLOAD_ROOT = resolve(process.env.RONANA_MCP_UPLOAD_ROOT ?? process.cwd());
+async function resolveInsideRoot(inputPath) {
+    const root = await realpath(UPLOAD_ROOT);
+    const candidate = await realpath(isAbsolute(inputPath) ? inputPath : resolve(root, inputPath));
+    const rel = relative(root, candidate);
+    if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+        throw new Error("The path is outside RONANA_MCP_UPLOAD_ROOT.");
+    return candidate;
+}
+async function serve() {
+    const remote = await remoteClient();
+    const { tools } = await remote.listTools();
+    serveStdio(() => {
+        const server = new McpServer({ name: "Ronana local bridge", version: "1.0.0" });
+        for (const tool of tools) {
+            server.registerTool(tool.name, {
+                title: tool.title,
+                description: tool.description,
+                inputSchema: fromJsonSchema(tool.inputSchema),
+                outputSchema: tool.outputSchema ? fromJsonSchema(tool.outputSchema) : undefined,
+                annotations: tool.annotations,
+            }, async (args) => remote.callTool({
+                name: tool.name,
+                arguments: args,
+            }));
+        }
+        server.registerTool("upload_local_reference", {
+            description: `Upload a local file below ${UPLOAD_ROOT} to the account library.`,
+            inputSchema: z.object({ path: z.string() }),
+            annotations: { readOnlyHint: false, destructiveHint: false },
+        }, async ({ path }) => {
+            try {
+                const safePath = await resolveInsideRoot(path);
+                if (!(await stat(safePath)).isFile())
+                    throw new Error("The path is not a file.");
+                const body = { ok: true, data: await uploadFile(remote, safePath) };
+                return { content: [{ type: "text", text: JSON.stringify(body) }], structuredContent: body };
+            }
+            catch (error) {
+                // A server refusal keeps its own code; a local problem gets ours.
+                const body = { ok: false, error: error instanceof ToolError ? error.error
+                        : { code: "LOCAL_UPLOAD_REJECTED", message: error instanceof Error ? error.message : "The upload failed." } };
+                return { isError: true, content: [{ type: "text", text: JSON.stringify(body) }], structuredContent: body };
+            }
+        });
+        return server;
+    });
+}
+async function main() {
+    const command = process.argv[2] ?? "serve";
+    if (command === "login") {
+        await login();
+        process.stdout.write("Connected.\n");
+        return;
+    }
+    if (command === "logout") {
+        await logout();
+        process.stdout.write("Disconnected.\n");
+        return;
+    }
+    if (command === "status") {
+        const credentials = readCredentials();
+        process.stdout.write(credentials ? `Connected to ${credentials.baseUrl}.\n` : "Not connected.\n");
+        return;
+    }
+    if (command === "serve") {
+        await serve();
+        return;
+    }
+    throw new Error("Use login, logout, status, or serve.");
+}
+main().catch((error) => {
+    process.stderr.write(`[ronana-mcp] ${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+});

package/dist/types.d.ts

@@ -0,0 +1,173 @@
+export type RefKind = "image" | "video" | "audio";
+export interface ApiSlotSpec {
+    id: string;
+    kind: RefKind;
+    required: boolean;
+}
+export interface ApiRefSpec {
+    kinds: readonly RefKind[];
+    max: {
+        images?: number;
+        videos?: number;
+        audio?: number;
+        total?: number;
+        videosTotalSec?: number;
+        audioTotalSec?: number;
+        videoMaxBytes?: number;
+        audioMaxBytes?: number;
+        videoMinSec?: number;
+        videoMinWidthPx?: number;
+        videoMaxWidthPx?: number;
+        imageMinPx?: number;
+        imageMaxPx?: number;
+        imageMaxBytes?: number;
+        imageMaxPixels?: number;
+        imageMinAspect?: number;
+        imageMaxAspect?: number;
+        videoMaxSec?: number;
+    };
+    inline: boolean;
+    slots: readonly ApiSlotSpec[];
+    attachmentGroups: {
+        tokenPrefix?: string;
+        maxGroups: number;
+        kinds: Array<"image" | "video" | "audio">;
+        minPerGroup: number;
+        maxPerGroup: number;
+        primaryFirst?: boolean;
+    } | null;
+}
+export type ApiParamSpec = {
+    id: string;
+    kind: "number";
+    min: number;
+    max: number;
+    step: number;
+} | {
+    id: string;
+    kind: "select";
+    options: readonly string[];
+} | {
+    id: string;
+    kind: "toggle";
+};
+export interface ApiInputConditionedRule {
+    mode: "t2v" | "i2v" | "r2v";
+    aspect?: string[];
+    resolution?: string[];
+    duration?: number[];
+    when: readonly {
+        imageRefs: "0" | "1" | "2+" | "any";
+        audioRefs: "0" | "1+" | "any";
+    }[];
+}
+export interface ApiModelSpec {
+    id: string;
+    kind: "video" | "image";
+    name: string;
+    prompt: {
+        required: boolean;
+        maxChars?: number;
+    };
+    aspect: readonly string[];
+    aspectWithImage: readonly string[];
+    resolution: readonly string[];
+    duration: readonly number[];
+    quality: readonly ("low" | "medium" | "high")[];
+    dimensionsFromReference: boolean;
+    refs: ApiRefSpec;
+    params: readonly ApiParamSpec[];
+    variants: readonly ApiInputConditionedRule[];
+    multiShot: boolean;
+    seed: boolean;
+    negativePrompt: boolean;
+    generateAudio: boolean;
+    movementAmplitude: boolean;
+    webSearch: boolean;
+    mask: {
+        format: "png-data-url";
+        dimensions: "match-first-image";
+        polarity: "alpha-punch" | "white-on-black";
+    } | null;
+}
+/**
+ * What the server actually SENDS for a model.
+ *
+ * `ApiModelSpec` above is the total shape. The wire is smaller, twice over: it
+ * drops every field carrying no information (`false`, `null`, an empty list),
+ * and it drops the fields only the studio uses (`category`, `preset`, and the
+ * `group`/`label` split, which arrives as one `name`). A capability the model
+ * does not have is ABSENT rather than sent as a "no", so read presence as
+ * support:
+ *
+ *     if (model.seed) { ... }          // correct, whether absent or true
+ *     for (const s of model.refs?.slots ?? []) { ... }
+ *
+ * Derived from `ApiModelSpec`, never hand-written, so a new field on the server
+ * reaches this type with no second edit here.
+ */
+type Loosen<T> = {
+    [K in keyof T]?: T[K];
+};
+export type InternalModelField = never;
+export type ApiPublicModel = Loosen<Omit<ApiModelSpec, "refs" | "prompt" | InternalModelField>> & {
+    /** The model's display name, in one piece. */
+    name?: string;
+    refs?: Loosen<ApiRefSpec>;
+    prompt?: Loosen<ApiModelSpec["prompt"]>;
+};
+/** The error envelope every v1 endpoint returns on a failure. */
+export interface ApiErrorBody {
+    error: {
+        code: "AUTH_REQUIRED" | "AUTH_INVALID" | "AUTH_EXPIRED" | "SCOPE_INSUFFICIENT" | "ACCOUNT_SUSPENDED" | "ACCOUNT_PENDING_DELETION" | "EMAIL_UNVERIFIED" | "PLAN_UPGRADE_REQUIRED" | "CREDITS_INSUFFICIENT" | "SPEND_LOCKED" | "DAILY_CREDIT_CAP" | "KEY_DAILY_CREDIT_CAP" | "DAILY_GENERATION_CAP" | "STORAGE_FULL" | "RATE_LIMITED" | "CONCURRENCY_LIMIT" | "INVALID_REQUEST" | "MODEL_UNKNOWN" | "MODEL_DISABLED" | "NOT_FOUND" | "PROMPT_TOO_LONG" | "UNSUPPORTED_OPTION" | "LAUNCH_CLOSED" | "SERVICE_UNAVAILABLE" | "INTERNAL";
+        message: string;
+        requestId: string;
+        retryAfterMs?: number;
+        resetAt?: string;
+        field?: string;
+        billing?: {
+            balance?: number;
+            needed?: number;
+            currentTier?: string;
+            requiredTier?: string;
+            nextTier?: {
+                id: string;
+                creditsMonthly: number;
+            } | null;
+            purchasesEnabled?: boolean;
+            atMaxTier?: boolean;
+            action: "buy_credits" | "upgrade_plan" | "either" | "verify_email" | "wait" | "contact_support";
+            url: string;
+        };
+    };
+}
+export interface GenerationState {
+    id: string;
+    kind: "video" | "image";
+    status: "queued" | "processing" | "completed" | "failed" | "canceled";
+    model: string;
+    prompt: string;
+    aspectRatio: string;
+    resolution: string;
+    durationS?: number;
+    quality?: "low" | "medium" | "high" | null;
+    source: "api";
+    output: {
+        url: string | null;
+        expiresAt: string | null;
+        bytes: number | null;
+        width: number | null;
+        height: number | null;
+        durationS?: number | null;
+        retentionExpiresAt: string | null;
+    };
+    failure: {
+        reason: string;
+        title: string;
+        detail: string;
+        detailKey?: string;
+    } | null;
+    createdAt: string;
+    completedAt: string | null;
+}
+export {};

package/dist/types.js

@@ -0,0 +1,11 @@
+// The public shapes this package reads, declared with NO runtime import.
+//
+// They are a copy of the types the server publishes at `GET /api/v1/models`
+// (lib/api/modelSchema.ts). The copy is deliberate: this package must run from
+// npm with nothing but `RONANA_API_KEY` and `RONANA_BASE_URL`, so it can hold no
+// path into the application repository.
+//
+// tests/mcpPublicTypes.test.ts asserts the two definitions stay compatible, in
+// both directions. If somebody adds a field to `ApiModelSpec` and forgets this
+// file, that test fails.
+export {};

package/package.json

@@ -1,6 +1,28 @@
 {
   "name": "@ronana/mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.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" },
+  "files": ["dist", "README.md"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "start": "node --import tsx src/server.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/server": "2.0.0",
+    "@napi-rs/keyring": "1.3.0",
+    "zod4": "npm:zod@4.4.3"
+  },
+  "devDependencies": {
+    "typescript": "^5",
+    "tsx": "^4"
+  },
+  "engines": { "node": ">=20" }
+}