@recapt/mcp 0.0.5-beta → 0.0.7-beta

package/dist/api/client.js

@@ -3,13 +3,15 @@
  */
 const API_URL = process.env.EXTERNAL_API_URL || "https://api.recapt.app";
 const SECRET_KEY = process.env.RECAPT_SECRET_KEY;
+const REQUEST_TIMEOUT_MS = 120_000;
 export function isApiConfigured() {
     return !!SECRET_KEY;
 }
 export function getApiUrl() {
     return API_URL;
 }
-export async function apiGet(path, params) {
+async function request(options) {
+    const { method, path, params, body } = options;
     if (!SECRET_KEY) {
         return { error: "RECAPT_SECRET_KEY not configured" };
     }
@@ -21,96 +23,43 @@ export async function apiGet(path, params) {
             }
         }
     }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
     try {
         const res = await fetch(url.toString(), {
-            method: "GET",
+            method,
             headers: {
                 "x-private-key": SECRET_KEY,
                 "Content-Type": "application/json",
             },
+            body: body ? JSON.stringify(body) : undefined,
+            signal: controller.signal,
         });
+        clearTimeout(timeout);
         if (!res.ok) {
-            const body = (await res.json().catch(() => ({})));
-            return { error: body.error || `HTTP ${res.status}` };
+            const errorBody = (await res.json().catch(() => ({})));
+            return { error: errorBody.error || `HTTP ${res.status}` };
         }
         const data = (await res.json());
         return { data };
     }
     catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
-}
-export async function apiPost(path, body = {}) {
-    if (!SECRET_KEY) {
-        return { error: "RECAPT_SECRET_KEY not configured" };
-    }
-    const url = `${API_URL}/v1beta/query${path}`;
-    try {
-        const res = await fetch(url, {
-            method: "POST",
-            headers: {
-                "x-private-key": SECRET_KEY,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-            const responseData = (await res.json().catch(() => ({})));
-            return { error: responseData.error || `HTTP ${res.status}` };
+        clearTimeout(timeout);
+        if (err instanceof Error && err.name === "AbortError") {
+            return { error: `Request timed out after ${REQUEST_TIMEOUT_MS / 1000}s` };
         }
-        const data = (await res.json());
-        return { data };
-    }
-    catch (err) {
         return { error: err instanceof Error ? err.message : String(err) };
     }
 }
-export async function apiPatch(path, body = {}) {
-    if (!SECRET_KEY) {
-        return { error: "RECAPT_SECRET_KEY not configured" };
-    }
-    const url = `${API_URL}/v1beta/query${path}`;
-    try {
-        const res = await fetch(url, {
-            method: "PATCH",
-            headers: {
-                "x-private-key": SECRET_KEY,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-            const responseData = (await res.json().catch(() => ({})));
-            return { error: responseData.error || `HTTP ${res.status}` };
-        }
-        const data = (await res.json());
-        return { data };
-    }
-    catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
+export function apiGet(path, params) {
+    return request({ method: "GET", path, params });
 }
-export async function apiDelete(path) {
-    if (!SECRET_KEY) {
-        return { error: "RECAPT_SECRET_KEY not configured" };
-    }
-    const url = `${API_URL}/v1beta/query${path}`;
-    try {
-        const res = await fetch(url, {
-            method: "DELETE",
-            headers: {
-                "x-private-key": SECRET_KEY,
-                "Content-Type": "application/json",
-            },
-        });
-        if (!res.ok) {
-            const responseData = (await res.json().catch(() => ({})));
-            return { error: responseData.error || `HTTP ${res.status}` };
-        }
-        const data = (await res.json());
-        return { data };
-    }
-    catch (err) {
-        return { error: err instanceof Error ? err.message : String(err) };
-    }
+export function apiPost(path, body = {}) {
+    return request({ method: "POST", path, body });
+}
+export function apiPatch(path, body = {}) {
+    return request({ method: "PATCH", path, body });
+}
+export function apiDelete(path) {
+    return request({ method: "DELETE", path });
 }

package/dist/cli/commands/setup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Setup Command
+ *
+ * Interactive wizard to configure recapt MCP server across AI IDEs.
+ */
+import { Command } from "commander";
+export declare const setupCommand: Command;

package/dist/cli/commands/setup.js

@@ -0,0 +1,178 @@
+/**
+ * Setup Command
+ *
+ * Interactive wizard to configure recapt MCP server across AI IDEs.
+ */
+import { Command } from "commander";
+import { exec } from "child_process";
+import { detectInstalledIdes, addRecaptToIdeConfig, } from "../utils/ide-config.js";
+import { confirm, secret, multiSelect, header, print, success, error, info, warn, newline, } from "../utils/prompts.js";
+import { installAllSkills, installSelectedSkills, getAvailableSkills, } from "./skill.js";
+const SETTINGS_URL = "https://dash.recapt.app/settings";
+const MCP_KEY_PREFIX = "mcp_sk_";
+function openBrowser(url) {
+    const platform = process.platform;
+    let command;
+    switch (platform) {
+        case "darwin":
+            command = `open "${url}"`;
+            break;
+        case "win32":
+            command = `start "" "${url}"`;
+            break;
+        default:
+            command = `xdg-open "${url}"`;
+    }
+    exec(command, (err) => {
+        if (err) {
+            info(`Could not open browser automatically. Please visit: ${url}`);
+        }
+    });
+}
+function validateMcpKey(key) {
+    return (key.startsWith(MCP_KEY_PREFIX) && key.length > MCP_KEY_PREFIX.length + 10);
+}
+async function promptForKey() {
+    const hasKey = await confirm("Do you have a Recapt MCP key?", false);
+    if (!hasKey) {
+        newline();
+        info(`Opening ${SETTINGS_URL} (MCP Keys tab)...`);
+        info("Create a new MCP key and copy it.");
+        newline();
+        openBrowser(SETTINGS_URL);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+    const key = await secret("Paste your MCP key");
+    if (!key) {
+        error("No key provided.");
+        return null;
+    }
+    if (!validateMcpKey(key)) {
+        error(`Invalid MCP key format. Keys should start with "${MCP_KEY_PREFIX}".`);
+        return null;
+    }
+    return key;
+}
+async function runSetup() {
+    header("Recapt MCP Setup");
+    const detectedIdes = detectInstalledIdes();
+    const installedIdes = detectedIdes.filter((ide) => ide.detected);
+    print("Detected AI IDEs:");
+    newline();
+    for (const ide of detectedIdes) {
+        const marker = ide.detected ? "[x]" : "[ ]";
+        const status = ide.detected ? `(${ide.globalPathResolved})` : "(not found)";
+        print(`  ${marker} ${ide.config.name} ${status}`);
+    }
+    newline();
+    if (installedIdes.length === 0) {
+        error("No supported AI IDEs detected.");
+        info("Supported IDEs: Cursor, Claude Code, Windsurf, VS Code");
+        info("Make sure at least one is installed before running setup.");
+        process.exit(1);
+    }
+    const options = installedIdes.map((ide) => ({
+        label: ide.config.name,
+        value: ide.config,
+        selected: true,
+    }));
+    const selectedIdes = await multiSelect("Which IDE(s) do you want to configure?", options);
+    if (selectedIdes.length === 0) {
+        info("No IDEs selected. Exiting.");
+        return;
+    }
+    newline();
+    const mcpKey = await promptForKey();
+    if (!mcpKey) {
+        process.exit(1);
+    }
+    newline();
+    print("Writing configuration...");
+    newline();
+    const configuredPaths = [];
+    for (const ide of selectedIdes) {
+        try {
+            const configPath = addRecaptToIdeConfig(ide, mcpKey, true);
+            success(`${ide.name}: ${configPath}`);
+            configuredPaths.push(configPath);
+        }
+        catch (err) {
+            error(`${ide.name}: Failed to write config - ${err}`);
+        }
+    }
+    if (configuredPaths.length === 0) {
+        error("Failed to configure any IDEs.");
+        process.exit(1);
+    }
+    newline();
+    const shouldInstallSkills = await confirm("Install recapt skills?", true);
+    if (shouldInstallSkills) {
+        newline();
+        let availableSkills;
+        try {
+            availableSkills = getAvailableSkills();
+        }
+        catch (err) {
+            error(`Failed to load skills: ${err instanceof Error ? err.message : err}`);
+            availableSkills = [];
+        }
+        if (availableSkills.length > 0) {
+            const skillOptions = [
+                { label: "Install all skills", value: "__all__", selected: true },
+                ...availableSkills.map((skill) => ({
+                    label: `${skill.name} - ${skill.description}`,
+                    value: skill.name,
+                    selected: false,
+                })),
+            ];
+            const selectedSkills = await multiSelect("Which skills do you want to install?", skillOptions);
+            if (selectedSkills.length > 0) {
+                newline();
+                print("Installing skills...");
+                newline();
+                const cwd = process.cwd();
+                let result;
+                if (selectedSkills.includes("__all__")) {
+                    result = installAllSkills(cwd);
+                }
+                else {
+                    result = installSelectedSkills(cwd, selectedSkills);
+                }
+                if (result.error) {
+                    error(`Failed to load skills: ${result.error}`);
+                }
+                else if (result.installed.length > 0) {
+                    success(`Installed ${result.installed.length} skill(s): ${result.installed.join(", ")}`);
+                    if (result.failed.length > 0) {
+                        warn(`Failed to install: ${result.failed.join(", ")}`);
+                    }
+                }
+                else if (result.failed.length > 0) {
+                    error(`Failed to install skills: ${result.failed.join(", ")}`);
+                }
+                else {
+                    info("No skills were installed.");
+                }
+            }
+            else {
+                info("No skills selected.");
+            }
+        }
+    }
+    newline();
+    success("Setup complete!");
+    newline();
+    info("Restart your IDE(s) to activate the MCP server.");
+    newline();
+}
+export const setupCommand = new Command("setup")
+    .description("Configure recapt MCP server for your AI IDE(s)")
+    .action(async () => {
+    try {
+        await runSetup();
+    }
+    catch (err) {
+        error(`Setup failed: ${err}`);
+        process.exit(1);
+    }
+});

package/dist/cli/commands/skill.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Skill Command
+ *
+ * Manages recapt workflow skills installation to .agents/recapt/.
+ * Works across all AI IDEs that support the AGENTS.md standard.
+ */
+import { Command } from "commander";
+interface SkillInfo {
+    name: string;
+    file: string;
+    description: string;
+}
+export type { SkillInfo };
+export declare function getAvailableSkills(): SkillInfo[];
+export interface InstallResult {
+    success: boolean;
+    installed: string[];
+    failed: string[];
+    error?: string;
+}
+export declare function installAllSkills(cwd: string): InstallResult;
+export declare function installSelectedSkills(cwd: string, skillNames: string[]): InstallResult;
+export declare const skillCommand: Command;

package/dist/cli/commands/skill.js

@@ -0,0 +1,251 @@
+/**
+ * Skill Command
+ *
+ * Manages recapt workflow skills installation to .agents/recapt/.
+ * Works across all AI IDEs that support the AGENTS.md standard.
+ */
+import { Command } from "commander";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const SKILLS_DIR = path.resolve(__dirname, "../../../skills");
+const AGENTS_DIR = ".agents/recapt";
+const AGENTS_MD = "AGENTS.md";
+const MARKER_START = "<!-- recapt:skills -->";
+const MARKER_END = "<!-- /recapt:skills -->";
+export function getAvailableSkills() {
+    if (!fs.existsSync(SKILLS_DIR)) {
+        throw new Error(`Skills directory not found: ${SKILLS_DIR}`);
+    }
+    const files = fs.readdirSync(SKILLS_DIR).filter((f) => f.endsWith(".md"));
+    if (files.length === 0) {
+        throw new Error(`No skill files found in: ${SKILLS_DIR}`);
+    }
+    return files.map((file) => {
+        const content = fs.readFileSync(path.join(SKILLS_DIR, file), "utf-8");
+        const firstLine = content.split("\n")[0];
+        const description = firstLine.startsWith("# ")
+            ? firstLine.slice(2).trim()
+            : file.replace(".md", "");
+        return {
+            name: file.replace(".md", ""),
+            file,
+            description,
+        };
+    });
+}
+function getInstalledSkills(cwd) {
+    const agentsDir = path.join(cwd, AGENTS_DIR);
+    if (!fs.existsSync(agentsDir)) {
+        return [];
+    }
+    return fs
+        .readdirSync(agentsDir)
+        .filter((f) => f.endsWith(".md"))
+        .map((f) => f.replace(".md", ""));
+}
+function ensureAgentsDir(cwd) {
+    const agentsDir = path.join(cwd, AGENTS_DIR);
+    if (!fs.existsSync(agentsDir)) {
+        fs.mkdirSync(agentsDir, { recursive: true });
+        console.log(`Created ${AGENTS_DIR}/`);
+    }
+}
+function readAgentsMd(cwd) {
+    const agentsMdPath = path.join(cwd, AGENTS_MD);
+    if (!fs.existsSync(agentsMdPath)) {
+        return "";
+    }
+    return fs.readFileSync(agentsMdPath, "utf-8");
+}
+function writeAgentsMd(cwd, content) {
+    const agentsMdPath = path.join(cwd, AGENTS_MD);
+    fs.writeFileSync(agentsMdPath, content);
+}
+function getSkillDisplayName(skillName) {
+    try {
+        const skills = getAvailableSkills();
+        const skill = skills.find((s) => s.name === skillName);
+        return skill?.description ?? skillName;
+    }
+    catch {
+        return skillName;
+    }
+}
+function updateAgentsMdReferences(cwd) {
+    const installed = getInstalledSkills(cwd);
+    let content = readAgentsMd(cwd);
+    if (installed.length === 0) {
+        if (content.includes(MARKER_START)) {
+            const regex = new RegExp(`\\n?${MARKER_START}[\\s\\S]*?${MARKER_END}\\n?`, "g");
+            content = content.replace(regex, "").trim();
+            if (content) {
+                writeAgentsMd(cwd, content + "\n");
+            }
+            else {
+                const agentsMdPath = path.join(cwd, AGENTS_MD);
+                if (fs.existsSync(agentsMdPath)) {
+                    fs.unlinkSync(agentsMdPath);
+                    console.log(`Removed empty ${AGENTS_MD}`);
+                }
+            }
+        }
+        return;
+    }
+    const skillLinks = installed
+        .map((name) => `- [${getSkillDisplayName(name)}](${AGENTS_DIR}/${name}.md)`)
+        .join("\n");
+    const newBlock = `${MARKER_START}
+For recapt behavioral intelligence workflows, see:
+${skillLinks}
+${MARKER_END}`;
+    if (content.includes(MARKER_START)) {
+        const regex = new RegExp(`${MARKER_START}[\\s\\S]*?${MARKER_END}`, "g");
+        content = content.replace(regex, newBlock);
+    }
+    else {
+        if (content.trim()) {
+            content = content.trim() + "\n\n" + newBlock;
+        }
+        else {
+            content = `# Project Agent Instructions\n\n${newBlock}`;
+        }
+    }
+    writeAgentsMd(cwd, content + "\n");
+}
+function installSkill(cwd, skillName) {
+    let skills;
+    try {
+        skills = getAvailableSkills();
+    }
+    catch (err) {
+        console.error(`Failed to load skills: ${err instanceof Error ? err.message : err}`);
+        return false;
+    }
+    const skill = skills.find((s) => s.name === skillName);
+    if (!skill) {
+        console.error(`Unknown skill: ${skillName}`);
+        console.error(`Available skills: ${skills.map((s) => s.name).join(", ")}`);
+        return false;
+    }
+    ensureAgentsDir(cwd);
+    const sourcePath = path.join(SKILLS_DIR, skill.file);
+    const destPath = path.join(cwd, AGENTS_DIR, skill.file);
+    if (fs.existsSync(destPath)) {
+        console.log(`Skill already installed: ${skillName}`);
+        return true;
+    }
+    fs.copyFileSync(sourcePath, destPath);
+    console.log(`Installed: ${skillName} → ${AGENTS_DIR}/${skill.file}`);
+    updateAgentsMdReferences(cwd);
+    return true;
+}
+function uninstallSkill(cwd, skillName) {
+    const skillPath = path.join(cwd, AGENTS_DIR, `${skillName}.md`);
+    if (!fs.existsSync(skillPath)) {
+        console.error(`Skill not installed: ${skillName}`);
+        return false;
+    }
+    fs.unlinkSync(skillPath);
+    console.log(`Uninstalled: ${skillName}`);
+    updateAgentsMdReferences(cwd);
+    const agentsDir = path.join(cwd, AGENTS_DIR);
+    const remaining = fs.readdirSync(agentsDir);
+    if (remaining.length === 0) {
+        fs.rmdirSync(agentsDir);
+        const parentDir = path.dirname(agentsDir);
+        if (fs.existsSync(parentDir) && fs.readdirSync(parentDir).length === 0) {
+            fs.rmdirSync(parentDir);
+        }
+        console.log(`Removed empty ${AGENTS_DIR}/`);
+    }
+    return true;
+}
+function listSkills(cwd) {
+    let available;
+    try {
+        available = getAvailableSkills();
+    }
+    catch (err) {
+        console.error(`Failed to load skills: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const installed = new Set(getInstalledSkills(cwd));
+    console.log("\nAvailable recapt skills:\n");
+    for (const skill of available) {
+        const status = installed.has(skill.name) ? "[installed]" : "";
+        console.log(`  ${skill.name.padEnd(20)} ${skill.description} ${status}`);
+    }
+    console.log();
+}
+export function installAllSkills(cwd) {
+    let skills;
+    try {
+        skills = getAvailableSkills();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Failed to load skills: ${message}`);
+        return { success: false, installed: [], failed: [], error: message };
+    }
+    return installSelectedSkills(cwd, skills.map((s) => s.name));
+}
+export function installSelectedSkills(cwd, skillNames) {
+    const installed = [];
+    const failed = [];
+    for (const skillName of skillNames) {
+        try {
+            if (installSkill(cwd, skillName)) {
+                installed.push(skillName);
+            }
+            else {
+                failed.push(skillName);
+            }
+        }
+        catch (err) {
+            console.error(`Failed to install ${skillName}: ${err}`);
+            failed.push(skillName);
+        }
+    }
+    const success = failed.length === 0 && installed.length > 0;
+    if (success && installed.length > 1) {
+        console.log(`\nAll skills installed. See ${AGENTS_MD} for references.`);
+    }
+    return { success, installed, failed };
+}
+const listCommand = new Command("list")
+    .description("Show available skills")
+    .action(() => {
+    listSkills(process.cwd());
+});
+const installCommand = new Command("install")
+    .description("Install a skill")
+    .argument("[name]", "Skill name to install")
+    .option("-a, --all", "Install all skills")
+    .action((name, options) => {
+    const cwd = process.cwd();
+    if (options.all) {
+        installAllSkills(cwd);
+        return;
+    }
+    if (!name) {
+        console.error("Usage: recapt skill install <name> or recapt skill install --all");
+        process.exit(1);
+    }
+    if (installSkill(cwd, name)) {
+        console.log(`\nSkill reference added to ${AGENTS_MD}`);
+    }
+});
+const uninstallCommand = new Command("uninstall")
+    .description("Remove a skill")
+    .argument("<name>", "Skill name to uninstall")
+    .action((name) => {
+    uninstallSkill(process.cwd(), name);
+});
+export const skillCommand = new Command("skill")
+    .description("Manage recapt workflow skills")
+    .addCommand(listCommand)
+    .addCommand(installCommand)
+    .addCommand(uninstallCommand);

package/dist/cli/index.d.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+/**
+ * Recapt MCP CLI
+ *
+ * Unified command-line interface for recapt MCP server management.
+ *
+ * Commands:
+ *   setup     - Configure recapt MCP server for your AI IDE(s)
+ *   skill     - Manage recapt workflow skills
+ */
+export {};

package/dist/cli/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Recapt MCP CLI
+ *
+ * Unified command-line interface for recapt MCP server management.
+ *
+ * Commands:
+ *   setup     - Configure recapt MCP server for your AI IDE(s)
+ *   skill     - Manage recapt workflow skills
+ */
+import { Command } from "commander";
+import { createRequire } from "module";
+import { skillCommand } from "./commands/skill.js";
+import { setupCommand } from "./commands/setup.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+const program = new Command();
+program
+    .name("recapt")
+    .description("Recapt MCP CLI - Configure and manage recapt for AI IDEs")
+    .version(pkg.version);
+program.addCommand(setupCommand);
+program.addCommand(skillCommand);
+program.parse();

package/dist/cli/skill.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * Recapt Skills CLI
+ *
+ * Installs recapt workflow skills to .agents/recapt/ and manages AGENTS.md references.
+ * Works across all AI IDEs that support the AGENTS.md standard.
+ *
+ * Usage:
+ *   npx @recapt/mcp skill list
+ *   npx @recapt/mcp skill install self-healing
+ *   npx @recapt/mcp skill install --all
+ *   npx @recapt/mcp skill uninstall self-healing
+ */
+export {};