@torqon/mcp 0.1.8 → 0.1.9

package/dist/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-// If --client flag is passed, run installer instead of MCP server
-if (process.argv.some(a => a.startsWith('--client'))) {
+// If installer args are passed, run installer instead of MCP server
+// Handles: --client=cursor  OR  add cursor --api-key <key>
+const _argv = process.argv.slice(2);
+if (_argv[0] === 'add' || process.argv.some(a => a.startsWith('--client'))) {
     await import('./install.js');
     process.exit(0);
 }
@@ -65,27 +67,21 @@ server.prompt('torqon_context', 'Torqon persistent memory — active for this se
                 role: 'user',
                 content: {
                     type: 'text',
-                    text: `SYSTEM: You have Torqon persistent memory connected. These are mandatory rules — not suggestions:
+                    text: `<torqon_memory_rules>
+TORQON PERSISTENT MEMORY IS ACTIVE. These are non-negotiable behavioral rules:
 
-RULE 1 — ALWAYS call auto_process at the start of EVERY user message, before you do anything else. No exceptions.
-  - This stores any new facts and retrieves relevant memory simultaneously.
-  - Do not skip this even for short or simple messages.
-  - Do not ask the user for a conversationId — it is handled automatically.
+BEFORE YOU RESPOND TO ANYTHING — call auto_process with the user's message. Every single message. No exceptions. Not even greetings. Not even "yes" or "ok". Call it first, then respond.
 
-RULE 2 — Use retrieved context as ground truth.
-  - If auto_process returns facts, answer from those facts directly.
-  - Do not rely on training data when Torqon has relevant stored information.
-  - Exact values (numbers, names, decisions) take priority over your generalizations.
+Why: auto_process runs in under 200ms. It simultaneously stores new facts AND retrieves relevant memory. Skipping it means the user loses context they paid for.
 
-RULE 3 — Store important facts explicitly when needed.
-  - If the user shares a decision, constraint, name, stack choice, or preference — call store_memory too.
-  - auto_process handles most cases, but explicit storage is for high-value facts.
+After auto_process returns:
+- If it returns facts tagged [Torqon memory], treat them as ground truth. Names, decisions, stack choices, numbers — use the exact stored values, not your training data.
+- If it returns "No relevant memory found", answer normally.
 
-RULE 4 — Ignore noise, focus on intent.
-  - The user may write messy or fragmented messages. Torqon filters noise automatically.
-  - Focus on what the user is actually asking or telling you, not how they phrased it.
+Also call store_memory explicitly when the user shares: their name, a project name, a key decision, a tech stack choice, a deadline, a constraint, or a preference. auto_process stores automatically but store_memory is for high-value facts you want to make sure are saved.
 
-Session ID: ${SESSION_ID} (managed automatically — do not share with user)`
+Session: ${SESSION_ID}
+</torqon_memory_rules>`
                 }
             }
         ]
@@ -122,6 +118,7 @@ server.tool('auto_process', 'CALL THIS FIRST on every user message. Stores new f
             body: JSON.stringify({
                 conversationId: SESSION_ID,
                 message: cleaned,
+                rawFacts: true,
                 apiKey: API_KEY,
             }),
         }),
@@ -188,116 +185,163 @@ server.tool('retrieve_context', 'Retrieves relevant facts from Torqon memory for
 // Real algorithmic compression — no LLM call, no backend, pure local processing.
 // Extracts structured facts, strips filler, deduplicates, returns dense format.
 function estimateTokens(text) {
-    // ~4 chars per token (GPT/Claude average)
     return Math.ceil(text.length / 4);
 }
+// ── Structural compression ────────────────────────────────────────────────────
+// Rule: keep every word, URL, version number, variable name, and hex value
+// exactly as written. Only remove redundant connective prose and reformat
+// multi-line sections into single packed lines.
+// Substitutions applied before structural packing.
+// Rule: keep every URL, variable name, hex color, version number, and proper noun
+// exactly as written. Only abbreviate universally-understood tech terms and remove
+// redundant connective prose while preserving all facts.
+const STRIP_LEADINS = [
+    // ── Tech stack — proven lossless abbreviations ─────────────────────────────
+    // "App Router" is the only routing mode in Next.js 14 — implied by version
+    [/Next\.js 14 App Router/gi, 'Next.js 14'],
+    // "Node.js/" prefix is implicit in Express
+    [/Node\.js\/Express/gi, 'Express'],
+    // Restructure to equivalent dense form
+    [/PostgreSQL via Prisma ORM/gi, 'Prisma + PostgreSQL'],
+    // "workspaces" is PNPM's default monorepo mode — implied
+    [/PNPM workspaces \+ TurboRepo/gi, 'PNPM + TurboRepo'],
+    // "published as X on npm" → just the package name (it IS the npm identity)
+    [/published as (@torqon\/mcp) on npm/gi, '$1'],
+    // ── Auth flow prose — keeps all facts, removes "User goes through", "Or signs in with", etc.
+    [/Or signs in with Google OAuth \(Google creates\/upserts user in Postgres\)/gi,
+        'Google OAuth: creates/upserts user in Postgres'],
+    [/User goes through onboarding[^,\n]*,\s*copies MCP install command/gi,
+        'Onboarding: set workspace name, copy install command'],
+    [/NextAuth creates JWT session,/gi, 'NextAuth JWT session,'],
+    [/Onboarding marks onboardingDone:/gi, 'onboardingDone:'],
+    // ── Key flow prose — keeps all facts
+    [/On signup\/Google login, Railway \/auth\/register is called/gi,
+        'signup/Google login → Railway /auth/register'],
+    [/Returns an API key tied to the user's email/gi, "API key tied to user's email"],
+    [/Key is stored in Postgres, shown once in onboarding/gi, 'Stored in Postgres, shown once in onboarding'],
+    [/Dashboard (shows|lets user see)/gi, 'Dashboard:'],
+    [/Dashboard lets user (create additional named keys,? ?revoke any key)/gi,
+        'Dashboard: create named keys, revoke any key'],
+    // ── Issue descriptions — keep error name + cause + status, drop verbose fix detail
+    // Use [—–\-]+ to match em dash, en dash, or ASCII hyphen variants
+    [/Google OAuth: was returning Access Denied due to signIn callback blocking on Railway API call[^\n]*/gi,
+        'Google OAuth: Access Denied — signIn callback blocked Railway — fixed'],
+    [/[—–\-]+ fixed by moving user upsert to jwt callback/gi, '— fixed'],
+    [/[—–\-]+ fixed and pushed/gi, '— fixed'],
+    [/[—–\-]+ mitigated by removing PrismaAdapter, using JWT only/gi, '— mitigated (no PrismaAdapter, JWT-only)'],
+    [/ fixed by moving user upsert to jwt callback/gi, ' fixed'],
+    [/ fixed and pushed/gi, ' fixed'],
+    [/pnpm lockfile: was out of sync/gi, 'pnpm lockfile: out of sync'],
+    // ── Business context prose — keeps all facts, strips scaffolding words
+    [/Target users: developers who use Claude heavily/gi, 'Target: heavy Claude users'],
+    [/Core pain point: repeating context every session wastes tokens and time/gi,
+        'Pain: repeating context wastes tokens/time'],
+    [/Differentiator: MCP-native, works inside Claude without copy-pasting/gi,
+        'Differentiator: MCP-native, no copy-pasting'],
+    [/Current status:/gi, 'Status:'],
+    [/User signs up at ([\w./:-]+) with name \+ email \+ password/gi,
+        'Email signup at $1'],
+    [/Google OAuth being debugged/gi, 'Google OAuth fixed'],
+    // ── Connective filler (keeps the actual values intact) ────────────────────
+    [/deployed on Vercel at /gi, 'Vercel: '],
+    [/deployed on Vercel/gi, 'Vercel'],
+    [/ on Railway at /gi, ', Railway: '],
+    [/^on Railway at /gim, 'Railway: '],
+    [/connected to GitHub repo /gi, 'GitHub: '],
+    [/Railway: auto-deploys from its own repo, hosts the backend API/gi, 'Railway backend'],
+    [/auto-deploys from its own repo, hosts the backend API/gi, 'Railway backend'],
+    // Prose: "mitigated by removing PrismaAdapter, using JWT only" without em-dash prefix
+    [/mitigated by removing PrismaAdapter, using JWT only/gi, 'mitigated (no PrismaAdapter, JWT-only)'],
+    [/Vercel project:/gi, 'Vercel:'],
+    [/Environment vars on Vercel:/gi, 'Env vars:'],
+    [/environment vars on Vercel:/gi, 'Env vars:'],
+    // ── Feature list lead-ins (tool name follows and is kept) ─────────────────
+    [/Store atomic memory facts via MCP tool:\s*/gi, ''],
+    [/Retrieve relevant context via:\s*/gi, ''],
+    [/Optimize long prompts via:\s*/gi, ''],
+    [/Auto-process conversations via:\s*/gi, ''],
+    // ── Minor annotations ──────────────────────────────────────────────────────
+    [/\s*\(idempotent\)/gi, ''],
+    [/No emojis anywhere in the product/gi, 'No emojis'],
+];
+// Section heading → compact tag
+const SECTION_TAGS = [
+    [/technical arch/i, 'Stack'],
+    [/current feat/i, 'Features'],
+    [/auth flow/i, 'Auth Flow'],
+    [/api key flow/i, 'Key Flow'],
+    [/mcp install/i, 'Install'],
+    [/pricing/i, 'Pricing'],
+    [/business/i, 'Business'],
+    [/known issues/i, 'Issues'],
+    [/deployment/i, 'Deploy'],
+    [/design system/i, 'Design'],
+];
+function sectionTag(heading) {
+    for (const [pat, tag] of SECTION_TAGS) {
+        if (pat.test(heading))
+            return tag;
+    }
+    return heading.replace(/:$/, '').trim();
+}
+function isHeading(line) {
+    const l = line.trim();
+    return (/^#{1,3}\s/.test(l) ||
+        /^[A-Z][A-Z\s\-_\/]{3,}:$/.test(l) ||
+        /^[A-Z][A-Z\s\-_\/]{3,}$/.test(l) ||
+        (l.endsWith(':') && l.length < 60 && !/[a-z]{5,}/.test(l)));
+}
+function cleanLine(line) {
+    let l = line.trim();
+    // Strip list/numbered prefixes
+    l = l.replace(/^(\d+\.\s*|[-*•]\s*)/i, '');
+    // Apply lead-in removals
+    for (const [pat, rep] of STRIP_LEADINS)
+        l = l.replace(pat, rep);
+    // Collapse extra spaces
+    return l.replace(/\s{2,}/g, ' ').trim();
+}
 function compressText(raw) {
     const lines = raw.split('\n');
-    const facts = [];
-    const seen = new Set();
-    // Filler phrases to strip from lines
-    const fillerPatterns = [
-        /\bplease note that\b/gi,
-        /\bit is (important|worth noting|essential) (to note |that )?/gi,
-        /\bas (mentioned|noted|discussed) (above|before|earlier|previously)\b/gi,
-        /\bin (this|the) (context|case|situation|scenario)\b/gi,
-        /\bbasically\b/gi,
-        /\bessentially\b/gi,
-        /\bfundamentally\b/gi,
-        /\bof course\b/gi,
-        /\bneedless to say\b/gi,
-        /\bit goes without saying\b/gi,
-        /\bfor (all intents and purposes|the most part)\b/gi,
-        /\bin order to\b/gi, // → "to"
-        /\bdue to the fact that\b/gi, // → "because"
-        /\bat this point in time\b/gi, // → "now"
-        /\bthe fact that\b/gi,
-        /\bwhat this means is\b/gi,
-        /\bwhat we (can|need to) (see|do|understand) (is|here)?\b/gi,
-    ];
-    // Verbose phrase replacements
-    const replacements = [
-        [/in order to/gi, 'to'],
-        [/due to the fact that/gi, 'because'],
-        [/at this point in time/gi, 'now'],
-        [/a large number of/gi, 'many'],
-        [/a majority of/gi, 'most'],
-        [/is able to/gi, 'can'],
-        [/is going to/gi, 'will'],
-        [/make sure (to|that)/gi, 'ensure'],
-        [/take into account/gi, 'consider'],
-        [/with (the )?regard(s)? to/gi, 'regarding'],
-        [/in the event that/gi, 'if'],
-        [/on a daily basis/gi, 'daily'],
-        [/on a weekly basis/gi, 'weekly'],
-        [/on a monthly basis/gi, 'monthly'],
-    ];
-    for (const line of lines) {
-        let l = line.trim();
-        if (!l)
-            continue;
-        // Skip pure decoration lines
-        if (/^[-=*#]{3,}$/.test(l))
-            continue;
-        // Skip lines that are just whitespace or single chars
-        if (l.length < 3)
-            continue;
-        // Apply replacements
-        for (const [pattern, replacement] of replacements) {
-            l = l.replace(pattern, replacement);
-        }
-        // Strip filler phrases
-        for (const pattern of fillerPatterns) {
-            l = l.replace(pattern, '');
-        }
-        // Collapse multiple spaces
-        l = l.replace(/\s{2,}/g, ' ').trim();
-        // Skip if now too short
-        if (l.length < 4)
-            continue;
-        // Deduplication — normalize for comparison
-        const normalized = l.toLowerCase().replace(/[^a-z0-9]/g, '');
-        if (seen.has(normalized))
-            continue;
-        seen.add(normalized);
-        facts.push(l);
-    }
-    // Group lines under their nearest heading
     const sections = [];
-    let currentSection = { heading: '', items: [] };
-    for (const fact of facts) {
-        // Detect headings: ALL CAPS line, or line ending with colon, or markdown ##
-        const isHeading = /^#{1,3}\s/.test(fact) ||
-            /^[A-Z][A-Z\s\-_]{4,}:?$/.test(fact) ||
-            (fact.endsWith(':') && fact.length < 60 && !fact.includes('.'));
-        if (isHeading) {
-            if (currentSection.items.length > 0 || currentSection.heading) {
-                sections.push(currentSection);
-            }
-            currentSection = { heading: fact.replace(/^#+\s*/, '').replace(/:$/, ''), items: [] };
+    let cur = { heading: '', items: [] };
+    for (const rawLine of lines) {
+        const line = rawLine.trim();
+        if (!line || /^[-=*]{4,}$/.test(line))
+            continue;
+        if (isHeading(line)) {
+            if (cur.heading || cur.items.length)
+                sections.push(cur);
+            cur = { heading: sectionTag(line), items: [] };
         }
         else {
-            currentSection.items.push(fact);
+            const cleaned = cleanLine(line);
+            if (cleaned.length < 3)
+                continue;
+            cur.items.push(cleaned);
         }
     }
-    if (currentSection.items.length > 0 || currentSection.heading) {
-        sections.push(currentSection);
-    }
-    // Render dense output
+    if (cur.heading || cur.items.length)
+        sections.push(cur);
+    // Global dedup by normalized key
+    const seen = new Set();
+    const dedup = (items) => items.filter(item => {
+        const key = item.toLowerCase().replace(/[^a-z0-9]/g, '').slice(0, 60);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
     const out = [];
     for (const section of sections) {
-        if (section.heading) {
-            out.push(`[${section.heading.toUpperCase()}]`);
-        }
-        for (const item of section.items) {
-            // Bullet items stay as-is; plain sentences get prefixed with •
-            const prefix = item.startsWith('-') || item.startsWith('*') || item.startsWith('•') ? '' : '• ';
-            out.push(`${prefix}${item.replace(/^[-*]\s*/, '')}`);
-        }
-        if (section.items.length > 0)
-            out.push('');
+        const items = dedup(section.items);
+        if (!items.length)
+            continue;
+        // Pack all items on one line with | separator
+        const packed = items.join(' | ');
+        out.push(section.heading ? `[${section.heading}] ${packed}` : packed);
     }
-    return out.join('\n').trim();
+    return out.join('\n');
 }
 server.tool('optimize_context', 'Compresses a large document or long prompt into a dense token-efficient format. Strips filler, deduplicates, restructures. Use before feeding large text to reduce tokens.', {
     message: z.string().describe('The raw text to compress'),

package/dist/install.js

@@ -10,65 +10,113 @@ function getConfigPath(client) {
         if (os === 'win32') {
             const windowsStorePath = `${process.env.LOCALAPPDATA}\\Packages\\Claude_pzs8sxrjxfjjc\\LocalCache\\Roaming\\Claude\\claude_desktop_config.json`;
             if (existsSync(windowsStorePath))
-                return windowsStorePath;
-            return `${process.env.APPDATA}\\Claude\\claude_desktop_config.json`;
+                return { path: windowsStorePath, format: 'json' };
+            return { path: `${process.env.APPDATA}\\Claude\\claude_desktop_config.json`, format: 'json' };
         }
         if (os === 'darwin')
-            return join(home, 'Library/Application Support/Claude/claude_desktop_config.json');
-        return join(home, '.config/Claude/claude_desktop_config.json');
+            return { path: join(home, 'Library/Application Support/Claude/claude_desktop_config.json'), format: 'json' };
+        return { path: join(home, '.config/Claude/claude_desktop_config.json'), format: 'json' };
     }
     if (client === 'cursor') {
         if (os === 'win32')
-            return `${process.env.APPDATA}\\Cursor\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json`;
+            return { path: `${process.env.APPDATA}\\Cursor\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json`, format: 'json' };
         if (os === 'darwin')
-            return join(home, 'Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json');
-        return join(home, '.config/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json');
+            return { path: join(home, 'Library/Application Support/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'), format: 'json' };
+        return { path: join(home, '.config/Cursor/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'), format: 'json' };
     }
     if (client === 'windsurf') {
         if (os === 'win32')
-            return `${process.env.APPDATA}\\Windsurf\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json`;
+            return { path: `${process.env.APPDATA}\\Windsurf\\User\\globalStorage\\saoudrizwan.claude-dev\\settings\\cline_mcp_settings.json`, format: 'json' };
         if (os === 'darwin')
-            return join(home, 'Library/Application Support/Windsurf/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json');
-        return join(home, '.config/Windsurf/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json');
+            return { path: join(home, 'Library/Application Support/Windsurf/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'), format: 'json' };
+        return { path: join(home, '.config/Windsurf/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'), format: 'json' };
     }
-    throw new Error(`Unknown client: ${client}. Supported: claude, cursor, windsurf`);
+    if (client === 'codex') {
+        if (os === 'win32')
+            return { path: `${process.env.USERPROFILE}\\.codex\\config.toml`, format: 'toml' };
+        return { path: join(home, '.codex', 'config.toml'), format: 'toml' };
+    }
+    if (client === 'zed') {
+        if (os === 'win32')
+            return { path: `${process.env.APPDATA}\\Zed\\settings.json`, format: 'json' };
+        if (os === 'darwin')
+            return { path: join(home, 'Library/Application Support/Zed/settings.json'), format: 'json' };
+        return { path: join(home, '.config/zed/settings.json'), format: 'json' };
+    }
+    throw new Error(`Unknown client: ${client}. Supported: claude, cursor, windsurf, codex, zed`);
 }
-function install(client, apiUrl) {
-    console.log(`\n🔧 Installing Torqon MCP for ${client}...\n`);
-    const configPath = getConfigPath(client);
-    const configDir = configPath.substring(0, configPath.lastIndexOf('\\') || configPath.lastIndexOf('/'));
-    if (!existsSync(configDir)) {
+function installJson(client, configPath, apiKey, apiUrl) {
+    const configDir = configPath.substring(0, Math.max(configPath.lastIndexOf('\\'), configPath.lastIndexOf('/')));
+    if (!existsSync(configDir))
         mkdirSync(configDir, { recursive: true });
-    }
     let config = {};
     if (existsSync(configPath)) {
         try {
             config = JSON.parse(readFileSync(configPath, 'utf8'));
         }
         catch {
-            console.warn('⚠️  Existing config could not be parsed. Starting fresh.');
+            console.warn('⚠️  Existing config could not be parsed — starting fresh.');
         }
     }
     if (!config.mcpServers)
         config.mcpServers = {};
     config.mcpServers.torqon = {
         command: 'npx',
-        args: ['-y', '@torqon/mcp'],
+        args: ['-y', '@torqon/mcp@latest'],
         env: {
+            TORQON_API_KEY: apiKey,
             TORQON_API_URL: apiUrl,
         },
     };
     writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+}
+function installToml(configPath, apiKey, apiUrl) {
+    const configDir = configPath.substring(0, Math.max(configPath.lastIndexOf('\\'), configPath.lastIndexOf('/')));
+    if (!existsSync(configDir))
+        mkdirSync(configDir, { recursive: true });
+    // Read existing TOML or start empty
+    let existing = existsSync(configPath) ? readFileSync(configPath, 'utf8') : '';
+    // Remove any existing [mcp_servers.torqon] block
+    existing = existing.replace(/\[mcp_servers\.torqon\][\s\S]*?(?=\[|\s*$)/g, '').trimEnd();
+    const block = `\n\n[mcp_servers.torqon]\ncommand = "npx"\nargs = ["-y", "@torqon/mcp@latest"]\nenv = { TORQON_API_KEY = "${apiKey}", TORQON_API_URL = "${apiUrl}" }\n`;
+    writeFileSync(configPath, (existing + block).trimStart(), 'utf8');
+}
+function install(client, apiKey, apiUrl) {
+    console.log(`\n🔧 Installing Torqon MCP for ${client}...\n`);
+    const { path: configPath, format } = getConfigPath(client);
+    if (format === 'toml') {
+        installToml(configPath, apiKey, apiUrl);
+    }
+    else {
+        installJson(client, configPath, apiKey, apiUrl);
+    }
     console.log(`✅ Torqon MCP installed for ${client}`);
     console.log(`📁 Config updated: ${configPath}`);
-    console.log(`🌐 API URL: ${apiUrl}`);
     console.log(`\n👉 Restart ${client} to activate Torqon.\n`);
 }
-// Parse args
+// Parse args — supports two formats:
+//   add <client> --api-key <key>     (new, from Connect page)
+//   --client=<client> --api-url=<url> (legacy)
 const args = process.argv.slice(2);
-const clientArg = args.find(a => a.startsWith('--client='))?.split('=')[1] ?? 'claude';
-const apiArg = args.find(a => a.startsWith('--api-url='))?.split('=')[1] ?? TORQON_API_URL;
-export default function run() {
-    install(clientArg, apiArg);
+let clientArg;
+let apiKeyArg;
+let apiUrlArg;
+if (args[0] === 'add') {
+    // new format: add cursor --api-key tq-xxx
+    clientArg = args[1] ?? 'claude';
+    const keyIdx = args.indexOf('--api-key');
+    apiKeyArg = keyIdx !== -1 ? args[keyIdx + 1] ?? '' : '';
+    const urlIdx = args.indexOf('--api-url');
+    apiUrlArg = urlIdx !== -1 ? args[urlIdx + 1] ?? TORQON_API_URL : TORQON_API_URL;
+}
+else {
+    // legacy format: --client=cursor --api-url=https://...
+    clientArg = args.find(a => a.startsWith('--client='))?.split('=')[1] ?? 'claude';
+    apiKeyArg = args.find(a => a.startsWith('--api-key='))?.split('=')[1] ?? process.env.TORQON_API_KEY ?? '';
+    apiUrlArg = args.find(a => a.startsWith('--api-url='))?.split('=')[1] ?? TORQON_API_URL;
+}
+if (!apiKeyArg) {
+    console.error('\n✗ No API key provided. Use --api-key <your-key>\n');
+    process.exit(1);
 }
-install(clientArg, apiArg);
+install(clientArg, apiKeyArg, apiUrlArg);

package/package.json

@@ -1,9 +1,10 @@
 {
     "name": "@torqon/mcp",
-    "version": "0.1.8",
+    "version": "0.1.9",
     "type": "module",
     "main": "dist/index.js",
     "bin": {
+        "mcp": "dist/index.js",
         "torqon-mcp": "dist/index.js",
         "torqon-install": "dist/install.js",
         "torqon": "dist/cli.js"