@ompo-design/mcp-server 0.1.6 → 0.1.9

package/dist/cli.js

@@ -4,7 +4,10 @@ import { homedir } from 'os';
 import { join, resolve } from 'path';
 import { editsStoreReady } from './edit-store.js';
 import { getOmpoEditsStorePath } from './edits-path.js';
+import { readOmpoMcpSession } from './session.js';
+import { readMcpTokenBalance } from './tokens.js';
 const PACKAGE_NAME = '@ompo-design/mcp-server';
+const PACKAGE_VERSION = '0.1.9';
 const SERVER_NAME = 'ompo';
 function resolveExecutable(name) {
     try {
@@ -85,7 +88,7 @@ export function runCli(argv) {
         return true;
     }
     if (command === 'doctor') {
-        runDoctor();
+        void runDoctor();
         return true;
     }
     if (command === 'help' || command === '--help' || command === '-h') {
@@ -123,7 +126,7 @@ function runGlobalSetup() {
     console.log('  5. In Ompo, click Send on an edit before using the tools');
     console.log(`     Edits are stored in ${getOmpoEditsStorePath()}`);
 }
-function runDoctor() {
+async function runDoctor() {
     const projectRoot = resolve(process.cwd());
     const configPath = join(projectRoot, '.mcp.json');
     const desktopPath = claudeDesktopConfigPath();
@@ -131,6 +134,7 @@ function runDoctor() {
     const storePath = getOmpoEditsStorePath();
     console.log('Ompo MCP doctor');
     console.log('');
+    console.log(`Package version: ${PACKAGE_VERSION}`);
     console.log(`Current folder: ${projectRoot}`);
     console.log(`Node: ${process.version}`);
     console.log(`npx: ${resolveExecutable('npx')}`);
@@ -156,6 +160,26 @@ function runDoctor() {
         }
     }
     console.log('');
+    const session = readOmpoMcpSession();
+    if (!session) {
+        console.log('Session: missing (open Ompo, sign in, and keep the app running)');
+    }
+    else {
+        console.log(`Session: ready for user ${session.userId}`);
+        console.log(`Session updated: ${session.updatedAt}`);
+        if (!session.refreshToken) {
+            console.log('Session: missing refresh token (restart Ompo after updating)');
+        }
+        try {
+            const balance = await readMcpTokenBalance();
+            console.log(`Tokens: ${balance ?? 'unknown'} available`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'unknown error';
+            console.log(`Tokens: could not read balance (${message})`);
+        }
+    }
+    console.log('');
     if (editsStoreReady()) {
         console.log('Edits: ready (Send from Ompo to add more)');
     }
@@ -163,6 +187,7 @@ function runDoctor() {
         console.log('Edits: none yet (click Send in Ompo first)');
     }
     console.log('');
+    console.log('If tools skip token usage, quit and reopen Claude Code to reload MCP v0.1.9+');
     console.log('Global install: npx @ompo-design/mcp-server setup-global');
 }
 function printProjectNextSteps(projectRoot) {

package/dist/edit-billing.d.ts

@@ -0,0 +1,2 @@
+export declare function consumeMcpTokenForEdit(toolName: string, editId: string): Promise<number>;
+export declare function requireMcpSessionBalance(): Promise<number>;

package/dist/edit-billing.js

@@ -0,0 +1,75 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import { consumeMcpToken, McpTokenError, readMcpTokenBalance } from './tokens.js';
+import { readOmpoMcpSession } from './session.js';
+function requireSignedIn() {
+    if (!readOmpoMcpSession()) {
+        throw new McpTokenError('NOT_SIGNED_IN', 'Sign in to Ompo and keep the app open so your MCP session stays active.');
+    }
+}
+const BILLING_TTL_MS = 24 * 60 * 60 * 1000;
+function getEditBillingPath() {
+    return join(homedir(), '.ompo', 'edit-billing.json');
+}
+function readBillingState() {
+    const billingPath = getEditBillingPath();
+    if (!existsSync(billingPath)) {
+        return { billedEdits: {} };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(billingPath, 'utf8'));
+        return {
+            billedEdits: typeof parsed.billedEdits === 'object' && parsed.billedEdits !== null
+                ? parsed.billedEdits
+                : {}
+        };
+    }
+    catch {
+        return { billedEdits: {} };
+    }
+}
+function writeBillingState(state) {
+    const billingPath = getEditBillingPath();
+    mkdirSync(dirname(billingPath), { recursive: true });
+    writeFileSync(billingPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+function pruneExpiredBilledEdits(billedEdits) {
+    const now = Date.now();
+    const pruned = {};
+    for (const [editId, billedAt] of Object.entries(billedEdits)) {
+        const billedTime = Date.parse(billedAt);
+        if (Number.isNaN(billedTime))
+            continue;
+        if (now - billedTime <= BILLING_TTL_MS) {
+            pruned[editId] = billedAt;
+        }
+    }
+    return pruned;
+}
+function isEditAlreadyBilled(editId) {
+    const state = readBillingState();
+    const billedEdits = pruneExpiredBilledEdits(state.billedEdits);
+    return editId in billedEdits;
+}
+function markEditBilled(editId) {
+    const state = readBillingState();
+    const billedEdits = pruneExpiredBilledEdits(state.billedEdits);
+    billedEdits[editId] = new Date().toISOString();
+    writeBillingState({ billedEdits });
+}
+export async function consumeMcpTokenForEdit(toolName, editId) {
+    requireSignedIn();
+    if (isEditAlreadyBilled(editId)) {
+        const balance = await readMcpTokenBalance();
+        return balance ?? 0;
+    }
+    const tokensRemaining = await consumeMcpToken(toolName);
+    markEditBilled(editId);
+    return tokensRemaining;
+}
+export async function requireMcpSessionBalance() {
+    requireSignedIn();
+    const balance = await readMcpTokenBalance();
+    return balance ?? 0;
+}

package/dist/index.js

@@ -4,11 +4,13 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod';
 import { buildApplyPlan, explainEdit } from './apply-plan.js';
 import { runCli } from './cli.js';
+import { consumeMcpTokenForEdit, requireMcpSessionBalance } from './edit-billing.js';
 import { editsStoreReady, listEdits, readEditBundle, recordEditApplied, recordEditPull } from './edit-store.js';
 import { getOmpoEditsStorePath } from './edits-path.js';
+import { McpTokenError } from './tokens.js';
 const server = new McpServer({
     name: 'ompo-mcp-server',
-    version: '0.1.6'
+    version: '0.1.9'
 });
 function requireEditsStore() {
     const storePath = getOmpoEditsStorePath();
@@ -17,47 +19,85 @@ function requireEditsStore() {
     }
     return storePath;
 }
-server.tool('list_edits', 'List Ompo edit bundles saved on this machine', {}, async () => {
-    const storePath = requireEditsStore();
-    const edits = listEdits();
+async function withMcpTokenUseForEdit(toolName, editId, handler) {
+    const tokensRemaining = await consumeMcpTokenForEdit(toolName, editId);
+    return handler(tokensRemaining);
+}
+function tokenErrorResult(error) {
+    const message = error instanceof McpTokenError
+        ? error.message
+        : 'Could not verify MCP token balance. Check your connection and try again.';
     return {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({ storePath, edits }, null, 2)
+                text: message
             }
-        ]
+        ],
+        isError: true
     };
+}
+server.tool('list_edits', 'List Ompo edit bundles saved on this machine', {}, async () => {
+    try {
+        const storePath = requireEditsStore();
+        const edits = listEdits();
+        const tokensRemaining = await requireMcpSessionBalance();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({ storePath, edits, tokensRemaining }, null, 2)
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return tokenErrorResult(error);
+    }
 });
 server.tool('get_edit', 'Load a specific Ompo edit bundle by id', {
     id: z.string().describe('Edit id, e.g. ed_8K42P')
 }, async ({ id }) => {
-    requireEditsStore();
-    const bundle = readEditBundle(id);
-    recordEditPull(id);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(bundle, null, 2)
-            }
-        ]
-    };
+    try {
+        return await withMcpTokenUseForEdit('get_edit', id, async (tokensRemaining) => {
+            requireEditsStore();
+            const bundle = readEditBundle(id);
+            recordEditPull(id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${JSON.stringify(bundle, null, 2)}\n\nTokens remaining: ${tokensRemaining}`
+                    }
+                ]
+            };
+        });
+    }
+    catch (error) {
+        return tokenErrorResult(error);
+    }
 });
 server.tool('explain_edit', 'Summarize what an Ompo edit changes', {
     id: z.string().describe('Edit id, e.g. ed_8K42P')
 }, async ({ id }) => {
-    requireEditsStore();
-    const bundle = readEditBundle(id);
-    recordEditPull(id);
-    return {
-        content: [
-            {
-                type: 'text',
-                text: explainEdit(bundle)
-            }
-        ]
-    };
+    try {
+        return await withMcpTokenUseForEdit('explain_edit', id, async (tokensRemaining) => {
+            requireEditsStore();
+            const bundle = readEditBundle(id);
+            recordEditPull(id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `${explainEdit(bundle)}\n\nTokens remaining: ${tokensRemaining}`
+                    }
+                ]
+            };
+        });
+    }
+    catch (error) {
+        return tokenErrorResult(error);
+    }
 });
 server.tool('apply_edit', 'Build an apply plan for an Ompo edit. The agent should execute the plan against source files in the open codebase and only change listed properties.', {
     id: z.string().describe('Edit id, e.g. ed_8K42P'),
@@ -66,21 +106,28 @@ server.tool('apply_edit', 'Build an apply plan for an Ompo edit. The agent shoul
         .optional()
         .describe('Set true after the agent successfully applies the edit')
 }, async ({ id, markApplied }) => {
-    requireEditsStore();
-    const bundle = readEditBundle(id);
-    recordEditPull(id);
-    const plan = buildApplyPlan(bundle);
-    if (markApplied) {
-        recordEditApplied(id);
-    }
-    return {
-        content: [
-            {
-                type: 'text',
-                text: JSON.stringify(plan, null, 2)
+    try {
+        return await withMcpTokenUseForEdit('apply_edit', id, async (tokensRemaining) => {
+            requireEditsStore();
+            const bundle = readEditBundle(id);
+            recordEditPull(id);
+            const plan = buildApplyPlan(bundle);
+            if (markApplied) {
+                recordEditApplied(id);
             }
-        ]
-    };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ ...plan, tokensRemaining }, null, 2)
+                    }
+                ]
+            };
+        });
+    }
+    catch (error) {
+        return tokenErrorResult(error);
+    }
 });
 async function main() {
     if (runCli(process.argv.slice(2)))

package/dist/session.d.ts

@@ -0,0 +1,11 @@
+export type OmpoMcpSession = {
+    userId: string;
+    accessToken: string;
+    refreshToken?: string;
+    supabaseUrl: string;
+    supabaseAnonKey: string;
+    updatedAt: string;
+};
+export declare function getOmpoMcpSessionPath(): string;
+export declare function readOmpoMcpSession(): OmpoMcpSession | null;
+export declare function writeOmpoMcpSession(session: OmpoMcpSession): void;

package/dist/session.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+export function getOmpoMcpSessionPath() {
+    return join(homedir(), '.ompo', 'session.json');
+}
+export function readOmpoMcpSession() {
+    const sessionPath = getOmpoMcpSessionPath();
+    if (!existsSync(sessionPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(sessionPath, 'utf8'));
+        if (typeof parsed.userId !== 'string' ||
+            typeof parsed.accessToken !== 'string' ||
+            typeof parsed.supabaseUrl !== 'string' ||
+            typeof parsed.supabaseAnonKey !== 'string') {
+            return null;
+        }
+        return {
+            userId: parsed.userId,
+            accessToken: parsed.accessToken,
+            refreshToken: typeof parsed.refreshToken === 'string' ? parsed.refreshToken : undefined,
+            supabaseUrl: parsed.supabaseUrl,
+            supabaseAnonKey: parsed.supabaseAnonKey,
+            updatedAt: typeof parsed.updatedAt === 'string' ? parsed.updatedAt : new Date(0).toISOString()
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function writeOmpoMcpSession(session) {
+    const sessionPath = getOmpoMcpSessionPath();
+    mkdirSync(dirname(sessionPath), { recursive: true });
+    writeFileSync(sessionPath, `${JSON.stringify({ ...session, updatedAt: new Date().toISOString() }, null, 2)}\n`, 'utf8');
+}

package/dist/tokens.d.ts

@@ -0,0 +1,6 @@
+export declare class McpTokenError extends Error {
+    code: 'NOT_SIGNED_IN' | 'INSUFFICIENT_TOKENS' | 'TOKEN_SERVICE_UNAVAILABLE';
+    constructor(code: McpTokenError['code'], message: string);
+}
+export declare function readMcpTokenBalance(): Promise<number | null>;
+export declare function consumeMcpToken(toolName: string): Promise<number>;

package/dist/tokens.js

@@ -0,0 +1,90 @@
+import { createClient } from '@supabase/supabase-js';
+import { readOmpoMcpSession, writeOmpoMcpSession } from './session.js';
+export class McpTokenError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'McpTokenError';
+        this.code = code;
+    }
+}
+function mapRpcError(message) {
+    const normalized = message.toUpperCase();
+    if (normalized.includes('NOT_AUTHENTICATED') || normalized.includes('JWT')) {
+        return new McpTokenError('NOT_SIGNED_IN', 'Sign in to Ompo and keep the app open so your MCP session stays active.');
+    }
+    if (normalized.includes('INSUFFICIENT_TOKENS')) {
+        return new McpTokenError('INSUFFICIENT_TOKENS', 'You are out of MCP tokens. Add more tokens to your account before using Ompo MCP tools.');
+    }
+    return new McpTokenError('TOKEN_SERVICE_UNAVAILABLE', 'Could not verify MCP token balance. Check your connection and try again.');
+}
+async function createAuthedSupabase(session) {
+    const supabase = createClient(session.supabaseUrl, session.supabaseAnonKey, {
+        auth: {
+            persistSession: false,
+            autoRefreshToken: false,
+            detectSessionInUrl: false
+        }
+    });
+    if (session.refreshToken) {
+        const { data, error } = await supabase.auth.setSession({
+            access_token: session.accessToken,
+            refresh_token: session.refreshToken
+        });
+        if (!error && data.session) {
+            if (data.session.access_token !== session.accessToken ||
+                data.session.refresh_token !== session.refreshToken) {
+                writeOmpoMcpSession({
+                    ...session,
+                    accessToken: data.session.access_token,
+                    refreshToken: data.session.refresh_token
+                });
+            }
+            return supabase;
+        }
+    }
+    return createClient(session.supabaseUrl, session.supabaseAnonKey, {
+        auth: {
+            persistSession: false,
+            autoRefreshToken: false,
+            detectSessionInUrl: false
+        },
+        global: {
+            headers: {
+                Authorization: `Bearer ${session.accessToken}`
+            }
+        }
+    });
+}
+export async function readMcpTokenBalance() {
+    const session = readOmpoMcpSession();
+    if (!session)
+        return null;
+    const supabase = await createAuthedSupabase(session);
+    const { data, error } = await supabase
+        .from('user_token_balances')
+        .select('tokens_available')
+        .eq('user_id', session.userId)
+        .maybeSingle();
+    if (error)
+        throw mapRpcError(error.message);
+    return data?.tokens_available ?? null;
+}
+export async function consumeMcpToken(toolName) {
+    const session = readOmpoMcpSession();
+    if (!session) {
+        throw new McpTokenError('NOT_SIGNED_IN', 'Sign in to Ompo and keep the app open so your MCP session stays active.');
+    }
+    const supabase = await createAuthedSupabase(session);
+    const { data, error } = await supabase.rpc('consume_mcp_token', {
+        p_tool_name: toolName
+    });
+    if (error) {
+        throw mapRpcError(error.message);
+    }
+    const tokensRemaining = data?.tokens_remaining;
+    if (typeof tokensRemaining !== 'number') {
+        throw new McpTokenError('TOKEN_SERVICE_UNAVAILABLE', 'Could not verify MCP token balance. Check your connection and try again.');
+    }
+    return tokensRemaining;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ompo-design/mcp-server",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "MCP server for applying Ompo visual edits to a codebase",
   "type": "module",
   "license": "MIT",
@@ -12,7 +12,7 @@
     "claude-code"
   ],
   "bin": {
-    "ompo-mcp": "./dist/index.js"
+    "ompo-mcp": "dist/index.js"
   },
   "main": "./dist/index.js",
   "files": [
@@ -25,6 +25,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "@supabase/supabase-js": "^2.49.8",
     "zod": "^3.24.2"
   },
   "devDependencies": {