@rvry/mcp 0.1.3 → 0.1.5

package/dist/index.js

@@ -13,6 +13,9 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { callTool } from './client.js';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const PKG_VERSION = require('../package.json').version;
 /** Cache original question per session for response enrichment */
 const questionCache = new Map();
 /**
@@ -198,7 +201,7 @@ async function main() {
         console.error('[rvry-mcp] Generate one at https://rvry.ai/dashboard');
         process.exit(1);
     }
-    const server = new Server({ name: 'RVRY', version: '0.1.0' }, { capabilities: { tools: {}, prompts: {} } });
+    const server = new Server({ name: 'RVRY', version: PKG_VERSION }, { capabilities: { tools: {}, prompts: {} } });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: TOOL_DEFS,
     }));

package/dist/setup.js

@@ -15,6 +15,9 @@ import { homedir } from 'os';
 import { createInterface } from 'readline';
 import { execSync } from 'child_process';
 import { platform } from 'os';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const PKG_VERSION = require('../package.json').version;
 const ENGINE_URL = 'https://engine.rvry.ai';
 const COMMAND_FILES = [
     'deepthink.md',
@@ -177,9 +180,6 @@ function openBrowser(url) {
         return false;
     }
 }
-/**
- * Check if the `claude` CLI is available in PATH.
- */
 function isClaudeCLIAvailable() {
     try {
         const cmd = platform() === 'win32' ? 'where claude' : 'which claude';
@@ -190,9 +190,6 @@ function isClaudeCLIAvailable() {
         return false;
     }
 }
-/**
- * Get the platform-specific Claude Desktop config file path.
- */
 function getDesktopConfigPath() {
     const plat = platform();
     if (plat === 'darwin') {
@@ -203,19 +200,10 @@ function getDesktopConfigPath() {
     }
     return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
 }
-/**
- * Check if Claude Desktop config directory exists (app is installed).
- */
 function isClaudeDesktopInstalled() {
     const configPath = getDesktopConfigPath();
-    const configDir = dirname(configPath);
-    return existsSync(configDir);
+    return existsSync(dirname(configPath));
 }
-/**
- * Configure Claude Desktop by merging RVRY into the existing config.
- * Creates the config file if it doesn't exist. Preserves other MCP servers.
- * Returns 'created' | 'updated' | 'unchanged' | 'error'.
- */
 function configureDesktop(token) {
     const configPath = getDesktopConfigPath();
     try {
@@ -232,29 +220,23 @@ function configureDesktop(token) {
                 config = {};
             }
         }
-        // Ensure mcpServers object exists
         if (!config.mcpServers || typeof config.mcpServers !== 'object') {
             config.mcpServers = {};
         }
         const servers = config.mcpServers;
-        const newEntry = RVRY_SERVER_ENTRY(token);
-        // Check if RVRY is already configured with the same token
         const existing = servers.RVRY;
         if (existing) {
             const existingEnv = existing.env;
-            if (existingEnv?.RVRY_TOKEN === token) {
+            if (existingEnv?.RVRY_TOKEN === token)
                 return 'unchanged';
-            }
         }
         const wasNew = !existing;
-        servers.RVRY = newEntry;
-        // Write config with clean formatting
+        servers.RVRY = RVRY_SERVER_ENTRY(token);
         const configDir = dirname(configPath);
-        if (!existsSync(configDir)) {
+        if (!existsSync(configDir))
             mkdirSync(configDir, { recursive: true });
-        }
         writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-        return wasNew ? 'created' : 'updated';
+        return wasNew ? 'ok' : 'updated';
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -262,27 +244,221 @@ function configureDesktop(token) {
         return 'error';
     }
 }
-/**
- * Register RVRY as an MCP server in Claude Code.
- * Removes existing registration first for idempotency.
- */
 function registerClaudeCode(token) {
     try {
-        // Remove existing (ignore error if not registered)
         try {
             execSync('claude mcp remove rvry', { stdio: 'pipe' });
         }
-        catch {
-            // Not registered yet, that's fine
-        }
-        // Add with token
+        catch { /* not registered */ }
         execSync(`claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx @rvry/mcp`, { stdio: 'inherit' });
-        return true;
+        return 'ok';
     }
     catch {
-        return false;
+        return 'error';
+    }
+}
+/**
+ * Write RVRY server entry into a generic MCP JSON config file.
+ * Used by clients that follow the Desktop-style config format (Codex, Gemini, etc.)
+ */
+function configureJsonMcp(configPath, token) {
+    try {
+        let config = {};
+        if (existsSync(configPath)) {
+            const raw = readFileSync(configPath, 'utf-8');
+            try {
+                config = JSON.parse(raw);
+            }
+            catch {
+                writeFileSync(configPath + '.backup', raw, 'utf-8');
+                config = {};
+            }
+        }
+        if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+            config.mcpServers = {};
+        }
+        const servers = config.mcpServers;
+        const existing = servers.RVRY;
+        if (existing) {
+            const existingEnv = existing.env;
+            if (existingEnv?.RVRY_TOKEN === token)
+                return 'unchanged';
+        }
+        const wasNew = !existing;
+        servers.RVRY = RVRY_SERVER_ENTRY(token);
+        const dir = dirname(configPath);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        return wasNew ? 'ok' : 'updated';
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`  Error writing config: ${msg}`);
+        return 'error';
     }
 }
+/** All supported clients. Add new clients here. */
+const CLIENT_REGISTRY = [
+    {
+        name: 'Claude Code',
+        id: 'code',
+        detect: isClaudeCLIAvailable,
+        configure: registerClaudeCode,
+        notInstalledHint: 'CLI not found (https://docs.anthropic.com/en/docs/claude-code)',
+    },
+    {
+        name: 'Claude Desktop / Claude Co-Work',
+        id: 'desktop',
+        detect: isClaudeDesktopInstalled,
+        configure: (token) => configureDesktop(token),
+        notInstalledHint: 'Not installed',
+    },
+    {
+        name: 'Anti-Gravity',
+        id: 'antigravity',
+        detect: () => {
+            // OR-logic: binary (agy or antigravity), config dir, or macOS app bundle
+            try {
+                const cmd = platform() === 'win32' ? 'where agy' : 'which agy';
+                execSync(cmd, { stdio: 'pipe' });
+                return true;
+            }
+            catch { /* not on PATH */ }
+            if (platform() !== 'win32') {
+                try {
+                    execSync('which antigravity', { stdio: 'pipe' });
+                    return true;
+                }
+                catch { /* not on PATH */ }
+            }
+            if (existsSync(join(homedir(), '.gemini', 'antigravity')))
+                return true;
+            if (platform() === 'darwin' && existsSync('/Applications/Google Antigravity.app'))
+                return true;
+            return false;
+        },
+        configure: (token) => configureJsonMcp(join(homedir(), '.gemini', 'antigravity', 'mcp_config.json'), token),
+        notInstalledHint: 'Not installed (https://antigravity.google)',
+    },
+];
+/**
+ * Interactive multi-select picker with arrow keys + space + enter.
+ * Returns indices of selected items.
+ */
+function multiSelect(items) {
+    return new Promise((resolve) => {
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        if (typeof stdin.setRawMode === 'function')
+            stdin.setRawMode(true);
+        stdin.resume();
+        stdin.setEncoding('utf8');
+        let cursor = items.findIndex((i) => i.available);
+        if (cursor === -1)
+            cursor = 0;
+        const render = () => {
+            // Move cursor up to overwrite previous render (except first render)
+            for (let i = 0; i < items.length; i++) {
+                process.stdout.write('\x1b[2K'); // clear line
+                if (i < items.length - 1)
+                    process.stdout.write('\x1b[1A'); // move up
+            }
+            process.stdout.write('\r');
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const pointer = i === cursor ? '›' : ' ';
+                const checkbox = !item.available
+                    ? '\x1b[2m[ ]\x1b[0m'
+                    : item.selected
+                        ? '\x1b[32m[x]\x1b[0m'
+                        : '[ ]';
+                const label = !item.available
+                    ? `\x1b[2m${item.label}\x1b[0m`
+                    : item.label;
+                const hint = !item.available && item.hint
+                    ? `  \x1b[2m${item.hint}\x1b[0m`
+                    : '';
+                process.stdout.write(`  ${pointer} ${checkbox} ${label}${hint}`);
+                if (i < items.length - 1)
+                    process.stdout.write('\n');
+            }
+        };
+        // Initial render: print blank lines then render
+        for (let i = 0; i < items.length; i++) {
+            process.stdout.write(i < items.length - 1 ? '\n' : '');
+        }
+        render();
+        const cleanup = () => {
+            if (typeof stdin.setRawMode === 'function')
+                stdin.setRawMode(wasRaw ?? false);
+            stdin.removeListener('data', onData);
+            stdin.pause();
+        };
+        const onData = (key) => {
+            // Ctrl+C
+            if (key === '\x03') {
+                cleanup();
+                process.stdout.write('\n');
+                process.exit(1);
+            }
+            // Enter — confirm selection
+            if (key === '\r' || key === '\n') {
+                cleanup();
+                process.stdout.write('\n');
+                const selected = [];
+                for (let i = 0; i < items.length; i++) {
+                    if (items[i].selected && items[i].available)
+                        selected.push(i);
+                }
+                resolve(selected);
+                return;
+            }
+            // Space — toggle current item
+            if (key === ' ') {
+                if (items[cursor].available) {
+                    items[cursor].selected = !items[cursor].selected;
+                    render();
+                }
+                return;
+            }
+            // Arrow keys (escape sequences)
+            if (key === '\x1b[A' || key === 'k') {
+                // Up
+                let next = cursor - 1;
+                while (next >= 0 && !items[next].available)
+                    next--;
+                if (next >= 0) {
+                    cursor = next;
+                    render();
+                }
+                return;
+            }
+            if (key === '\x1b[B' || key === 'j') {
+                // Down
+                let next = cursor + 1;
+                while (next < items.length && !items[next].available)
+                    next++;
+                if (next < items.length) {
+                    cursor = next;
+                    render();
+                }
+                return;
+            }
+            // 'a' — select all available
+            if (key === 'a') {
+                const allSelected = items.filter((i) => i.available).every((i) => i.selected);
+                for (const item of items) {
+                    if (item.available)
+                        item.selected = !allSelected;
+                }
+                render();
+                return;
+            }
+        };
+        stdin.on('data', onData);
+    });
+}
 /**
  * Verify token by hitting the engine /api/usage endpoint.
  * Returns tier info on success, null on failure.
@@ -454,16 +630,18 @@ async function installCommands() {
 }
 // ── Main setup flow ────────────────────────────────────────────────
 const BANNER = `
- _____ __      __ _____ __     __
-|  __ \\\\ \\\\    / /|  __ \\\\ \\\\   / /
-| |__) |\\\\ \\\\  / / | |__) |\\\\ \\\\_/ /
-|  _  /  \\\\ \\\\/ /  |  _  /  \\\\   /
-| | \\\\ \\\\   \\\\  /   | | \\\\ \\\\   | |
-|_|  \\\\_\\\\   \\\\/    |_|  \\\\_\\\\  |_|
+8888888b.  888     888 8888888b. Y88b   d88P
+888   Y88b 888     888 888   Y88b Y88b d88P
+888    888 888     888 888    888  Y88o88P
+888   d88P Y88b   d88P 888   d88P   Y888P
+8888888P"   Y88b d88P  8888888P"     888
+888 T88b     Y88o88P   888 T88b      888
+888  T88b     Y888P    888  T88b     888
+888   T88b     Y8P     888   T88b    888
 `;
 export async function runSetup() {
     console.log(BANNER);
-    console.log('Setup');
+    console.log(`Setup v${PKG_VERSION}`);
     console.log('');
     // Parse flags
     const tokenFlagIndex = process.argv.indexOf('--token');
@@ -517,93 +695,68 @@ export async function runSetup() {
     }
     console.log('');
     // ── Step 2: Detect clients ──────────────────────────────────────
-    console.log('[2/4] Detecting Claude clients');
-    const hasClaudeCode = isClaudeCLIAvailable();
-    const hasDesktop = isClaudeDesktopInstalled();
-    const desktopConfigPath = getDesktopConfigPath();
-    const wantCode = !clientFilter || clientFilter === 'code';
-    const wantDesktop = !clientFilter || clientFilter === 'desktop';
-    if (hasClaudeCode && wantCode) {
-        console.log('  Found: Claude Code (claude CLI)');
-    }
-    if (hasDesktop && wantDesktop) {
-        console.log(`  Found: Claude Desktop (${desktopConfigPath})`);
+    console.log('[2/4] Detecting clients');
+    // Filter registry if --client was passed
+    const clients = clientFilter
+        ? CLIENT_REGISTRY.filter((c) => c.id === clientFilter)
+        : CLIENT_REGISTRY;
+    const detected = clients.map((c) => ({
+        client: c,
+        available: c.detect(),
+    }));
+    const anyDetected = detected.some((d) => d.available);
+    for (const d of detected) {
+        if (d.available) {
+            console.log(`  Found: ${d.client.name}`);
+        }
     }
-    if (!hasClaudeCode && !hasDesktop) {
-        console.log('  No Claude clients detected.');
+    if (!anyDetected) {
+        console.log('  No supported clients detected.');
     }
     console.log('');
     // ── Step 3: Configure clients ───────────────────────────────────
-    console.log('[3/4] Client Configuration');
-    let codeConfigured = false;
-    let desktopConfigured = 'skipped';
-    let neitherConfigured = true;
-    // Claude Code
-    if (hasClaudeCode && wantCode) {
-        const rl = createRL();
-        const answer = await ask(rl, '  Install for Claude Code? [Y/n] ');
-        rl.close();
-        if (answer.toLowerCase() !== 'n') {
-            const success = registerClaudeCode(token);
-            if (success) {
-                codeConfigured = true;
-                neitherConfigured = false;
-                console.log('  Claude Code:    Registered (user scope -- works in all projects)');
-            }
-            else {
-                console.log('  Claude Code:    Failed to register via CLI');
-            }
-        }
-        else {
-            console.log('  Claude Code:    Skipped');
-        }
-    }
-    else if (wantCode && !hasClaudeCode) {
-        console.log('  Claude Code:    CLI not found (install: https://docs.anthropic.com/en/docs/claude-code)');
-    }
-    // Claude Desktop / Co-Work
-    if (hasDesktop && wantDesktop) {
-        const rl = createRL();
-        const answer = await ask(rl, '  Install for Claude Desktop / Co-Work? [Y/n] ');
-        rl.close();
-        if (answer.toLowerCase() !== 'n') {
-            desktopConfigured = configureDesktop(token);
-            switch (desktopConfigured) {
-                case 'created':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Added RVRY to config');
-                    break;
-                case 'updated':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Updated RVRY token in config');
-                    break;
-                case 'unchanged':
-                    neitherConfigured = false;
-                    console.log('  Claude Desktop: Already configured with this token');
-                    break;
-                case 'error':
-                    console.log('  Claude Desktop: Failed to write config (see error above)');
-                    break;
-            }
-        }
-        else {
-            console.log('  Claude Desktop: Skipped');
-        }
+    console.log('[3/4] Select apps to add RVRY MCP configuration');
+    console.log('  Use \x1b[1m↑↓\x1b[0m to navigate, \x1b[1mspace\x1b[0m to toggle, \x1b[1ma\x1b[0m to toggle all, \x1b[1menter\x1b[0m to confirm');
+    console.log('');
+    const pickerItems = detected.map((d) => ({
+        label: d.client.name,
+        selected: d.available, // pre-select detected clients
+        available: d.available,
+        hint: d.available ? undefined : d.client.notInstalledHint,
+    }));
+    const selectedIndices = await multiSelect(pickerItems);
+    const configuredClients = [];
+    let anyConfigured = false;
+    console.log('');
+    for (const idx of selectedIndices) {
+        const { client } = detected[idx];
+        const result = client.configure(token);
+        const statusMap = {
+            ok: 'Configured',
+            updated: 'Updated token',
+            unchanged: 'Already configured',
+            error: 'Failed',
+        };
+        const status = statusMap[result] ?? result;
+        const icon = result === 'error' ? '✗' : '✓';
+        console.log(`  ${icon} ${client.name}: ${status}`);
+        configuredClients.push({ name: client.name, status });
+        if (result !== 'error')
+            anyConfigured = true;
     }
-    else if (wantDesktop && !hasDesktop) {
-        console.log('  Claude Desktop: Not installed');
+    if (selectedIndices.length === 0) {
+        console.log('  No clients selected.');
     }
     // Fallback: print manual config if nothing was configured
-    if (neitherConfigured) {
+    if (!anyConfigured) {
         console.log('');
         console.log('  Manual configuration:');
         console.log('');
         console.log('  Option A — Claude Code (if you install it later):');
         console.log(`    claude mcp add -e RVRY_TOKEN="${token}" -s user rvry -- npx @rvry/mcp`);
         console.log('');
-        console.log('  Option B — Claude Desktop config JSON:');
+        console.log('  Option B — JSON config (Claude Desktop, Codex, etc.):');
         const manualConfig = { mcpServers: { RVRY: RVRY_SERVER_ENTRY(token) } };
-        console.log(`    File: ${desktopConfigPath}`);
         console.log('');
         for (const line of JSON.stringify(manualConfig, null, 2).split('\n')) {
             console.log(`    ${line}`);
@@ -626,35 +779,36 @@ export async function runSetup() {
     console.log('RVRY Setup Complete');
     console.log('');
     console.log(`  Token:          ${maskToken(token)}${usage ? ` (${usage.tier})` : ''}`);
-    if (codeConfigured) {
-        console.log('  Claude Code:    Configured');
-    }
-    if (desktopConfigured !== 'skipped' && desktopConfigured !== 'error') {
-        console.log('  Claude Desktop: Configured');
+    for (const c of configuredClients) {
+        const pad = ' '.repeat(Math.max(1, 16 - c.name.length));
+        console.log(`  ${c.name}:${pad}${c.status}`);
     }
     console.log(`  Commands:       ${commandCount} installed`);
     console.log('');
     // Client-specific next steps
+    const configuredNames = new Set(configuredClients.map((c) => c.name));
+    const hasDesktopStyle = configuredNames.has('Claude Desktop / Claude Co-Work')
+        || configuredNames.has('Anti-Gravity');
+    const hasCodeStyle = configuredNames.has('Claude Code');
     console.log('Next steps:');
-    const desktopOk = desktopConfigured !== 'skipped' && desktopConfigured !== 'error';
     let step = 1;
-    if (desktopOk) {
-        console.log(`  ${step}. Restart Claude Desktop for the new MCP server to load`);
+    if (hasDesktopStyle) {
+        console.log(`  ${step}. Restart desktop apps for the new MCP server to load`);
         step++;
     }
-    if (codeConfigured) {
+    if (hasCodeStyle) {
         console.log(`  ${step}. In Claude Code, try:`);
         console.log('     /deepthink "your question"');
         console.log('     /problem-solve "your decision"');
         step++;
     }
-    if (desktopOk) {
-        console.log(`  ${step}. In Claude Desktop, use natural language:`);
+    if (hasDesktopStyle) {
+        console.log(`  ${step}. In desktop clients, use natural language:`);
         console.log('     "Use deepthink to analyze..." or "Use problem-solve for..."');
         step++;
     }
-    if (!codeConfigured && !desktopOk) {
-        console.log('  1. Configure a Claude client using the manual instructions above');
+    if (!anyConfigured) {
+        console.log('  1. Configure a client using the manual instructions above');
         console.log('  2. Then try: /deepthink "your question"');
     }
     console.log('');

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {
-    "rvry-mcp": "./dist/index.js"
+    "rvry-mcp": "dist/index.js"
   },
   "main": "./dist/index.js",
   "files": [