doc2mcp 0.1.13

package/README.md

@@ -0,0 +1,62 @@
+# doc2mcp CLI
+
+Generate documentation MCP servers from your terminal.
+
+## Install
+
+```bash
+npm install -g doc2mcp
+```
+
+## Quick start
+
+```bash
+# 1. Authorize (opens browser)
+doc2mcp login
+
+# 2. Convert docs → MCP (same pipeline as the website)
+doc2mcp https://docs.example.com
+
+# 3. Follow the install prompt for Cursor, VS Code, Claude, or Windsurf
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `doc2mcp login` | Browser device authorization |
+| `doc2mcp logout` | Remove stored credentials |
+| `doc2mcp whoami` | Show logged-in user |
+| `doc2mcp list` | List your MCP projects |
+| `doc2mcp install <id>` | Install a ready MCP into editors |
+| `doc2mcp <docs-url>` | Create MCP from documentation URL |
+
+## Environment
+
+| Variable | Default | Description |
+| --- | --- | --- |
+| `DOC2MCP_API_URL` | `https://doc2mcp.com` | API base URL (use for local dev) |
+
+Config is stored at `~/.doc2mcp/config.json`.
+
+## Local development
+
+```bash
+cd cli
+pnpm install
+pnpm build
+node dist/index.js --help
+
+# Point at local Next app
+DOC2MCP_API_URL=http://localhost:3000 node dist/index.js login
+```
+
+## Publish
+
+```bash
+cd cli
+pnpm build
+npm publish --access public
+```
+
+Ensure the npm package name `doc2mcp` is available before publishing.

package/dist/index.js

@@ -0,0 +1,579 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import pc6 from "picocolors";
+
+// src/commands/account.ts
+import pc from "picocolors";
+
+// src/store.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_API_URL = "https://doc2mcp.com";
+function getConfigPath() {
+  return join(homedir(), ".doc2mcp", "config.json");
+}
+function getApiUrl() {
+  return process.env.DOC2MCP_API_URL?.replace(/\/$/, "") ?? DEFAULT_API_URL;
+}
+
+// src/store.ts
+async function loadConfig() {
+  try {
+    const raw = await readFile(getConfigPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      apiUrl: parsed.apiUrl || getApiUrl(),
+      token: parsed.token,
+      user: parsed.user
+    };
+  } catch {
+    return { apiUrl: getApiUrl() };
+  }
+}
+async function saveConfig(config) {
+  const path = getConfigPath();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+async function clearConfigToken() {
+  const config = await loadConfig();
+  await saveConfig({
+    apiUrl: config.apiUrl
+  });
+}
+
+// src/commands/account.ts
+async function runLogout() {
+  await clearConfigToken();
+  process.stdout.write(`${pc.green("Logged out.")}
+`);
+}
+async function runWhoami() {
+  const config = await loadConfig();
+  if (!config.token || !config.user) {
+    process.stdout.write(`${pc.yellow("Not logged in.")} Run ${pc.bold("doc2mcp login")}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  process.stdout.write(`${pc.bold(config.user.email)}
+`);
+  if (config.user.name) {
+    process.stdout.write(`${pc.dim(config.user.name)}
+`);
+  }
+  process.stdout.write(`${pc.dim(`API: ${config.apiUrl}`)}
+`);
+}
+
+// src/commands/convert.ts
+import pc5 from "picocolors";
+
+// src/api.ts
+import pc2 from "picocolors";
+var ApiError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+async function parseJson(response) {
+  const text = await response.text();
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+async function apiFetch(path, options = {}) {
+  const config = await loadConfig();
+  const baseUrl = config.apiUrl || getApiUrl();
+  const headers = new Headers(options.headers);
+  headers.set("Content-Type", "application/json");
+  const needsAuth = options.auth !== false;
+  if (needsAuth) {
+    if (!config.token) {
+      throw new ApiError("Not logged in. Run: doc2mcp login", 401, null);
+    }
+    headers.set("Authorization", `Bearer ${config.token}`);
+  }
+  const response = await fetch(`${baseUrl}${path}`, {
+    ...options,
+    headers
+  });
+  const body = await parseJson(response);
+  if (!response.ok) {
+    const message = typeof body === "object" && body !== null && "message" in body && typeof body.message === "string" ? body.message : `Request failed (${response.status})`;
+    throw new ApiError(message, response.status, body);
+  }
+  return body;
+}
+function printError(error) {
+  if (error instanceof ApiError) {
+    process.stderr.write(`${pc2.red("Error:")} ${error.message}
+`);
+    return;
+  }
+  if (error instanceof Error) {
+    process.stderr.write(`${pc2.red("Error:")} ${error.message}
+`);
+    return;
+  }
+  process.stderr.write(`${pc2.red("Error:")} Unknown error
+`);
+}
+
+// src/commands/login.ts
+import open from "open";
+import ora from "ora";
+import pc3 from "picocolors";
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function runLogin() {
+  const config = await loadConfig();
+  const spinner = ora("Starting device authorization\u2026").start();
+  try {
+    const start = await apiFetch("/api/cli/auth/start", {
+      method: "POST",
+      auth: false,
+      body: JSON.stringify({})
+    });
+    spinner.stop();
+    process.stdout.write(
+      `
+${pc3.cyan("Open this link to authorize:")}
+${pc3.bold(start.verifyUrl)}
+
+`
+    );
+    process.stdout.write(
+      `${pc3.dim("Code:")} ${pc3.bold(start.userCode)}  ${pc3.dim("(also shown in browser)")}
+
+`
+    );
+    try {
+      await open(start.verifyUrl);
+    } catch {
+      process.stdout.write(
+        `${pc3.yellow("Could not auto-open browser. Open the link manually.")}
+
+`
+      );
+    }
+    const pollSpinner = ora("Waiting for approval\u2026").start();
+    const deadline = Date.now() + start.expiresIn * 1e3;
+    const intervalMs = start.interval * 1e3;
+    while (Date.now() < deadline) {
+      await sleep(intervalMs);
+      const poll = await apiFetch("/api/cli/auth/poll", {
+        method: "POST",
+        auth: false,
+        body: JSON.stringify({ deviceCode: start.deviceCode })
+      });
+      if (poll.status === "pending") {
+        continue;
+      }
+      if (poll.status === "approved") {
+        pollSpinner.succeed("Authorized");
+        await saveConfig({
+          apiUrl: config.apiUrl || getApiUrl(),
+          token: poll.token,
+          user: poll.user
+        });
+        process.stdout.write(
+          `${pc3.green("Logged in as")} ${poll.user.email}
+`
+        );
+        return;
+      }
+      if (poll.status === "denied") {
+        pollSpinner.fail("Authorization denied");
+        process.exitCode = 1;
+        return;
+      }
+      pollSpinner.fail("Authorization expired");
+      process.exitCode = 1;
+      return;
+    }
+    pollSpinner.fail("Authorization timed out");
+    process.exitCode = 1;
+  } catch (error) {
+    spinner.fail("Login failed");
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+async function ensureLoggedIn() {
+  const config = await loadConfig();
+  if (!config.token) {
+    await runLogin();
+    const next = await loadConfig();
+    if (!next.token) {
+      throw new Error("Login required");
+    }
+  }
+}
+
+// src/commands/install.ts
+import { confirm, multiselect } from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/installers/detect.ts
+import { access } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+async function exists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectClients() {
+  const home = homedir2();
+  const detected = [];
+  const cursorGlobal = join2(home, ".cursor", "mcp.json");
+  const cursorProject = join2(process.cwd(), ".cursor", "mcp.json");
+  if (await exists(cursorGlobal) || await exists(join2(home, ".cursor"))) {
+    detected.push({
+      id: "cursor",
+      label: "Cursor (global ~/.cursor/mcp.json)",
+      configPath: cursorGlobal
+    });
+  } else if (await exists(cursorProject)) {
+    detected.push({
+      id: "cursor",
+      label: "Cursor (project .cursor/mcp.json)",
+      configPath: cursorProject
+    });
+  } else {
+    detected.push({
+      id: "cursor",
+      label: "Cursor (~/.cursor/mcp.json)",
+      configPath: cursorGlobal
+    });
+  }
+  const vscodeProject = join2(process.cwd(), ".vscode", "mcp.json");
+  detected.push({
+    id: "vscode",
+    label: "VS Code (workspace .vscode/mcp.json)",
+    configPath: vscodeProject
+  });
+  const windsurf = join2(home, ".codeium", "windsurf", "mcp_config.json");
+  if (await exists(windsurf) || await exists(join2(home, ".codeium"))) {
+    detected.push({
+      id: "windsurf",
+      label: "Windsurf",
+      configPath: windsurf
+    });
+  }
+  const claudeMac = join2(
+    home,
+    "Library",
+    "Application Support",
+    "Claude",
+    "claude_desktop_config.json"
+  );
+  const claudeWin = join2(
+    home,
+    "AppData",
+    "Roaming",
+    "Claude",
+    "claude_desktop_config.json"
+  );
+  let claudePath = join2(home, ".config", "Claude", "claude_desktop_config.json");
+  if (process.platform === "win32") {
+    claudePath = claudeWin;
+  } else if (process.platform === "darwin") {
+    claudePath = claudeMac;
+  }
+  if (await exists(claudePath) || process.platform === "darwin") {
+    detected.push({
+      id: "claude",
+      label: "Claude Desktop",
+      configPath: claudePath
+    });
+  }
+  return detected;
+}
+
+// src/installers/merge.ts
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function readJsonFile(path) {
+  try {
+    const raw = await readFile2(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+async function writeJsonFile(path, value) {
+  await mkdir2(dirname2(path), { recursive: true });
+  await writeFile2(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function mergeMcpServers(existing, incoming) {
+  const currentServers = existing.mcpServers && typeof existing.mcpServers === "object" ? existing.mcpServers : {};
+  const incomingServers = incoming.mcpServers && typeof incoming.mcpServers === "object" ? incoming.mcpServers : incoming;
+  return {
+    ...existing,
+    mcpServers: {
+      ...currentServers,
+      ...incomingServers
+    }
+  };
+}
+function mergeVscodeMcp(existing, incoming) {
+  const currentServers = existing.servers && typeof existing.servers === "object" ? existing.servers : {};
+  const incomingServers = incoming.servers && typeof incoming.servers === "object" ? incoming.servers : {};
+  return {
+    ...existing,
+    servers: {
+      ...currentServers,
+      ...incomingServers
+    }
+  };
+}
+
+// src/installers/install.ts
+async function installToClient(client, configPath, payload) {
+  if (client === "cursor") {
+    const existing = await readJsonFile(configPath);
+    const merged = mergeMcpServers(existing, payload.cursor);
+    await writeJsonFile(configPath, merged);
+    return;
+  }
+  if (client === "vscode") {
+    const existing = await readJsonFile(configPath);
+    const merged = mergeVscodeMcp(existing, payload.vscode);
+    await writeJsonFile(configPath, merged);
+    return;
+  }
+  if (client === "windsurf") {
+    const existing = await readJsonFile(configPath);
+    const merged = mergeMcpServers(existing, payload.windsurf);
+    await writeJsonFile(configPath, merged);
+    return;
+  }
+  if (client === "claude") {
+    const existing = await readJsonFile(configPath);
+    const merged = mergeMcpServers(existing, payload.claude);
+    await writeJsonFile(configPath, merged);
+  }
+}
+
+// src/commands/install.ts
+async function promptInstall(install) {
+  const shouldInstall = await confirm({
+    message: "Install this MCP into your editor?",
+    initialValue: true
+  });
+  if (shouldInstall !== true) {
+    return;
+  }
+  const clients = await detectClients();
+  const selected = await multiselect({
+    message: "Select clients to install into",
+    options: clients.map((client) => ({
+      value: client.id,
+      label: client.label
+    })),
+    required: true
+  });
+  if (typeof selected === "symbol") {
+    return;
+  }
+  for (const clientId of selected) {
+    const client = clients.find((item) => item.id === clientId);
+    if (!client) {
+      continue;
+    }
+    await installToClient(client.id, client.configPath, install);
+    process.stdout.write(
+      `${pc4.green("Installed")} ${client.label}
+${pc4.dim(client.configPath)}
+`
+    );
+  }
+}
+async function runInstallCommand(projectId) {
+  try {
+    await ensureLoggedIn();
+    const detail = await apiFetch(`/api/cli/projects/${projectId}`);
+    if (!detail.install) {
+      process.stderr.write(`${pc4.red("Project is not ready or missing install bundle.")}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    await promptInstall(detail.install);
+  } catch (error) {
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/convert.ts
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function printStatus(detail) {
+  const { project } = detail;
+  process.stdout.write(
+    `\r${pc5.cyan("Status:")} ${project.status.padEnd(12)} ${pc5.dim(project.name)}`
+  );
+}
+async function runConvert(sourceUrl) {
+  try {
+    await ensureLoggedIn();
+    process.stdout.write(`${pc5.bold("Converting")} ${sourceUrl}
+`);
+    const created = await apiFetch("/api/cli/convert", {
+      method: "POST",
+      body: JSON.stringify({ sourceUrl })
+    });
+    process.stdout.write(`${pc5.dim("Project:")} ${created.id}
+`);
+    let delayMs = 2e3;
+    const terminal = /* @__PURE__ */ new Set(["ready", "error"]);
+    while (true) {
+      const detail = await apiFetch(
+        `/api/cli/projects/${created.id}`
+      );
+      printStatus(detail);
+      if (terminal.has(detail.project.status)) {
+        process.stdout.write("\n");
+        break;
+      }
+      await sleep2(delayMs);
+      delayMs = Math.min(delayMs + 1e3, 1e4);
+    }
+    const finalDetail = await apiFetch(
+      `/api/cli/projects/${created.id}`
+    );
+    if (finalDetail.project.status === "error") {
+      const lastLog = finalDetail.project.logs.at(-1);
+      process.stderr.write(
+        `${pc5.red("Conversion failed.")}${lastLog ? ` ${lastLog.message}` : ""}
+`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    if (!finalDetail.mcp || !finalDetail.install) {
+      process.stderr.write(`${pc5.red("MCP ready but missing install bundle.")}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    process.stdout.write(`
+${pc5.green("MCP ready")}
+`);
+    process.stdout.write(`${pc5.bold("Server:")} ${finalDetail.mcp.serverName}
+`);
+    process.stdout.write(`${pc5.bold("URL:")} ${finalDetail.mcp.url}
+`);
+    process.stdout.write(`${pc5.bold("Token:")} ${finalDetail.mcp.token}
+`);
+    process.stdout.write(
+      `${pc5.dim("Also listed in the doc2mcp marketplace when ready.")}
+`
+    );
+    await promptInstall(finalDetail.install);
+  } catch (error) {
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+async function runList() {
+  try {
+    await ensureLoggedIn();
+    const data = await apiFetch("/api/cli/projects");
+    if (data.projects.length === 0) {
+      process.stdout.write(`${pc5.dim("No projects yet.")}
+`);
+      return;
+    }
+    for (const project of data.projects) {
+      process.stdout.write(
+        `${pc5.bold(project.name)} ${pc5.dim(`[${project.status}]`)} ${project.source}
+`
+      );
+      process.stdout.write(`  ${pc5.dim(project.id)} ${project.sourceUrl ?? ""}
+`);
+    }
+  } catch (error) {
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("doc2mcp").description("Generate documentation MCP servers from your terminal").version("0.1.0");
+program.command("login").description("Authorize the CLI via browser").action(async () => {
+  await runLogin();
+});
+program.command("logout").description("Remove stored credentials").action(async () => {
+  await runLogout();
+});
+program.command("whoami").description("Show the logged-in user").action(async () => {
+  await runWhoami();
+});
+program.command("list").description("List your MCP projects").action(async () => {
+  await runList();
+});
+program.command("install <projectId>").description("Install an existing MCP into Cursor, VS Code, Claude, or Windsurf").action(async (projectId) => {
+  await runInstallCommand(projectId);
+});
+program.argument("[url]", "Documentation URL to convert").action(async (url) => {
+  if (!url) {
+    program.help();
+    return;
+  }
+  try {
+    const parsed = new URL(url);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      throw new Error("URL must start with http:// or https://");
+    }
+  } catch {
+    process.stderr.write(
+      `${pc6.red("Error:")} Invalid URL. Example: doc2mcp https://docs.example.com
+`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  await runConvert(url);
+});
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : "Unknown error";
+  process.stderr.write(`${pc6.red("Error:")} ${message}
+`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "doc2mcp",
+  "version": "0.1.13",
+  "description": "Generate documentation MCP servers from your terminal",
+  "type": "module",
+  "bin": {
+    "doc2mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "mcp",
+    "documentation",
+    "cli",
+    "cursor",
+    "model-context-protocol"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.10.1",
+    "commander": "^13.1.0",
+    "open": "^10.1.0",
+    "ora": "^8.2.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.2"
+  }
+}