techprufer-mcp 0.1.6 → 0.2.0

package/README.md

@@ -4,9 +4,58 @@ TechPrufer MCP — tailor resumes and build profiles from your AI tool.
 
 Uses the same TechPrufer cube mark as the site and Chrome extension (shown in MCP clients that support server icons).
 
-## Install
+## Quick start
 
-Server key **must** be `techprufer` so slash commands are `/techprufer/…`:
+One command does everything:
+
+```bash
+npx techprufer-mcp login
+```
+
+This runs two steps:
+
+1. **Configure AI tools** — an interactive picker (arrow keys, `Space` to toggle, `a` for all, `Enter` to confirm). Tools that already have the server show `(refresh)` and are pre-selected.
+2. **Device-code login** — opens your browser to approve the device. If the browser doesn't open, paste the printed link manually; the CLI keeps waiting and re-shows the link after 30 seconds.
+
+Use `--no-setup` to skip the picker and login only. Restart your AI tools after setup so they pick up the server.
+
+## Commands
+
+```bash
+npx techprufer-mcp              # Start stdio MCP server (what AI tools run)
+npx techprufer-mcp login        # Configure tools, then device-code login
+npx techprufer-mcp setup        # Configure tools only (no login)
+npx techprufer-mcp status       # Show saved credentials
+```
+
+### Setup options (non-interactive)
+
+```bash
+npx techprufer-mcp setup --all
+npx techprufer-mcp setup --tools=cursor,claude-code,codex
+npx techprufer-mcp setup --print --tools=antigravity   # print snippets, write nothing
+```
+
+### Login options
+
+```bash
+npx techprufer-mcp login --name "Work laptop"   # device name shown on the site
+npx techprufer-mcp login --no-setup             # skip the tool picker
+```
+
+## Supported tools
+
+| Id | Tool | Config written |
+|----|------|----------------|
+| `cursor` | Cursor | `~/.cursor/mcp.json` |
+| `claude` | Claude Desktop | `claude_desktop_config.json` (per-OS path) |
+| `claude-code` | Claude Code | `~/.claude.json` (user scope) |
+| `antigravity` | Antigravity | `~/.gemini/…/mcp_config.json` |
+| `codex` | Codex | `~/.codex/config.toml` |
+
+Setup merges into existing config files — other MCP servers are preserved. The server key **must** be `techprufer` so slash commands are `/techprufer/…`.
+
+## Manual JSON (any mcpServers client)
 
 ```json
 {
@@ -19,12 +68,6 @@ Server key **must** be `techprufer` so slash commands are `/techprufer/…`:
 }
 ```
 
-## Login
-
-```bash
-npx techprufer-mcp login
-```
-
 ## Slash commands
 
 Type `/techprufer` in your AI tool to list:

package/dist/api.js

@@ -8,6 +8,17 @@ export class ApiError extends Error {
         this.body = body;
     }
 }
+/** Avoid Error.cause typing (needs lib es2022); Node fetch still sets cause at runtime. */
+function formatFetchError(err) {
+    if (!(err instanceof Error))
+        return String(err);
+    const cause = err.cause;
+    if (cause instanceof Error)
+        return cause.message;
+    if (typeof cause === 'string' && cause)
+        return cause;
+    return err.message;
+}
 export async function apiFetch(path, init = {}) {
     const creds = loadCredentials();
     const token = init.token === undefined ? creds?.token : init.token;
@@ -30,12 +41,7 @@ export async function apiFetch(path, init = {}) {
         res = await fetch(`${base}${path}`, { ...fetchInit, headers });
     }
     catch (err) {
-        const cause = err instanceof Error && err.cause instanceof Error
-            ? err.cause.message
-            : err instanceof Error
-                ? err.message
-                : String(err);
-        throw new Error(`fetch failed (${base}${path}): ${cause}`);
+        throw new Error(`fetch failed (${base}${path}): ${formatFetchError(err)}`);
     }
     const text = await res.text();
     let body = null;

package/dist/cli.js

@@ -1,13 +1,43 @@
 #!/usr/bin/env node
 import { runLogin, startStdioServer } from './server.js';
 import { loadCredentials, credentialsFilePath, getApiUrl } from './config.js';
+import { listToolsForHelp, runSetup } from './setup.js';
+function parseFlagValue(args, name) {
+    const eq = args.find((a) => a.startsWith(`${name}=`));
+    if (eq)
+        return eq.slice(name.length + 1);
+    const idx = args.indexOf(name);
+    if (idx >= 0)
+        return args[idx + 1];
+    return undefined;
+}
+function hasFlag(args, name) {
+    return args.includes(name);
+}
 async function main() {
     const args = process.argv.slice(2);
     const cmd = args[0];
     if (cmd === 'login') {
         const nameIdx = args.indexOf('--name');
         const deviceName = nameIdx >= 0 ? args[nameIdx + 1] : undefined;
-        await runLogin(deviceName);
+        const skipSetup = hasFlag(args, '--no-setup');
+        if (!skipSetup) {
+            await runSetup({ beforeLogin: true });
+            console.error('');
+        }
+        await runLogin(deviceName, skipSetup ? {} : { stepLabel: 'step 2/2 · login' });
+        return;
+    }
+    if (cmd === 'setup') {
+        const toolsRaw = parseFlagValue(args, '--tools');
+        await runSetup({
+            all: hasFlag(args, '--all'),
+            tools: toolsRaw
+                ? toolsRaw.split(',').map((s) => s.trim()).filter(Boolean)
+                : undefined,
+            printOnly: hasFlag(args, '--print'),
+            yes: hasFlag(args, '-y') || hasFlag(args, '--yes'),
+        });
         return;
     }
     if (cmd === 'status' || cmd === 'whoami') {
@@ -27,9 +57,23 @@ async function main() {
 
 Usage:
   npx techprufer-mcp              Start stdio MCP server (for AI tools)
-  npx techprufer-mcp login        Device-code login (opens browser)
+  npx techprufer-mcp login        Pick AI tools to configure, then device-code login
+  npx techprufer-mcp setup        Configure AI tools only (no login)
   npx techprufer-mcp status       Show saved credentials
 
+Setup options:
+  --tools=id,id   Non-interactive: comma-separated tool ids
+  --all           Configure every supported tool
+  --print         Print config snippets only (no file writes)
+  -y, --yes       Require --tools or --all (no prompts)
+
+Supported tools:
+${listToolsForHelp()}
+
+Login options:
+  --name <label>  Device name shown on the site
+  --no-setup      Skip the tool picker; login only
+
 Env:
   TECHPRUFER_API_URL              Override API base (default https://techprufer.com)
 `);

package/dist/login.browserOpen.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/login.browserOpen.test.js

@@ -0,0 +1,26 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { browserOpenArgs } from './login.js';
+describe('browserOpenArgs', () => {
+    const url = 'https://techprufer.com/connect/device?code=ABCD-1234';
+    it('uses open on macOS', () => {
+        assert.deepEqual(browserOpenArgs(url, 'darwin'), {
+            command: 'open',
+            args: [url],
+            options: {},
+        });
+    });
+    it('uses cmd /c start on Windows (not spawn start)', () => {
+        const result = browserOpenArgs(url, 'win32');
+        assert.equal(result.command, 'cmd');
+        assert.deepEqual(result.args, ['/c', 'start', '', url]);
+        assert.equal(result.options.windowsHide, true);
+    });
+    it('uses xdg-open on Linux', () => {
+        assert.deepEqual(browserOpenArgs(url, 'linux'), {
+            command: 'xdg-open',
+            args: [url],
+            options: {},
+        });
+    });
+});

package/dist/login.d.ts

@@ -1 +1,11 @@
-export declare function runLogin(deviceName?: string): Promise<void>;
+/** Exported for tests — resolve platform-specific open command. */
+export declare function browserOpenArgs(url: string, os?: NodeJS.Platform): {
+    command: string;
+    args: string[];
+    options: {
+        windowsHide?: boolean;
+    };
+};
+export declare function runLogin(deviceName?: string, opts?: {
+    stepLabel?: string;
+}): Promise<void>;

package/dist/login.js

@@ -2,10 +2,37 @@ import { spawn } from 'child_process';
 import { platform } from 'os';
 import { apiFetch } from './api.js';
 import { getApiUrl, saveCredentials } from './config.js';
+/** Exported for tests — resolve platform-specific open command. */
+export function browserOpenArgs(url, os = platform()) {
+    if (os === 'darwin')
+        return { command: 'open', args: [url], options: {} };
+    if (os === 'win32') {
+        // `start` is a cmd.exe builtin, not an executable — spawn('start') → ENOENT.
+        // Empty title arg so the URL is not treated as a window title.
+        return {
+            command: 'cmd',
+            args: ['/c', 'start', '', url],
+            options: { windowsHide: true },
+        };
+    }
+    return { command: 'xdg-open', args: [url], options: {} };
+}
+/**
+ * Best-effort browser open. Failures must never kill the login poll —
+ * the URL is already printed for the user to open manually.
+ */
 function openBrowser(url) {
-    const cmd = platform() === 'darwin' ? 'open' : platform() === 'win32' ? 'start' : 'xdg-open';
     try {
-        const child = spawn(cmd, [url], { detached: true, stdio: 'ignore' });
+        const { command, args, options } = browserOpenArgs(url);
+        const child = spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            ...options,
+        });
+        // spawn errors are async ('error' event); try/catch alone is not enough.
+        child.on('error', () => {
+            /* ignore — user can open the printed URL */
+        });
         child.unref();
     }
     catch {
@@ -31,9 +58,9 @@ function alignVerifyUrl(verifyUrl, apiUrl) {
         return verifyUrl;
     }
 }
-export async function runLogin(deviceName) {
+export async function runLogin(deviceName, opts = {}) {
     const apiUrl = getApiUrl();
-    console.error(`TechPrufer MCP — logging in against ${apiUrl}`);
+    console.error(`TechPrufer MCP${opts.stepLabel ? ` — ${opts.stepLabel}` : ''} — logging in against ${apiUrl}`);
     const start = await apiFetch('/api/agent/device/start', {
         method: 'POST',
         token: null,
@@ -45,18 +72,37 @@ export async function runLogin(deviceName) {
     console.error(`  Code:  ${start.userCode}`);
     console.error(`  Open:  ${verifyUrl}`);
     console.error('');
-    console.error('Waiting for approval in the browser…');
+    console.error('Opening your browser… If it does not open, paste the link above manually.');
+    console.error('Waiting for approval (Ctrl+C to cancel)…');
     openBrowser(verifyUrl);
     const intervalMs = Math.max(3, start.interval || 5) * 1000;
     const deadline = Date.now() + start.expiresIn * 1000;
+    const startedAt = Date.now();
+    let remindedManualOpen = false;
     while (Date.now() < deadline) {
         await sleep(intervalMs);
-        const poll = await apiFetch('/api/agent/device/poll', {
-            method: 'POST',
-            token: null,
-            baseUrl: apiUrl,
-            body: JSON.stringify({ deviceCode: start.deviceCode }),
-        });
+        // Still pending after 30s — the browser probably never opened. Re-show the link.
+        if (!remindedManualOpen && Date.now() - startedAt > 30_000) {
+            remindedManualOpen = true;
+            console.error('');
+            console.error('Still waiting. If no browser window opened, visit:');
+            console.error(`  ${verifyUrl}`);
+            console.error(`  and enter code ${start.userCode}`);
+            console.error('');
+        }
+        let poll;
+        try {
+            poll = await apiFetch('/api/agent/device/poll', {
+                method: 'POST',
+                token: null,
+                baseUrl: apiUrl,
+                body: JSON.stringify({ deviceCode: start.deviceCode }),
+            });
+        }
+        catch {
+            // Transient network error — keep waiting until the code expires.
+            continue;
+        }
         if (poll.status === 'pending')
             continue;
         if (poll.status === 'expired') {

package/dist/setup.d.ts

@@ -0,0 +1,17 @@
+import { type AiToolId } from './tools.js';
+/** Parse "1,3", "cursor,codex", "all", "a" into tool ids (fallback prompt + --tools). */
+export declare function parseSelection(input: string): AiToolId[];
+export interface SetupOptions {
+    /** Explicit tool ids from --tools=… */
+    tools?: string[];
+    /** Configure every supported tool. */
+    all?: boolean;
+    /** Print snippets only; do not write files. */
+    printOnly?: boolean;
+    /** Skip interactive prompts (fail if tools not specified). */
+    yes?: boolean;
+    /** Called as step 1 of `login` — tweaks copy and skips the "next" hints. */
+    beforeLogin?: boolean;
+}
+export declare function runSetup(opts?: SetupOptions): Promise<void>;
+export declare function listToolsForHelp(): string;

package/dist/setup.js

@@ -0,0 +1,212 @@
+import { createInterface, emitKeypressEvents } from 'readline';
+import { AI_TOOLS, getTool, installTool, isToolConfigured, printSnippetForTool, resolveToolIds, } from './tools.js';
+const ANSI = {
+    hideCursor: '\x1b[?25l',
+    showCursor: '\x1b[?25h',
+    clearDown: '\x1b[J',
+    up: (n) => (n > 0 ? `\x1b[${n}A` : ''),
+    dim: (s) => `\x1b[2m${s}\x1b[22m`,
+    bold: (s) => `\x1b[1m${s}\x1b[22m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[39m`,
+    green: (s) => `\x1b[32m${s}\x1b[39m`,
+    red: (s) => `\x1b[31m${s}\x1b[39m`,
+};
+function isTty() {
+    return Boolean(process.stdin.isTTY && process.stderr.isTTY);
+}
+function ask(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/** Parse "1,3", "cursor,codex", "all", "a" into tool ids (fallback prompt + --tools). */
+export function parseSelection(input) {
+    const raw = input.trim().toLowerCase();
+    if (!raw)
+        return [];
+    if (raw === 'a' || raw === 'all')
+        return AI_TOOLS.map((t) => t.id);
+    const tokens = raw.split(/[\s,]+/).filter(Boolean);
+    const ids = [];
+    for (const token of tokens) {
+        const asNum = Number(token);
+        if (Number.isInteger(asNum) && asNum >= 1 && asNum <= AI_TOOLS.length) {
+            const id = AI_TOOLS[asNum - 1].id;
+            if (!ids.includes(id))
+                ids.push(id);
+            continue;
+        }
+        const tool = getTool(token);
+        if (!tool) {
+            throw new Error(`Unknown selection "${token}". Use numbers 1–${AI_TOOLS.length}, tool ids, or "all".`);
+        }
+        if (!ids.includes(tool.id))
+            ids.push(tool.id);
+    }
+    return ids;
+}
+function renderPicker(items, cursor) {
+    const lines = [];
+    const selectedLabels = items.filter((i) => i.selected).map((i) => i.tool.label);
+    lines.push(`${ANSI.bold('? Select AI tools to set up')} ${ANSI.dim(`(${AI_TOOLS.length} available)`)}`);
+    lines.push(`  Selected: ${selectedLabels.length ? ANSI.cyan(selectedLabels.join(', ')) : ANSI.dim('none')}`);
+    lines.push(ANSI.dim('  ↑↓ navigate · Space toggle · a all · Enter confirm · q quit'));
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const pointer = i === cursor ? ANSI.cyan('>') : ' ';
+        const mark = item.selected ? ANSI.green('●') : ANSI.dim('○');
+        const refresh = item.configured ? ` ${ANSI.dim('(refresh)')}` : '';
+        const label = i === cursor ? ANSI.bold(item.tool.label) : item.tool.label;
+        lines.push(`${pointer} ${mark} ${label}${refresh}  ${ANSI.dim(item.tool.hint)}`);
+    }
+    return lines.join('\n');
+}
+/** Arrow-key multi-select; pre-selects tools that already have a techprufer entry. */
+async function interactivePicker() {
+    const items = AI_TOOLS.map((tool) => {
+        const configured = isToolConfigured(tool);
+        return { tool, selected: configured, configured };
+    });
+    // Nothing configured yet → pre-select everything for a fast first run.
+    if (!items.some((i) => i.selected)) {
+        for (const item of items)
+            item.selected = true;
+    }
+    let cursor = 0;
+    let renderedLines = 0;
+    const draw = () => {
+        const frame = renderPicker(items, cursor);
+        process.stderr.write(ANSI.up(renderedLines) + '\r' + ANSI.clearDown + frame + '\n');
+        renderedLines = frame.split('\n').length;
+    };
+    emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode?.(true);
+    process.stdin.resume();
+    process.stderr.write(ANSI.hideCursor);
+    draw();
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            process.stdin.setRawMode?.(false);
+            process.stdin.pause();
+            process.stdin.removeListener('keypress', onKeypress);
+            process.stderr.write(ANSI.showCursor);
+        };
+        const onKeypress = (_str, key = {}) => {
+            if ((key.ctrl && key.name === 'c') || key.name === 'q' || key.name === 'escape') {
+                cleanup();
+                process.stderr.write('\nCancelled.\n');
+                reject(new Error('cancelled'));
+                return;
+            }
+            if (key.name === 'up' || key.name === 'k') {
+                cursor = (cursor - 1 + items.length) % items.length;
+            }
+            else if (key.name === 'down' || key.name === 'j') {
+                cursor = (cursor + 1) % items.length;
+            }
+            else if (key.name === 'space') {
+                items[cursor].selected = !items[cursor].selected;
+            }
+            else if (key.name === 'a') {
+                const allOn = items.every((i) => i.selected);
+                for (const item of items)
+                    item.selected = !allOn;
+            }
+            else if (key.name === 'return' || key.name === 'enter') {
+                cleanup();
+                resolve(items.filter((i) => i.selected).map((i) => i.tool.id));
+                return;
+            }
+            draw();
+        };
+        process.stdin.on('keypress', onKeypress);
+    });
+}
+async function promptToolSelection() {
+    if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        try {
+            return await interactivePicker();
+        }
+        catch (e) {
+            if (e instanceof Error && e.message === 'cancelled')
+                process.exit(1);
+            // Raw-mode failure → fall through to the plain prompt.
+        }
+    }
+    console.error('AI tools:');
+    AI_TOOLS.forEach((t, i) => {
+        console.error(`  ${i + 1}) ${t.label.padEnd(16)}  ${t.hint}`);
+    });
+    console.error('  a) all');
+    console.error('');
+    const answer = await ask('Select tools (numbers or ids, comma-separated; "all"): ');
+    return parseSelection(answer);
+}
+function printResults(results, opts = {}) {
+    console.error('');
+    for (const r of results) {
+        if (r.ok) {
+            console.error(`  ${ANSI.green('✓')} Setup complete for ${ANSI.bold(r.tool.label)}  ${ANSI.dim(r.path)}`);
+        }
+        else {
+            console.error(`  ${ANSI.red('✗')} ${r.tool.label}  ${ANSI.dim(r.path)}`);
+            console.error(`      ${r.error}`);
+        }
+    }
+    console.error('');
+    console.error(ANSI.dim('Restart your AI tools for the MCP server to take effect.'));
+    if (!opts.beforeLogin) {
+        console.error('');
+        console.error('Next: npx techprufer-mcp login  (if you have not already)');
+        console.error('Then: /techprufer/tailor or /techprufer/build-profile');
+    }
+}
+export async function runSetup(opts = {}) {
+    console.error(ANSI.bold(opts.beforeLogin
+        ? 'TechPrufer MCP — step 1/2 · configure AI tools'
+        : 'TechPrufer MCP — configure AI tools'));
+    console.error('');
+    let ids;
+    if (opts.all) {
+        ids = AI_TOOLS.map((t) => t.id);
+    }
+    else if (opts.tools?.length) {
+        ids = resolveToolIds(opts.tools);
+    }
+    else if (isTty() && !opts.yes) {
+        ids = await promptToolSelection();
+    }
+    else {
+        console.error('Non-interactive mode: pass --all or --tools=cursor,claude,claude-code,antigravity,codex');
+        process.exit(1);
+    }
+    if (ids.length === 0) {
+        if (opts.beforeLogin) {
+            console.error('No tools selected — skipping setup.');
+            return;
+        }
+        console.error('No tools selected.');
+        process.exit(1);
+    }
+    const selected = ids.map((id) => getTool(id));
+    if (opts.printOnly) {
+        for (const tool of selected) {
+            console.error(`--- ${tool.label} (${tool.configPath()}) ---`);
+            console.error(printSnippetForTool(tool));
+            console.error('');
+        }
+        return;
+    }
+    const results = selected.map((tool) => installTool(tool));
+    printResults(results, { beforeLogin: opts.beforeLogin });
+    if (results.some((r) => !r.ok) && !opts.beforeLogin) {
+        process.exit(1);
+    }
+}
+export function listToolsForHelp() {
+    return AI_TOOLS.map((t) => `    ${t.id.padEnd(14)} ${t.label}`).join('\n');
+}

package/dist/tools.d.ts

@@ -0,0 +1,49 @@
+/** Server key must stay `techprufer` so slash commands are `/techprufer/…`. */
+export declare const MCP_SERVER_KEY = "techprufer";
+export declare const MCP_SERVER_ENTRY: {
+    readonly command: "npx";
+    readonly args: readonly ["-y", "techprufer-mcp"];
+};
+export type AiToolId = 'cursor' | 'claude' | 'claude-code' | 'antigravity' | 'codex';
+export interface AiToolDef {
+    id: AiToolId;
+    label: string;
+    /** Short hint shown in the picker. */
+    hint: string;
+    /** Config path for the current OS (may not exist yet). */
+    configPath: () => string;
+    format: 'json-mcpServers' | 'toml-mcp_servers';
+    /** Shown after a successful write. */
+    restartHint: string;
+}
+/**
+ * Antigravity IDE commonly uses `~/.gemini/antigravity/mcp_config.json`.
+ * Newer docs also mention `~/.gemini/config/mcp_config.json` — prefer the path
+ * that already exists, else the antigravity path.
+ */
+export declare function antigravityConfigPath(): string;
+export declare const AI_TOOLS: AiToolDef[];
+export declare function getTool(id: string): AiToolDef | undefined;
+export declare function resolveToolIds(raw: string[]): AiToolId[];
+/** Merge techprufer into a Cursor/Claude/Antigravity-style JSON mcpServers file. */
+export declare function mergeJsonMcpServers(existingRaw: string | null): string;
+/**
+ * Upsert `[mcp_servers.techprufer]` in a Codex config.toml without a TOML parser.
+ * Replaces an existing techprufer table; appends otherwise.
+ */
+export declare function mergeTomlMcpServers(existingRaw: string | null): string;
+/** True if the tool's config file already has a techprufer entry. */
+export declare function isToolConfigured(tool: AiToolDef): boolean;
+export type InstallResult = {
+    ok: true;
+    tool: AiToolDef;
+    path: string;
+    created: boolean;
+} | {
+    ok: false;
+    tool: AiToolDef;
+    path: string;
+    error: string;
+};
+export declare function installTool(tool: AiToolDef): InstallResult;
+export declare function printSnippetForTool(tool: AiToolDef): string;

package/dist/tools.js

@@ -0,0 +1,186 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir, platform } from 'os';
+import { dirname, join } from 'path';
+/** Server key must stay `techprufer` so slash commands are `/techprufer/…`. */
+export const MCP_SERVER_KEY = 'techprufer';
+export const MCP_SERVER_ENTRY = {
+    command: 'npx',
+    args: ['-y', 'techprufer-mcp'],
+};
+function appDataRoaming() {
+    if (platform() === 'win32') {
+        return process.env.APPDATA || join(homedir(), 'AppData', 'Roaming');
+    }
+    return '';
+}
+function claudeDesktopConfigPath() {
+    const os = platform();
+    if (os === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    if (os === 'win32') {
+        return join(appDataRoaming(), 'Claude', 'claude_desktop_config.json');
+    }
+    return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+/**
+ * Antigravity IDE commonly uses `~/.gemini/antigravity/mcp_config.json`.
+ * Newer docs also mention `~/.gemini/config/mcp_config.json` — prefer the path
+ * that already exists, else the antigravity path.
+ */
+export function antigravityConfigPath() {
+    const antigravity = join(homedir(), '.gemini', 'antigravity', 'mcp_config.json');
+    const config = join(homedir(), '.gemini', 'config', 'mcp_config.json');
+    if (existsSync(antigravity))
+        return antigravity;
+    if (existsSync(config))
+        return config;
+    return antigravity;
+}
+export const AI_TOOLS = [
+    {
+        id: 'cursor',
+        label: 'Cursor',
+        hint: '~/.cursor/mcp.json',
+        configPath: () => join(homedir(), '.cursor', 'mcp.json'),
+        format: 'json-mcpServers',
+        restartHint: 'Reload Cursor MCP servers (or restart Cursor).',
+    },
+    {
+        id: 'claude',
+        label: 'Claude Desktop',
+        hint: 'claude_desktop_config.json',
+        configPath: claudeDesktopConfigPath,
+        format: 'json-mcpServers',
+        restartHint: 'Quit and reopen Claude Desktop.',
+    },
+    {
+        id: 'claude-code',
+        label: 'Claude Code',
+        hint: '~/.claude.json (user scope)',
+        configPath: () => join(homedir(), '.claude.json'),
+        format: 'json-mcpServers',
+        restartHint: 'Restart Claude Code / open a new session.',
+    },
+    {
+        id: 'antigravity',
+        label: 'Antigravity',
+        hint: '~/.gemini/…/mcp_config.json',
+        configPath: antigravityConfigPath,
+        format: 'json-mcpServers',
+        restartHint: 'Refresh MCP servers in Antigravity (or restart).',
+    },
+    {
+        id: 'codex',
+        label: 'Codex',
+        hint: '~/.codex/config.toml',
+        configPath: () => join(homedir(), '.codex', 'config.toml'),
+        format: 'toml-mcp_servers',
+        restartHint: 'Restart Codex / open a new session.',
+    },
+];
+export function getTool(id) {
+    return AI_TOOLS.find((t) => t.id === id);
+}
+export function resolveToolIds(raw) {
+    const out = [];
+    for (const token of raw) {
+        const id = token.trim().toLowerCase();
+        if (!getTool(id)) {
+            throw new Error(`Unknown tool "${token}". Choose: ${AI_TOOLS.map((t) => t.id).join(', ')}`);
+        }
+        if (!out.includes(id))
+            out.push(id);
+    }
+    return out;
+}
+/** Merge techprufer into a Cursor/Claude/Antigravity-style JSON mcpServers file. */
+export function mergeJsonMcpServers(existingRaw) {
+    let root = {};
+    if (existingRaw?.trim()) {
+        try {
+            const parsed = JSON.parse(existingRaw);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                root = parsed;
+            }
+            else {
+                throw new Error('Config root must be a JSON object');
+            }
+        }
+        catch (e) {
+            throw new Error(`Invalid JSON config: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    const servers = root.mcpServers && typeof root.mcpServers === 'object' && !Array.isArray(root.mcpServers)
+        ? { ...root.mcpServers }
+        : {};
+    servers[MCP_SERVER_KEY] = { ...MCP_SERVER_ENTRY };
+    root.mcpServers = servers;
+    return `${JSON.stringify(root, null, 2)}\n`;
+}
+/**
+ * Upsert `[mcp_servers.techprufer]` in a Codex config.toml without a TOML parser.
+ * Replaces an existing techprufer table; appends otherwise.
+ */
+export function mergeTomlMcpServers(existingRaw) {
+    const block = [
+        `[mcp_servers.${MCP_SERVER_KEY}]`,
+        'command = "npx"',
+        'args = ["-y", "techprufer-mcp"]',
+        '',
+    ].join('\n');
+    const text = existingRaw ?? '';
+    // Match `[mcp_servers.techprufer]` through the next `[section]` or EOF.
+    const re = /\[mcp_servers\.techprufer\][\s\S]*?(?=\n\[|\s*$)/;
+    if (re.test(text)) {
+        return text.replace(re, block.trimEnd()).replace(/\n{3,}/g, '\n\n');
+    }
+    const trimmed = text.replace(/\s+$/, '');
+    if (!trimmed)
+        return `${block}`;
+    return `${trimmed}\n\n${block}`;
+}
+/** True if the tool's config file already has a techprufer entry. */
+export function isToolConfigured(tool) {
+    const path = tool.configPath();
+    if (!existsSync(path))
+        return false;
+    try {
+        const raw = readFileSync(path, 'utf8');
+        if (tool.format === 'toml-mcp_servers') {
+            return /\[mcp_servers\.techprufer\]/.test(raw);
+        }
+        const parsed = JSON.parse(raw);
+        return Boolean(parsed?.mcpServers && MCP_SERVER_KEY in parsed.mcpServers);
+    }
+    catch {
+        return false;
+    }
+}
+export function installTool(tool) {
+    const path = tool.configPath();
+    try {
+        const existed = existsSync(path);
+        const prev = existed ? readFileSync(path, 'utf8') : null;
+        const next = tool.format === 'toml-mcp_servers'
+            ? mergeTomlMcpServers(prev)
+            : mergeJsonMcpServers(prev);
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(path, next, 'utf8');
+        return { ok: true, tool, path, created: !existed };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            tool,
+            path,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+export function printSnippetForTool(tool) {
+    if (tool.format === 'toml-mcp_servers') {
+        return mergeTomlMcpServers(null).trimEnd();
+    }
+    return mergeJsonMcpServers(null).trimEnd();
+}

package/dist/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tools.test.js

@@ -0,0 +1,67 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mergeJsonMcpServers, mergeTomlMcpServers, MCP_SERVER_KEY, MCP_SERVER_ENTRY, } from './tools.js';
+import { parseSelection } from './setup.js';
+describe('mergeJsonMcpServers', () => {
+    it('creates mcpServers when file is empty', () => {
+        const out = JSON.parse(mergeJsonMcpServers(null));
+        assert.deepEqual(out.mcpServers[MCP_SERVER_KEY], { ...MCP_SERVER_ENTRY });
+    });
+    it('preserves other servers', () => {
+        const prev = JSON.stringify({
+            mcpServers: {
+                other: { command: 'node', args: ['x.js'] },
+            },
+        });
+        const out = JSON.parse(mergeJsonMcpServers(prev));
+        assert.deepEqual(out.mcpServers.other, { command: 'node', args: ['x.js'] });
+        assert.deepEqual(out.mcpServers[MCP_SERVER_KEY], { ...MCP_SERVER_ENTRY });
+    });
+    it('overwrites an existing techprufer entry', () => {
+        const prev = JSON.stringify({
+            mcpServers: {
+                techprufer: { command: 'old', args: [] },
+            },
+        });
+        const out = JSON.parse(mergeJsonMcpServers(prev));
+        assert.equal(out.mcpServers.techprufer.command, 'npx');
+    });
+});
+describe('mergeTomlMcpServers', () => {
+    it('appends a techprufer table', () => {
+        const out = mergeTomlMcpServers('model = "o3"\n');
+        assert.match(out, /\[mcp_servers\.techprufer\]/);
+        assert.match(out, /command = "npx"/);
+        assert.match(out, /args = \["-y", "techprufer-mcp"\]/);
+        assert.match(out, /^model = "o3"/m);
+    });
+    it('replaces an existing techprufer table', () => {
+        const prev = [
+            '[mcp_servers.other]',
+            'command = "echo"',
+            '',
+            '[mcp_servers.techprufer]',
+            'command = "old"',
+            'args = ["x"]',
+            '',
+            '[features]',
+            'foo = true',
+            '',
+        ].join('\n');
+        const out = mergeTomlMcpServers(prev);
+        assert.match(out, /command = "npx"/);
+        assert.doesNotMatch(out, /command = "old"/);
+        assert.match(out, /\[mcp_servers\.other\]/);
+        assert.match(out, /\[features\]/);
+    });
+});
+describe('parseSelection', () => {
+    it('accepts numbers, ids, and all', () => {
+        assert.deepEqual(parseSelection('1,3'), ['cursor', 'claude-code']);
+        assert.deepEqual(parseSelection('codex'), ['codex']);
+        assert.deepEqual(parseSelection('all').length, 5);
+    });
+    it('rejects unknown tokens', () => {
+        assert.throws(() => parseSelection('windsurf'), /Unknown selection/);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "techprufer-mcp",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "TechPrufer MCP — tailor resumes and build profiles from your AI tool",
   "homepage": "https://techprufer.com",
   "type": "module",
@@ -31,6 +31,7 @@
   ],
   "license": "MIT",
   "scripts": {
-    "build": "tsc -p tsconfig.json"
+    "build": "tsc -p tsconfig.json",
+    "test": "npm run build && node --test dist/*.test.js"
   }
 }