@rvry/mcp 0.1.0 → 0.1.2

package/README.md

@@ -6,27 +6,36 @@ RVRY is a structural constraint system that forces Large Language Models past th
 
 ## Quick Start
 
-The setup wizard handles everything -- token configuration, Claude Code registration, and slash command installation:
-
 ```bash
 npx @rvry/mcp setup
 ```
 
 The wizard will:
-1. Prompt for your RVRY token (hidden input) -- or open rvry.ai/dashboard to generate one
-2. Register RVRY as an MCP server in Claude Code (`-s user` scope)
-3. Install slash commands (`/deepthink`, `/problem-solve`) to `.claude/commands/`
+1. Open your browser to sign in (or prompt for a token)
+2. Auto-detect Claude Code and Claude Desktop on your machine
+3. Configure both clients automatically
+4. Install slash commands (`/deepthink`, `/problem-solve`)
+
+That's it. Restart Claude Desktop if it was running, and RVRY is ready.
+
+### Options
+
+```bash
+npx @rvry/mcp setup --token rvry_abc123   # Skip browser auth, use token directly
+npx @rvry/mcp setup --client code          # Only configure Claude Code
+npx @rvry/mcp setup --client desktop       # Only configure Claude Desktop
+```
 
 ### Manual Installation
 
-If you prefer to configure manually, or the `claude` CLI is not available:
+If you prefer to configure manually:
 
+**Claude Code:**
 ```bash
 claude mcp add -e RVRY_TOKEN=rvry_your_token -s user rvry -- npx @rvry/mcp
 ```
 
-Or add the following to your Claude Desktop `claude_desktop_config.json`:
-
+**Claude Desktop** (`claude_desktop_config.json`):
 ```json
 {
   "mcpServers": {
@@ -41,12 +50,10 @@ Or add the following to your Claude Desktop `claude_desktop_config.json`:
 }
 ```
 
-## Configuration
-
-RVRY requires an API token to communicate with the reasoning engine.
-
-1.  Generate a token at [rvry.ai/dashboard](https://rvry.ai/dashboard).
-2.  The setup wizard sets `RVRY_TOKEN` automatically. For manual setup, set it in your MCP config.
+Config file locations:
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+- Linux: `~/.config/Claude/claude_desktop_config.json`
 
 ## Tools Provided
 

package/dist/setup.d.ts

@@ -1,7 +1,12 @@
 /**
  * @rvry/mcp setup wizard
  *
- * Interactive setup: token input, Claude Code MCP registration, slash command installation.
+ * Interactive setup: device auth flow (browser-based) or manual token paste.
+ * Auto-detects Claude Code CLI and Claude Desktop, configures both.
+ *
  * Usage: npx @rvry/mcp setup
+ *        npx @rvry/mcp setup --token <value>
+ *        npx @rvry/mcp setup --client code      (Claude Code only)
+ *        npx @rvry/mcp setup --client desktop    (Claude Desktop only)
  */
 export declare function runSetup(): Promise<void>;

package/dist/setup.js

@@ -1,19 +1,36 @@
 /**
  * @rvry/mcp setup wizard
  *
- * Interactive setup: token input, Claude Code MCP registration, slash command installation.
+ * Interactive setup: device auth flow (browser-based) or manual token paste.
+ * Auto-detects Claude Code CLI and Claude Desktop, configures both.
+ *
  * Usage: npx @rvry/mcp setup
+ *        npx @rvry/mcp setup --token <value>
+ *        npx @rvry/mcp setup --client code      (Claude Code only)
+ *        npx @rvry/mcp setup --client desktop    (Claude Desktop only)
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
+import { homedir } from 'os';
 import { createInterface } from 'readline';
 import { execSync } from 'child_process';
 import { platform } from 'os';
+const ENGINE_URL = 'https://engine.rvry.ai';
 const COMMAND_FILES = [
     'deepthink.md',
     'problem-solve.md',
 ];
 const TOKEN_REGEX = /^rvry_[0-9a-f]{32,}$/;
+/** Polling interval for device auth: 3 seconds */
+const POLL_INTERVAL_MS = 3000;
+/** Max polling duration: 10 minutes */
+const POLL_TIMEOUT_MS = 10 * 60 * 1000;
+/** RVRY MCP server config block (reused across Desktop + manual output) */
+const RVRY_SERVER_ENTRY = (token) => ({
+    command: 'npx',
+    args: ['@rvry/mcp'],
+    env: { RVRY_TOKEN: token },
+});
 // ── Utility functions ──────────────────────────────────────────────
 /**
  * Find the commands directory shipped with this package.
@@ -140,6 +157,7 @@ function maskToken(token) {
 }
 /**
  * Open a URL in the default browser, platform-aware.
+ * Returns true if the browser was opened successfully, false otherwise.
  */
 function openBrowser(url) {
     const plat = platform();
@@ -153,11 +171,10 @@ function openBrowser(url) {
         else {
             execSync(`xdg-open "${url}"`, { stdio: 'pipe' });
         }
+        return true;
     }
     catch {
-        // Non-fatal: browser open failed
-        console.log('  Could not open browser automatically.');
-        console.log(`  Visit: ${url}`);
+        return false;
     }
 }
 /**
@@ -173,11 +190,83 @@ function isClaudeCLIAvailable() {
         return false;
     }
 }
+/**
+ * Get the platform-specific Claude Desktop config file path.
+ */
+function getDesktopConfigPath() {
+    const plat = platform();
+    if (plat === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    else if (plat === 'win32') {
+        return join(process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    }
+    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);
+}
+/**
+ * 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 {
+        let config = {};
+        if (existsSync(configPath)) {
+            const raw = readFileSync(configPath, 'utf-8');
+            try {
+                config = JSON.parse(raw);
+            }
+            catch {
+                console.log(`  Warning: ${configPath} contains invalid JSON.`);
+                console.log('  Creating a backup and writing fresh config.');
+                writeFileSync(configPath + '.backup', raw, 'utf-8');
+                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) {
+                return 'unchanged';
+            }
+        }
+        const wasNew = !existing;
+        servers.RVRY = newEntry;
+        // Write config with clean formatting
+        const configDir = dirname(configPath);
+        if (!existsSync(configDir)) {
+            mkdirSync(configDir, { recursive: true });
+        }
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        return wasNew ? 'created' : 'updated';
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`  Error writing Desktop config: ${msg}`);
+        return 'error';
+    }
+}
 /**
  * Register RVRY as an MCP server in Claude Code.
  * Removes existing registration first for idempotency.
  */
-function registerMCP(token) {
+function registerClaudeCode(token) {
     try {
         // Remove existing (ignore error if not registered)
         try {
@@ -195,40 +284,124 @@ function registerMCP(token) {
     }
 }
 /**
- * Print manual JSON config block for users without the Claude CLI.
+ * Verify token by hitting the engine /api/usage endpoint.
+ * Returns tier info on success, null on failure.
  */
-function printManualConfig(token) {
-    const config = {
-        mcpServers: {
-            RVRY: {
-                command: 'npx',
-                args: ['@rvry/mcp'],
-                env: {
-                    RVRY_TOKEN: token,
-                },
-            },
+async function verifyToken(token) {
+    try {
+        const res = await fetch(`${ENGINE_URL}/api/usage`, {
+            headers: { 'Authorization': `Bearer ${token}` },
+        });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        return { tier: data.tier, used: data.monthlyUsage ?? 0, limit: data.limit };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Sleep for a given number of milliseconds.
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// ── Spinner animation ──────────────────────────────────────────────
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+/**
+ * Create a spinner that animates in the terminal.
+ * Returns start/stop controls.
+ */
+function createSpinner(message) {
+    let frameIndex = 0;
+    let timer = null;
+    return {
+        start() {
+            process.stdout.write(`  ${SPINNER_FRAMES[0]} ${message}`);
+            timer = setInterval(() => {
+                frameIndex = (frameIndex + 1) % SPINNER_FRAMES.length;
+                process.stdout.write(`\r  ${SPINNER_FRAMES[frameIndex]} ${message}`);
+            }, 80);
+        },
+        stop(finalMessage) {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            process.stdout.write('\r' + ' '.repeat(message.length + 10) + '\r');
+            if (finalMessage) {
+                console.log(`  ${finalMessage}`);
+            }
         },
     };
-    console.log('');
-    console.log('  Claude CLI not found. Add this to your MCP config manually:');
-    console.log('');
-    console.log(JSON.stringify(config, null, 2));
-    console.log('');
-    const plat = platform();
-    if (plat === 'darwin') {
-        console.log('  Claude Desktop config location:');
-        console.log('  ~/Library/Application Support/Claude/claude_desktop_config.json');
+}
+// ── Device auth flow ───────────────────────────────────────────────
+/**
+ * Device authorization flow: open browser, poll for token.
+ * Returns the token on success, or null on failure/timeout.
+ */
+async function deviceAuthFlow() {
+    // Step 1: Request a device code from the engine
+    let deviceCode;
+    let verificationUrl;
+    try {
+        const res = await fetch(`${ENGINE_URL}/api/device/start`, { method: 'POST' });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({ error: 'Unknown error' }));
+            console.log(`  Could not start device auth: ${body.error ?? res.statusText}`);
+            return null;
+        }
+        const data = await res.json();
+        deviceCode = data.device_code;
+        verificationUrl = data.verification_url;
     }
-    else if (plat === 'win32') {
-        console.log('  Claude Desktop config location:');
-        console.log('  %APPDATA%\\Claude\\claude_desktop_config.json');
+    catch (err) {
+        console.log('  Could not connect to RVRY engine. Is engine.rvry.ai reachable?');
+        return null;
+    }
+    // Step 2: Open browser
+    console.log('');
+    const browserOpened = openBrowser(verificationUrl);
+    if (browserOpened) {
+        console.log('  Browser opened. Complete sign-in to continue.');
     }
     else {
-        console.log('  Claude Desktop config location:');
-        console.log('  ~/.config/Claude/claude_desktop_config.json');
+        console.log('  Could not open browser automatically.');
+        console.log(`  Visit: ${verificationUrl}`);
+    }
+    console.log('');
+    // Step 3: Poll for token
+    const spinner = createSpinner('Waiting for login in browser...');
+    spinner.start();
+    const startTime = Date.now();
+    while (Date.now() - startTime < POLL_TIMEOUT_MS) {
+        await sleep(POLL_INTERVAL_MS);
+        try {
+            const res = await fetch(`${ENGINE_URL}/api/device/${deviceCode}/token`);
+            if (!res.ok) {
+                spinner.stop('Polling error. Falling back to manual token entry.');
+                return null;
+            }
+            const data = await res.json();
+            if (data.status === 'complete' && data.token) {
+                spinner.stop('Login successful!');
+                return { token: data.token, warning: data.warning };
+            }
+            if (data.status === 'expired') {
+                spinner.stop('Device code expired.');
+                return null;
+            }
+            // status === 'pending' — keep polling
+        }
+        catch {
+            // Network error during poll — keep trying
+        }
     }
+    spinner.stop('Timed out waiting for login.');
+    return null;
 }
-// ── Token input flow ───────────────────────────────────────────────
+// ── Manual token input flow ────────────────────────────────────────
 async function getToken() {
     while (true) {
         const token = (await readHiddenInput('  Enter your RVRY token: ')).trim();
@@ -281,57 +454,208 @@ async function installCommands() {
 }
 // ── Main setup flow ────────────────────────────────────────────────
 const BANNER = `
-░█████████  ░██    ░██ ░█████████  ░██     ░██
-░██     ░██ ░██    ░██ ░██     ░██  ░██   ░██
-░██     ░██ ░██    ░██ ░██     ░██   ░██ ░██
-░█████████  ░██    ░██ ░█████████     ░████
-░██   ░██    ░██  ░██  ░██   ░██       ░██
-░██    ░██    ░██░██   ░██    ░██      ░██
-░██     ░██    ░███    ░██     ░██     ░██
+ _____ __      __ _____ __     __
+|  __ \\\\ \\\\    / /|  __ \\\\ \\\\   / /
+| |__) |\\\\ \\\\  / / | |__) |\\\\ \\\\_/ /
+|  _  /  \\\\ \\\\/ /  |  _  /  \\\\   /
+| | \\\\ \\\\   \\\\  /   | | \\\\ \\\\   | |
+|_|  \\\\_\\\\   \\\\/    |_|  \\\\_\\\\  |_|
 `;
 export async function runSetup() {
     console.log(BANNER);
     console.log('Setup');
     console.log('');
-    // Step 1: Token input
-    console.log('[1/3] Token');
-    const token = await getToken();
-    console.log('');
-    // Step 2: Claude Code MCP registration
-    console.log('[2/3] Claude Code MCP Registration');
-    let claudeConfigured = false;
-    if (isClaudeCLIAvailable()) {
-        const success = registerMCP(token);
-        if (success) {
-            claudeConfigured = true;
-            console.log('  Registered RVRY in Claude Code (user scope).');
+    // Parse flags
+    const tokenFlagIndex = process.argv.indexOf('--token');
+    const clientFlagIndex = process.argv.indexOf('--client');
+    const clientFilter = clientFlagIndex !== -1 ? process.argv[clientFlagIndex + 1] : null;
+    // ── Step 1: Authentication ──────────────────────────────────────
+    let token = null;
+    let warning;
+    if (tokenFlagIndex !== -1 && process.argv[tokenFlagIndex + 1]) {
+        const flagValue = process.argv[tokenFlagIndex + 1];
+        if (!isValidToken(flagValue)) {
+            console.log('  Invalid token format. Expected: rvry_ followed by 32+ hex characters.');
+            process.exit(1);
+        }
+        token = flagValue;
+        console.log('[1/4] Authentication (from --token flag)');
+        console.log(`  Token: ${maskToken(token)}`);
+    }
+    else {
+        console.log('[1/4] Authentication');
+        console.log('  Opening browser for sign-in...');
+        const result = await deviceAuthFlow();
+        if (result) {
+            token = result.token;
+            warning = result.warning;
+            console.log(`  Token: ${maskToken(token)}`);
+            if (warning) {
+                console.log(`  Warning: ${warning}`);
+            }
         }
         else {
-            console.log('  Failed to register with Claude CLI.');
-            printManualConfig(token);
+            console.log('');
+            console.log('  Falling back to manual token entry.');
+            console.log('  Generate a token at https://rvry.ai/dashboard');
+            console.log('');
+            token = await getToken();
         }
     }
+    // Verify token against engine
+    const spinner = createSpinner('Verifying token...');
+    spinner.start();
+    const usage = await verifyToken(token);
+    if (usage) {
+        const usageText = usage.limit < 0
+            ? `${usage.used ?? 0} sessions used (unlimited)`
+            : `${usage.used ?? 0}/${usage.limit} sessions used`;
+        spinner.stop(`Verified. Plan: ${usage.tier} (${usageText})`);
+    }
     else {
-        printManualConfig(token);
+        spinner.stop('Could not verify token (engine may be unreachable). Continuing anyway.');
+    }
+    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})`);
+    }
+    if (!hasClaudeCode && !hasDesktop) {
+        console.log('  No Claude clients detected.');
     }
     console.log('');
-    // Step 3: Slash command installation
-    console.log('[3/3] Slash Commands');
+    // ── 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');
+        }
+    }
+    else if (wantDesktop && !hasDesktop) {
+        console.log('  Claude Desktop: Not installed');
+    }
+    // Fallback: print manual config if nothing was configured
+    if (neitherConfigured) {
+        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:');
+        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}`);
+        }
+    }
+    console.log('');
+    // ── Step 4: Slash commands ──────────────────────────────────────
+    console.log('[4/4] Slash Commands');
     const commandCount = await installCommands();
     if (commandCount > 0) {
-        console.log(`  Installed ${commandCount} commands to .claude/commands/`);
+        console.log(`  Installed ${commandCount} command${commandCount > 1 ? 's' : ''} to .claude/commands/`);
     }
     else {
-        console.log('  No new commands installed.');
+        console.log('  No new commands installed (already up to date).');
     }
     console.log('');
-    // Summary
+    // ── Summary ─────────────────────────────────────────────────────
+    console.log('─'.repeat(50));
+    console.log('');
     console.log('RVRY Setup Complete');
     console.log('');
-    console.log(`  Token:        ${maskToken(token)}`);
-    console.log(`  Claude Code:  ${claudeConfigured ? 'Configured (user scope)' : 'Manual config required'}`);
-    console.log(`  Commands:     ${commandCount} installed to .claude/commands/`);
+    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');
+    }
+    console.log(`  Commands:       ${commandCount} installed`);
     console.log('');
-    console.log('Try: /deepthink "your question"');
+    // Client-specific next steps
+    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`);
+        step++;
+    }
+    if (codeConfigured) {
+        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:`);
+        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');
+        console.log('  2. Then try: /deepthink "your question"');
+    }
     console.log('');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rvry/mcp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "RVRY reasoning depth enforcement (RDE) engine client.",
   "type": "module",
   "bin": {