@ojodotso/mcp-server 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 oJo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @ojodotso/mcp-server
+
+A [Model Context Protocol](https://modelcontextprotocol.io) server that lets an
+AI agent generate [oJo](https://ojo.so) images and manage templates through the
+user's own oJo API key. Transport is local **stdio**; the API boundary is HTTP
+to `https://api.ojo.so/v1` only.
+
+## Quick start
+
+Create an API key at <https://ojo.so/dashboard/api>, then point your MCP client
+at the package via `npx`:
+
+```json
+{
+  "mcpServers": {
+    "ojo": {
+      "command": "npx",
+      "args": ["-y", "@ojodotso/mcp-server"],
+      "env": { "OJO_API_KEY": "sk_..." }
+    }
+  }
+}
+```
+
+Works the same for Claude Desktop, Cursor, and Claude Code. For Claude Code:
+
+```bash
+claude mcp add ojo -e OJO_API_KEY=sk_... -- npx -y @ojodotso/mcp-server
+```
+
+## Tools
+
+| Tool | Purpose |
+|------|---------|
+| `generate_image_from_html` | Render plain HTML (with inline CSS) to a PNG; returns its public URL. |
+| `generate_image_from_template` | Render an existing template, optionally overriding variables via `modify`. |
+| `list_templates` | List the templates available to the account. |
+| `get_template` | Fetch one template's decoded HTML and variable defaults. |
+| `create_template` | Create a reusable template from plain HTML/Handlebars. |
+
+Both generate tools accept `inspect: true` to also return a small downscaled
+preview image, so the agent can see the render and iterate. Each image
+generation costs 1 credit; creating a template does not.
+
+## Guiding prompt
+
+`author_ojo_template` — teaches the Handlebars helper catalog, the **Template
+Variables** (schema/defaults) vs **Modify Payload** (per-render data) model, and
+viewport conventions.
+
+## Configuration
+
+- `OJO_API_KEY` (required) — your oJo API key.
+- `OJO_API_BASE_URL` (optional) — defaults to `https://api.ojo.so/v1`.
+
+## Develop (from the monorepo)
+
+```bash
+pnpm --filter @ojodotso/mcp-server build
+pnpm --filter @ojodotso/mcp-server test
+pnpm --filter @ojodotso/mcp-server check
+```

package/build/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const OJO_API_BASE_URL = "https://api.ojo.so/v1";
+export declare const HEADER_VIEWPORT_WIDTH = "x-viewport-width";
+export declare const HEADER_VIEWPORT_HEIGHT = "x-viewport-height";
+export declare const HEADER_TRANSPARENT_BACKGROUND = "x-transparent-background";
+//# sourceMappingURL=constants.d.ts.map

package/build/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,0BAA0B,CAAC;AAKxD,eAAO,MAAM,qBAAqB,qBAAqB,CAAC;AACxD,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAC1D,eAAO,MAAM,6BAA6B,6BAA6B,CAAC"}

package/build/constants.js

@@ -0,0 +1,7 @@
+export const OJO_API_BASE_URL = 'https://api.ojo.so/v1';
+// Inlined from packages/libs (request-headers) so the published package carries
+// no workspace dependencies. Keep in sync with
+// packages/libs/src/constants/request-headers.ts.
+export const HEADER_VIEWPORT_WIDTH = 'x-viewport-width';
+export const HEADER_VIEWPORT_HEIGHT = 'x-viewport-height';
+export const HEADER_TRANSPARENT_BACKGROUND = 'x-transparent-background';

package/build/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/build/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+import { createServer } from './server/index.js';
+import { OjoApiClient } from './server/ojo-client.js';
+import { startStdio } from './transports/stdio.js';
+dotenv.config();
+async function main() {
+    const apiKey = process.env.OJO_API_KEY;
+    if (!apiKey) {
+        console.error('OJO_API_KEY is not set. Create an API key at https://ojo.so/dashboard/api and set OJO_API_KEY before starting the server.');
+        process.exit(1);
+    }
+    const client = new OjoApiClient(apiKey, process.env.OJO_API_BASE_URL);
+    const server = createServer(client);
+    await startStdio(server);
+}
+main().catch((error) => {
+    console.error('Fatal error starting the oJo MCP server:', error);
+    process.exit(1);
+});

package/build/prompts/index.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Register the v1 guiding prompt that teaches oJo template semantics. */
+export declare function registerPrompts(server: McpServer): void;
+//# sourceMappingURL=index.d.ts.map

package/build/prompts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/prompts/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAkDzE,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CAiBvD"}

package/build/prompts/index.js

@@ -0,0 +1,61 @@
+// Handlebars helper catalog — keep in sync with
+// packages/libs/src/template/handlebars-helpers.ts (and the public docs at
+// apps/web/content/template-helpers.mdx). Drift here misleads the agent.
+const GUIDE = `# Authoring oJo templates
+
+You generate images from HTML. Two ways:
+- **One-off:** \`generate_image_from_html\` with plain HTML + inline CSS.
+- **Reusable:** \`create_template\` once, then \`generate_image_from_template\`
+  with a per-render **Modify Payload** that fills the placeholders.
+
+## Template Variables vs Modify Payload
+- **Template Variables** = the *schema/defaults* you pass to \`create_template\`
+  (the \`variables\` object). They are the shape of a template's inputs.
+- **Modify Payload** = the *data for one render*, passed as \`modify\` to
+  \`generate_image_from_template\`. Its keys override the variable defaults for
+  that single image. Use nested objects/arrays freely.
+
+## Placeholders
+Author placeholders in the HTML with Handlebars: \`{{title}}\`, \`{{user.name}}\`,
+\`{{#each items}}...{{/each}}\`, \`{{#if premium}}...{{/if}}\`.
+
+## Helper catalog (the only helpers available)
+- \`{{json value}}\` — value as a JSON string
+- \`{{array value}}\` — value as a JSON array string
+- \`{{eq a b}}\` / \`{{gt a b}}\` / \`{{lt a b}}\` — boolean comparisons
+- \`{{ternary cond yes no}}\` — pick yes/no by condition
+- \`{{formatDate dateString "YYYY-MM-DD"}}\` — dayjs formatting
+- \`{{isBefore date1 date2}}\` / \`{{isAfter date1 date2}}\` — date comparisons
+- \`{{math a "+" b}}\` — arithmetic; operators: + - * / %
+- \`{{round value decimals}}\` — fixed-decimal rounding
+- \`{{inc value}}\` / \`{{dec value}}\` — +1 / -1
+- \`{{concat a b c}}\` — concatenate strings
+- \`{{formatCurrency amount "USD" 0 2}}\` — Intl currency (min/max digits optional)
+- \`{{formatNumber number}}\` — Intl number formatting
+- \`{{uppercase s}}\` / \`{{lowercase s}}\` / \`{{capitalize s}}\` — case helpers
+- \`{{substring s start end}}\` — slice a string
+- \`{{len arr}}\` — array length
+- \`{{#times n}}...{{/times}}\` — repeat a block n times
+
+## Viewport & background
+Default viewport is 1280×800. Pass \`viewportWidth\`/\`viewportHeight\` to change it,
+and \`transparentBackground: true\` for a transparent (non-white) background.
+
+## Iterating
+Each generated image costs 1 credit and returns a public \`url\`. Pass
+\`inspect: true\` on a generate call to also get a small preview image back so you
+can see the render and refine the HTML before finalizing.`;
+/** Register the v1 guiding prompt that teaches oJo template semantics. */
+export function registerPrompts(server) {
+    server.registerPrompt('author_ojo_template', {
+        title: 'Author an oJo template',
+        description: 'Guidance for writing oJo templates: the Handlebars helper catalog, Template Variables vs Modify Payload, viewport conventions, and the inspect→iterate loop.',
+    }, () => ({
+        messages: [
+            {
+                role: 'user',
+                content: { type: 'text', text: GUIDE },
+            },
+        ],
+    }));
+}

package/build/server/index.d.ts

@@ -0,0 +1,8 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { OjoApiClient } from './ojo-client.js';
+/**
+ * Build a transport-agnostic McpServer wired to the given oJo API client.
+ * The transport (stdio for v1) is attached separately by the entrypoint.
+ */
+export declare function createServer(client: OjoApiClient): McpServer;
+//# sourceMappingURL=index.d.ts.map

package/build/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAQ5D"}

package/build/server/index.js

@@ -0,0 +1,16 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerTools } from '../tools/index.js';
+import { registerPrompts } from '../prompts/index.js';
+/**
+ * Build a transport-agnostic McpServer wired to the given oJo API client.
+ * The transport (stdio for v1) is attached separately by the entrypoint.
+ */
+export function createServer(client) {
+    const server = new McpServer({
+        name: 'ojo',
+        version: '0.1.0',
+    });
+    registerTools(server, client);
+    registerPrompts(server);
+    return server;
+}

package/build/server/ojo-client.d.ts

@@ -0,0 +1,76 @@
+export interface ViewportOptions {
+    viewportWidth?: number;
+    viewportHeight?: number;
+    transparentBackground?: boolean;
+}
+export interface GeneratedImage {
+    id: string;
+    imageUrl: string;
+    createdAt?: string;
+}
+export interface ListTemplatesParams {
+    page?: number;
+    pageSize?: number;
+    sort?: 'asc' | 'desc';
+}
+export interface TemplateSummary {
+    template_id: string;
+    name: string;
+    preview_url?: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface TemplateList {
+    items: TemplateSummary[];
+    totalItems: number;
+    totalPages: number;
+    currentPage: number;
+    pageSize: number;
+}
+export interface TemplateDetail {
+    id: string;
+    name: string;
+    /** Decoded (plain) HTML — the API returns it base64-encoded; decoded here. */
+    html: string;
+    variables: unknown;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreatedTemplate {
+    id: string;
+    message?: string;
+}
+/** Error from the oJo API carrying the HTTP status and an agent-readable message. */
+export declare class OjoApiError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+/**
+ * Thin HTTP client over the public oJo API (`/v1`). Authenticates with the
+ * user's oJo API key via `Authorization: Bearer <key>`. Never imports internal
+ * workspace packages — the boundary is HTTP only.
+ */
+export declare class OjoApiClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    constructor(apiKey: string, baseUrl?: string);
+    /**
+     * POST /image/html — render raw HTML. The server requires the Content-Type to
+     * be exactly `text/html` (a strict `!==` check), so it must not carry a charset.
+     */
+    createImageFromHtml(html: string, options?: ViewportOptions): Promise<GeneratedImage>;
+    /** POST /image/template — render an existing template, optionally overriding its variables. */
+    createImageFromTemplate(templateId: string, modify?: Record<string, unknown>, options?: ViewportOptions): Promise<GeneratedImage>;
+    /** GET /template — list the templates available to this account. */
+    listTemplates(params?: ListTemplatesParams): Promise<TemplateList>;
+    /** GET /template/:id — fetch one template; the API returns base64 html, decoded here. */
+    getTemplate(templateId: string): Promise<TemplateDetail>;
+    /** POST /template — create a template from plain HTML; the html is base64-encoded here. */
+    createTemplate(html: string, variables?: Record<string, unknown>): Promise<CreatedTemplate>;
+    private request;
+    private toError;
+    private describe;
+}
+/** The API may return a scheme-less hotlink (e.g. `ojousercontent.com/...`); make it absolute https. */
+export declare function toAbsoluteUrl(url: string): string;
+//# sourceMappingURL=ojo-client.d.ts.map

package/build/server/ojo-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ojo-client.d.ts","sourceRoot":"","sources":["../../src/server/ojo-client.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qBAAqB,CAAC,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,eAAe,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,qFAAqF;AACrF,qBAAa,WAAY,SAAQ,KAAK;aAElB,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EAC9B,OAAO,EAAE,MAAM;CAKlB;AAED;;;;GAIG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,MAAyB;IAK9D;;;OAGG;IACG,mBAAmB,CACvB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC;IAmB1B,+FAA+F;IACzF,uBAAuB,CAC3B,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACpC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC;IAmB1B,oEAAoE;IAC9D,aAAa,CAAC,MAAM,GAAE,mBAAwB,GAAG,OAAO,CAAC,YAAY,CAAC;IAa5E,yFAAyF;IACnF,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAW9D,2FAA2F;IACrF,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,OAAO,CAAC,eAAe,CAAC;YAcb,OAAO;YA8BP,OAAO;IAWrB,OAAO,CAAC,QAAQ;CAcjB;AAED,wGAAwG;AACxG,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD"}

package/build/server/ojo-client.js

@@ -0,0 +1,146 @@
+import { HEADER_TRANSPARENT_BACKGROUND, HEADER_VIEWPORT_HEIGHT, HEADER_VIEWPORT_WIDTH, OJO_API_BASE_URL, } from '../constants.js';
+/** Error from the oJo API carrying the HTTP status and an agent-readable message. */
+export class OjoApiError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'OjoApiError';
+    }
+}
+/**
+ * Thin HTTP client over the public oJo API (`/v1`). Authenticates with the
+ * user's oJo API key via `Authorization: Bearer <key>`. Never imports internal
+ * workspace packages — the boundary is HTTP only.
+ */
+export class OjoApiClient {
+    apiKey;
+    baseUrl;
+    constructor(apiKey, baseUrl = OJO_API_BASE_URL) {
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * POST /image/html — render raw HTML. The server requires the Content-Type to
+     * be exactly `text/html` (a strict `!==` check), so it must not carry a charset.
+     */
+    async createImageFromHtml(html, options = {}) {
+        const headers = { 'Content-Type': 'text/html' };
+        if (options.viewportWidth !== undefined) {
+            headers[HEADER_VIEWPORT_WIDTH] = String(options.viewportWidth);
+        }
+        if (options.viewportHeight !== undefined) {
+            headers[HEADER_VIEWPORT_HEIGHT] = String(options.viewportHeight);
+        }
+        if (options.transparentBackground) {
+            headers[HEADER_TRANSPARENT_BACKGROUND] = 'true';
+        }
+        const result = await this.request('/image/html', {
+            method: 'POST',
+            headers,
+            body: html,
+        });
+        return { ...result, imageUrl: toAbsoluteUrl(result.imageUrl) };
+    }
+    /** POST /image/template — render an existing template, optionally overriding its variables. */
+    async createImageFromTemplate(templateId, modify = {}, options = {}) {
+        const body = { templateId, modify };
+        if (options.viewportWidth !== undefined) {
+            body.viewportWidth = options.viewportWidth;
+        }
+        if (options.viewportHeight !== undefined) {
+            body.viewportHeight = options.viewportHeight;
+        }
+        if (options.transparentBackground !== undefined) {
+            body.transparentBackground = options.transparentBackground;
+        }
+        const result = await this.request('/image/template', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        return { ...result, imageUrl: toAbsoluteUrl(result.imageUrl) };
+    }
+    /** GET /template — list the templates available to this account. */
+    async listTemplates(params = {}) {
+        const query = new URLSearchParams();
+        if (params.page !== undefined)
+            query.set('page', String(params.page));
+        if (params.pageSize !== undefined) {
+            query.set('pageSize', String(params.pageSize));
+        }
+        if (params.sort !== undefined)
+            query.set('sort', params.sort);
+        const qs = query.toString();
+        return this.request(`/template${qs ? `?${qs}` : ''}`, {
+            method: 'GET',
+        });
+    }
+    /** GET /template/:id — fetch one template; the API returns base64 html, decoded here. */
+    async getTemplate(templateId) {
+        const record = await this.request(`/template/${encodeURIComponent(templateId)}`, { method: 'GET' });
+        return {
+            ...record,
+            html: Buffer.from(record.html, 'base64').toString('utf-8'),
+        };
+    }
+    /** POST /template — create a template from plain HTML; the html is base64-encoded here. */
+    async createTemplate(html, variables) {
+        const body = {
+            html: Buffer.from(html, 'utf-8').toString('base64'),
+        };
+        if (variables !== undefined) {
+            body.variables = variables;
+        }
+        return this.request('/template', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+    }
+    async request(path, init) {
+        let response;
+        try {
+            response = await fetch(`${this.baseUrl}${path}`, {
+                method: init.method,
+                headers: { ...init.headers, Authorization: `Bearer ${this.apiKey}` },
+                body: init.body,
+            });
+        }
+        catch (cause) {
+            const detail = cause instanceof Error ? cause.message : String(cause);
+            throw new OjoApiError(0, `Could not reach the oJo API at ${this.baseUrl}: ${detail}`);
+        }
+        if (!response.ok) {
+            throw await this.toError(response);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            return (await response.json());
+        }
+        return (await response.text());
+    }
+    async toError(response) {
+        const body = (await response.json().catch(() => null));
+        const serverMessage = body?.message ?? body?.error ?? response.statusText;
+        return new OjoApiError(response.status, this.describe(response.status, serverMessage));
+    }
+    describe(status, serverMessage) {
+        switch (status) {
+            case 401:
+                return 'Unauthorized — set OJO_API_KEY to a valid oJo API key (create one at https://ojo.so/dashboard/api).';
+            case 402:
+                return 'Out of credits — this oJo account has no remaining image credits.';
+            case 422:
+                return `The oJo API rejected the request: ${serverMessage}`;
+            case 429:
+                return 'Rate limited by the oJo API — slow down and retry shortly.';
+            default:
+                return `oJo API error ${status}: ${serverMessage}`;
+        }
+    }
+}
+/** The API may return a scheme-less hotlink (e.g. `ojousercontent.com/...`); make it absolute https. */
+export function toAbsoluteUrl(url) {
+    return /^https?:\/\//i.test(url) ? url : `https://${url}`;
+}

package/build/server/preview.d.ts

@@ -0,0 +1,12 @@
+export interface ImagePreview {
+    data: string;
+    mimeType: string;
+}
+/**
+ * Fetch a generated image from its public URL and downscale it locally to a
+ * small webp so it can be returned as inline MCP image content without bloating
+ * the agent's context. The public hotlink needs no auth and costs no credit.
+ */
+export declare function renderPreview(imageUrl: string): Promise<ImagePreview>;
+export type RenderPreview = typeof renderPreview;
+//# sourceMappingURL=preview.d.ts.map

package/build/server/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/server/preview.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAW3E;AAED,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC"}

package/build/server/preview.js

@@ -0,0 +1,18 @@
+import sharp from 'sharp';
+/**
+ * Fetch a generated image from its public URL and downscale it locally to a
+ * small webp so it can be returned as inline MCP image content without bloating
+ * the agent's context. The public hotlink needs no auth and costs no credit.
+ */
+export async function renderPreview(imageUrl) {
+    const response = await fetch(imageUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch image for preview (${response.status})`);
+    }
+    const input = Buffer.from(await response.arrayBuffer());
+    const output = await sharp(input)
+        .resize({ width: 512, withoutEnlargement: true })
+        .webp({ quality: 80 })
+        .toBuffer();
+    return { data: output.toString('base64'), mimeType: 'image/webp' };
+}

package/build/tools/handlers/image-handlers.d.ts

@@ -0,0 +1,7 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { OjoApiClient } from '../../server/ojo-client.js';
+import { type RenderPreview } from '../../server/preview.js';
+import type { GenerateImageFromHtmlArgs, GenerateImageFromTemplateArgs } from '../schema.js';
+export declare function makeGenerateImageFromHtml(client: OjoApiClient, preview?: RenderPreview): (args: GenerateImageFromHtmlArgs) => Promise<CallToolResult>;
+export declare function makeGenerateImageFromTemplate(client: OjoApiClient, preview?: RenderPreview): (args: GenerateImageFromTemplateArgs) => Promise<CallToolResult>;
+//# sourceMappingURL=image-handlers.d.ts.map

package/build/tools/handlers/image-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-handlers.d.ts","sourceRoot":"","sources":["../../../src/tools/handlers/image-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAEV,YAAY,EACb,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAiB,KAAK,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,KAAK,EACV,yBAAyB,EACzB,6BAA6B,EAC9B,MAAM,cAAc,CAAC;AAGtB,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,aAA6B,IAExB,MAAM,yBAAyB,KAAG,OAAO,CAAC,cAAc,CAAC,CASxE;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,aAA6B,IAGpC,MAAM,6BAA6B,KAClC,OAAO,CAAC,cAAc,CAAC,CAa3B"}

package/build/tools/handlers/image-handlers.js

@@ -0,0 +1,49 @@
+import { renderPreview } from '../../server/preview.js';
+import { toErrorResult } from '../result.js';
+export function makeGenerateImageFromHtml(client, preview = renderPreview) {
+    return async (args) => {
+        try {
+            const { html, inspect, ...viewport } = args;
+            const image = await client.createImageFromHtml(html, viewport);
+            return buildImageResult(image, inspect ?? false, preview);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    };
+}
+export function makeGenerateImageFromTemplate(client, preview = renderPreview) {
+    return async (args) => {
+        try {
+            const { templateId, modify, inspect, ...viewport } = args;
+            const image = await client.createImageFromTemplate(templateId, modify ?? {}, viewport);
+            return buildImageResult(image, inspect ?? false, preview);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    };
+}
+async function buildImageResult(image, inspect, preview) {
+    const content = [
+        { type: 'text', text: formatImage(image) },
+    ];
+    if (inspect) {
+        try {
+            const { data, mimeType } = await preview(image.imageUrl);
+            content.push({ type: 'image', data, mimeType });
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            content.push({ type: 'text', text: `(preview unavailable: ${detail})` });
+        }
+    }
+    return { content };
+}
+function formatImage(image) {
+    return [
+        'Image generated successfully.',
+        `id: ${image.id}`,
+        `url: ${image.imageUrl}`,
+    ].join('\n');
+}

package/build/tools/handlers/template-handlers.d.ts

@@ -0,0 +1,291 @@
+import type { OjoApiClient } from '../../server/ojo-client.js';
+import type { CreateTemplateArgs, GetTemplateArgs, ListTemplatesArgs } from '../schema.js';
+export declare function makeListTemplates(client: OjoApiClient): (args: ListTemplatesArgs) => Promise<{
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+}>;
+export declare function makeGetTemplate(client: OjoApiClient): (args: GetTemplateArgs) => Promise<{
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+}>;
+export declare function makeCreateTemplate(client: OjoApiClient): (args: CreateTemplateArgs) => Promise<{
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+}>;
+//# sourceMappingURL=template-handlers.d.ts.map

package/build/tools/handlers/template-handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"template-handlers.d.ts","sourceRoot":"","sources":["../../../src/tools/handlers/template-handlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,KAAK,EACV,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EAClB,MAAM,cAAc,CAAC;AAGtB,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,IACtC,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQtC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,YAAY,IACpC,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQpC;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,IACvC,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQvC"}

package/build/tools/handlers/template-handlers.js

@@ -0,0 +1,34 @@
+import { textResult, toErrorResult } from '../result.js';
+export function makeListTemplates(client) {
+    return async (args) => {
+        try {
+            const result = await client.listTemplates(args);
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    };
+}
+export function makeGetTemplate(client) {
+    return async (args) => {
+        try {
+            const result = await client.getTemplate(args.templateId);
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    };
+}
+export function makeCreateTemplate(client) {
+    return async (args) => {
+        try {
+            const result = await client.createTemplate(args.html, args.variables);
+            return textResult(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    };
+}

package/build/tools/index.d.ts

@@ -0,0 +1,5 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { OjoApiClient } from '../server/ojo-client.js';
+/** Register the Slice 0 + Slice 1 tool surface on an McpServer. */
+export declare function registerTools(server: McpServer, client: OjoApiClient): void;
+//# sourceMappingURL=index.d.ts.map

package/build/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAkB5D,mEAAmE;AACnE,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAsD3E"}

package/build/tools/index.js

@@ -0,0 +1,31 @@
+import { createTemplateSchema, generateImageFromHtmlSchema, generateImageFromTemplateSchema, getTemplateSchema, listTemplatesSchema, } from './schema.js';
+import { makeGenerateImageFromHtml, makeGenerateImageFromTemplate, } from './handlers/image-handlers.js';
+import { makeCreateTemplate, makeGetTemplate, makeListTemplates, } from './handlers/template-handlers.js';
+/** Register the Slice 0 + Slice 1 tool surface on an McpServer. */
+export function registerTools(server, client) {
+    server.registerTool('generate_image_from_html', {
+        title: 'Generate image from HTML',
+        description: 'Render plain HTML (with inline CSS) into a PNG and return its public URL. Costs 1 credit.',
+        inputSchema: generateImageFromHtmlSchema,
+    }, makeGenerateImageFromHtml(client));
+    server.registerTool('generate_image_from_template', {
+        title: 'Generate image from template',
+        description: 'Render an existing oJo template into a PNG, optionally overriding its variables via `modify`. Costs 1 credit.',
+        inputSchema: generateImageFromTemplateSchema,
+    }, makeGenerateImageFromTemplate(client));
+    server.registerTool('list_templates', {
+        title: 'List templates',
+        description: 'List the oJo templates available to this account.',
+        inputSchema: listTemplatesSchema,
+    }, makeListTemplates(client));
+    server.registerTool('get_template', {
+        title: 'Get template',
+        description: 'Fetch one oJo template by id, returning its decoded HTML and variable defaults.',
+        inputSchema: getTemplateSchema,
+    }, makeGetTemplate(client));
+    server.registerTool('create_template', {
+        title: 'Create template',
+        description: 'Create a reusable oJo template from plain HTML/Handlebars (with optional variable defaults). Does not cost a credit.',
+        inputSchema: createTemplateSchema,
+    }, makeCreateTemplate(client));
+}

package/build/tools/result.d.ts

@@ -0,0 +1,6 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function textResult(text: string): CallToolResult;
+export declare function errorResult(message: string): CallToolResult;
+/** Map any thrown value to an MCP error result the agent can read. */
+export declare function toErrorResult(error: unknown): CallToolResult;
+//# sourceMappingURL=result.d.ts.map

package/build/tools/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/tools/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGzE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAEvD;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAE3D;AAED,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CAM5D"}

package/build/tools/result.js

@@ -0,0 +1,15 @@
+import { OjoApiError } from '../server/ojo-client.js';
+export function textResult(text) {
+    return { content: [{ type: 'text', text }] };
+}
+export function errorResult(message) {
+    return { content: [{ type: 'text', text: message }], isError: true };
+}
+/** Map any thrown value to an MCP error result the agent can read. */
+export function toErrorResult(error) {
+    if (error instanceof OjoApiError) {
+        return errorResult(error.message);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return errorResult(`Unexpected error: ${message}`);
+}

package/build/tools/schema.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const generateImageFromHtmlSchema: {
+    html: z.ZodString;
+    viewportWidth: z.ZodOptional<z.ZodNumber>;
+    viewportHeight: z.ZodOptional<z.ZodNumber>;
+    transparentBackground: z.ZodOptional<z.ZodBoolean>;
+    inspect: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const generateImageFromTemplateSchema: {
+    templateId: z.ZodString;
+    modify: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    viewportWidth: z.ZodOptional<z.ZodNumber>;
+    viewportHeight: z.ZodOptional<z.ZodNumber>;
+    transparentBackground: z.ZodOptional<z.ZodBoolean>;
+    inspect: z.ZodOptional<z.ZodBoolean>;
+};
+export declare const listTemplatesSchema: {
+    page: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+};
+export declare const getTemplateSchema: {
+    templateId: z.ZodString;
+};
+export declare const createTemplateSchema: {
+    html: z.ZodString;
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+};
+export type GenerateImageFromHtmlArgs = z.infer<z.ZodObject<typeof generateImageFromHtmlSchema>>;
+export type GenerateImageFromTemplateArgs = z.infer<z.ZodObject<typeof generateImageFromTemplateSchema>>;
+export type ListTemplatesArgs = z.infer<z.ZodObject<typeof listTemplatesSchema>>;
+export type GetTemplateArgs = z.infer<z.ZodObject<typeof getTemplateSchema>>;
+export type CreateTemplateArgs = z.infer<z.ZodObject<typeof createTemplateSchema>>;
+//# sourceMappingURL=schema.d.ts.map

package/build/tools/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/tools/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA4BxB,eAAO,MAAM,2BAA2B;;;;;;CAUf,CAAC;AAE1B,eAAO,MAAM,+BAA+B;;;;;;;CAcnB,CAAC;AAE1B,eAAO,MAAM,mBAAmB;;;;CAiBP,CAAC;AAE1B,eAAO,MAAM,iBAAiB;;CAEL,CAAC;AAE1B,eAAO,MAAM,oBAAoB;;;CAYR,CAAC;AAE1B,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,CAAC,CAAC,SAAS,CAAC,OAAO,2BAA2B,CAAC,CAChD,CAAC;AACF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,CAAC,CAAC,SAAS,CAAC,OAAO,+BAA+B,CAAC,CACpD,CAAC;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC;AACjF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC;AAC7E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CACtC,CAAC,CAAC,SAAS,CAAC,OAAO,oBAAoB,CAAC,CACzC,CAAC"}

package/build/tools/schema.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+const viewportWidth = z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Viewport width in pixels (default 1280).');
+const viewportHeight = z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Viewport height in pixels (default 800).');
+const transparentBackground = z
+    .boolean()
+    .optional()
+    .describe('Render with a transparent background instead of white.');
+const inspect = z
+    .boolean()
+    .optional()
+    .describe('When true, also return a small downscaled preview image of the result so you can see it and iterate.');
+export const generateImageFromHtmlSchema = {
+    html: z
+        .string()
+        .describe('Plain HTML (with inline CSS) to render into an image. Do NOT base64-encode it.'),
+    viewportWidth,
+    viewportHeight,
+    transparentBackground,
+    inspect,
+};
+export const generateImageFromTemplateSchema = {
+    templateId: z
+        .string()
+        .describe('Id of an existing oJo template (from list_templates).'),
+    modify: z
+        .record(z.any())
+        .optional()
+        .describe('Modify Payload: per-render values that override the template variable defaults (merged over the defaults).'),
+    viewportWidth,
+    viewportHeight,
+    transparentBackground,
+    inspect,
+};
+export const listTemplatesSchema = {
+    page: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('1-based page number (default 1).'),
+    pageSize: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Number of templates per page (default 10).'),
+    sort: z
+        .enum(['asc', 'desc'])
+        .optional()
+        .describe('Sort by creation time, ascending or descending (default desc).'),
+};
+export const getTemplateSchema = {
+    templateId: z.string().describe('Id of the template to fetch.'),
+};
+export const createTemplateSchema = {
+    html: z
+        .string()
+        .describe('Plain HTML/Handlebars for the template, using {{variable}} placeholders. Do NOT base64-encode it.'),
+    variables: z
+        .record(z.any())
+        .optional()
+        .describe('Template Variables: the default values/shape for the template placeholders (the schema, not per-render data).'),
+};

package/build/transports/stdio.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function startStdio(server: McpServer): Promise<void>;
+//# sourceMappingURL=stdio.d.ts.map

package/build/transports/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/transports/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAGzE,wBAAsB,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAKjE"}

package/build/transports/stdio.js

@@ -0,0 +1,7 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+export async function startStdio(server) {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr so it never corrupts the stdout JSON-RPC stream.
+    console.error('oJo MCP server connected via stdio.');
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@ojodotso/mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for oJo — let AI agents generate images from HTML and templates via your oJo API key.",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ojo",
+    "screenshot",
+    "image-generation",
+    "html-to-image",
+    "ai",
+    "agent"
+  ],
+  "license": "MIT",
+  "author": "oJo",
+  "homepage": "https://github.com/ojodotso/ojo/tree/master/apps/mcp-server#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ojodotso/ojo.git",
+    "directory": "apps/mcp-server"
+  },
+  "bugs": {
+    "url": "https://github.com/ojodotso/ojo/issues"
+  },
+  "type": "module",
+  "bin": {
+    "ojo-mcp": "build/index.js"
+  },
+  "files": [
+    "build",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "dotenv": "^16.4.5",
+    "sharp": "^0.34.5",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.16.4",
+    "tsx": "^4.22.4",
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.6"
+  },
+  "scripts": {
+    "dev": "tsx watch ./src/index.ts",
+    "build": "tsc",
+    "start": "node build/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint . --max-warnings 0",
+    "depcheck": "depcheck",
+    "check": "tsc --noEmit -p tsconfig.test.json"
+  }
+}