@plaud-ai/mcp 0.2.1 → 0.2.2

package/dist/install-EEQXUUG3.js

@@ -0,0 +1,657 @@
+import {
+  getClient
+} from "./chunk-7KGB7GSZ.js";
+import {
+  copyToClipboard,
+  getMcpEntry,
+  writeSkillsToClaudeCode
+} from "./chunk-QT25MKZJ.js";
+import {
+  skillsCombined
+} from "./chunk-4QBEOJPX.js";
+import "./chunk-SNSGVRCU.js";
+
+// src/install.ts
+import { createInterface } from "readline/promises";
+import { createServer } from "http";
+import open from "open";
+
+// src/installers/registry.ts
+import { homedir as homedir4, platform as platform2 } from "os";
+import { join as join4 } from "path";
+
+// src/installers/claude-code.ts
+import { existsSync } from "fs";
+import { spawnSync } from "child_process";
+import { homedir, platform } from "os";
+import { join } from "path";
+var RESTART_HINT = "Exit any running Claude Code session and start a new `claude` session so MCP and Plaud skills load.";
+function claudeCodeDir() {
+  return join(homedir(), ".claude");
+}
+function commandExists(command) {
+  const lookup = platform() === "win32" ? "where" : "which";
+  return spawnSync(lookup, [command], { encoding: "utf-8" }).status === 0;
+}
+function claudeCodeAdapter() {
+  return {
+    id: "claude-code",
+    label: "Claude Code",
+    detect() {
+      const configPath = claudeCodeDir();
+      return { detected: existsSync(configPath), configPath };
+    },
+    async install({ entry }) {
+      const serverCommand = [entry.command, ...entry.args].join(" ");
+      const manualCmd = `claude mcp add --scope user plaud -- ${serverCommand}`;
+      if (!commandExists("claude")) {
+        return {
+          status: "failed",
+          message: `failed: Claude Code CLI not on PATH. Run manually once Claude Code CLI is available:
+  ${manualCmd}`,
+          manualCmd
+        };
+      }
+      spawnSync("claude", ["mcp", "remove", "plaud", "--scope", "user"], { encoding: "utf-8" });
+      const register = spawnSync(
+        "claude",
+        ["mcp", "add", "--scope", "user", "plaud", "--", entry.command, ...entry.args],
+        { encoding: "utf-8" }
+      );
+      if (register.status !== 0) {
+        const err = (register.stderr || register.stdout || "").trim();
+        return {
+          status: "failed",
+          message: `failed: auto-registering MCP failed (${err || "unknown"}). Run manually:
+  ${manualCmd}`,
+          manualCmd
+        };
+      }
+      return {
+        status: "configured",
+        message: "MCP registered at user scope.",
+        restartHint: RESTART_HINT
+      };
+    }
+  };
+}
+
+// src/installers/codex.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2 } from "path";
+var RESTART_HINT2 = "Quit Codex Desktop and reopen it.";
+function codexConfigPath() {
+  return join2(homedir2(), ".codex", "config.toml");
+}
+function quoteTomlString(value) {
+  return JSON.stringify(value);
+}
+function codexAdapter() {
+  return {
+    id: "codex",
+    label: "Codex Desktop",
+    detect() {
+      const configPath = codexConfigPath();
+      return { detected: existsSync2(configPath) || existsSync2(dirname(configPath)), configPath };
+    },
+    async install({ entry }) {
+      const configPath = codexConfigPath();
+      const argsStr = entry.args.map(quoteTomlString).join(", ");
+      const serverEntry = `
+[mcp_servers.plaud]
+command = ${quoteTomlString(entry.command)}
+args = [${argsStr}]
+`;
+      let content = "";
+      try {
+        content = await readFile(configPath, "utf-8");
+      } catch {
+      }
+      if (content.includes("[mcp_servers.plaud]")) {
+        return {
+          status: "already-configured",
+          message: "already configured",
+          restartHint: RESTART_HINT2
+        };
+      }
+      await mkdir(dirname(configPath), { recursive: true });
+      await writeFile(configPath, content + serverEntry, "utf-8");
+      const combined = await skillsCombined();
+      const copied = copyToClipboard(combined);
+      return {
+        status: "configured",
+        message: copied ? "configured. Skills copied to clipboard \u2014 paste into Codex custom instructions, then restart." : "configured. Paste the Plaud skills into Codex custom instructions manually (see docs).",
+        restartHint: RESTART_HINT2
+      };
+    }
+  };
+}
+
+// src/installers/json-mcp-servers.ts
+import { existsSync as existsSync3 } from "fs";
+import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readErrorCode(err) {
+  return isJsonObject(err) && typeof err.code === "string" ? err.code : void 0;
+}
+function jsonMcpServersAdapter(spec) {
+  const rootKey = spec.rootKey ?? "mcpServers";
+  const serverKey = spec.serverKey ?? "plaud";
+  const toEntry = spec.entry ?? ((entry) => entry);
+  return {
+    id: spec.id,
+    label: spec.label,
+    detect() {
+      const configPath = spec.configPath();
+      return {
+        detected: configPath !== null && (existsSync3(configPath) || existsSync3(dirname2(configPath))),
+        configPath: configPath ?? "(unsupported on this OS)"
+      };
+    },
+    async install(ctx) {
+      const configPath = spec.configPath();
+      if (!configPath) {
+        return { status: "skipped", message: spec.unsupportedMessage ?? "skipped (OS not supported)" };
+      }
+      let config = {};
+      try {
+        const raw = await readFile2(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isJsonObject(parsed)) {
+          return { status: "failed", message: `failed: ${configPath} must contain a JSON object.` };
+        }
+        config = parsed;
+      } catch (err) {
+        if (readErrorCode(err) !== "ENOENT") {
+          return { status: "failed", message: `failed: ${configPath} contains invalid JSON. Fix it and retry.` };
+        }
+      }
+      const existingServers = config[rootKey];
+      if (existingServers !== void 0 && !isJsonObject(existingServers)) {
+        return { status: "failed", message: `failed: ${configPath} field ${rootKey} must be a JSON object.` };
+      }
+      const servers = existingServers ?? {};
+      if (servers[serverKey]) {
+        return {
+          status: "already-configured",
+          message: "already configured",
+          restartHint: spec.restartHint
+        };
+      }
+      config[rootKey] = { ...servers, [serverKey]: toEntry(ctx.entry) };
+      await mkdir2(dirname2(configPath), { recursive: true });
+      await writeFile2(configPath, JSON.stringify(config, null, 2), "utf-8");
+      return {
+        status: "configured",
+        message: spec.configuredMessage ?? "configured",
+        restartHint: spec.restartHint
+      };
+    }
+  };
+}
+
+// src/installers/web-client.ts
+function remoteMcpUrl() {
+  const explicit = process.env.PLAUD_REMOTE_MCP_URL?.trim();
+  if (explicit) return explicit;
+  const serverUrl = process.env.PLAUD_SERVER_URL?.trim();
+  if (!serverUrl) return null;
+  return /\/(mcp|sse)\/?$/.test(serverUrl) ? serverUrl : `${serverUrl.replace(/\/+$/, "")}/mcp`;
+}
+function webClientAdapter(spec) {
+  return {
+    id: spec.id,
+    label: spec.label,
+    manualOnly: true,
+    detect() {
+      return { detected: true, configPath: "remote connector (manual setup)" };
+    },
+    async install() {
+      const url = remoteMcpUrl();
+      const remoteLine = url ? `Remote MCP URL: ${url}` : "Remote MCP URL: not configured. Deploy `plaud-mcp http` behind HTTPS, then rerun with PLAUD_REMOTE_MCP_URL=https://your-host.example/mcp.";
+      return {
+        status: "configured",
+        requiresLocalAuth: false,
+        restartHint: `Finish setup in ${spec.label}; no local restart is needed.`,
+        message: [
+          "manual setup only:",
+          `  Open: ${spec.setupUrl}`,
+          `  ${remoteLine}`,
+          `  Step: ${spec.setupStep}`
+        ].join("\n")
+      };
+    }
+  };
+}
+
+// src/installers/zed.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname3, join as join3 } from "path";
+var RESTART_HINT3 = "Restart Zed to load the Plaud MCP.";
+function zedConfigPath() {
+  return join3(homedir3(), ".config", "zed", "settings.json");
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readErrorCode2(err) {
+  return isJsonObject2(err) && typeof err.code === "string" ? err.code : void 0;
+}
+function zedAdapter() {
+  return {
+    id: "zed",
+    label: "Zed",
+    detect() {
+      const configPath = zedConfigPath();
+      return { detected: existsSync4(configPath) || existsSync4(dirname3(configPath)), configPath };
+    },
+    async install({ entry }) {
+      const configPath = zedConfigPath();
+      let config = {};
+      try {
+        const parsed = JSON.parse(await readFile3(configPath, "utf-8"));
+        if (!isJsonObject2(parsed)) {
+          return { status: "failed", message: `failed: ${configPath} must contain a JSON object.` };
+        }
+        config = parsed;
+      } catch (err) {
+        if (readErrorCode2(err) !== "ENOENT") {
+          return { status: "failed", message: `failed: ${configPath} contains invalid JSON. Fix it and retry.` };
+        }
+      }
+      const existingServers = config.context_servers;
+      if (existingServers !== void 0 && !isJsonObject2(existingServers)) {
+        return { status: "failed", message: `failed: ${configPath} field context_servers must be a JSON object.` };
+      }
+      const servers = existingServers ?? {};
+      if (servers.plaud) {
+        return { status: "already-configured", message: "already configured", restartHint: RESTART_HINT3 };
+      }
+      config.context_servers = {
+        ...servers,
+        plaud: { command: { path: entry.command, args: entry.args } }
+      };
+      await mkdir3(dirname3(configPath), { recursive: true });
+      await writeFile3(configPath, JSON.stringify(config, null, 2), "utf-8");
+      return {
+        status: "configured",
+        message: "configured. Restart Zed to load the Plaud MCP.",
+        restartHint: RESTART_HINT3
+      };
+    }
+  };
+}
+
+// src/installers/registry.ts
+var CLAUDE_DESKTOP_RESTART = "Fully quit Claude Desktop (\u2318Q on macOS) and reopen it \u2014 closing the window is not enough.";
+function claudeDesktopConfigPath() {
+  if (platform2() === "darwin") {
+    return join4(homedir4(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  if (platform2() === "win32") {
+    return join4(process.env.APPDATA ?? "", "Claude", "claude_desktop_config.json");
+  }
+  return null;
+}
+function cursorConfigPath() {
+  return join4(homedir4(), ".cursor", "mcp.json");
+}
+function windsurfConfigPath() {
+  return join4(homedir4(), ".codeium", "windsurf", "mcp_config.json");
+}
+function vsCodeConfigPath() {
+  return join4(process.cwd(), ".vscode", "mcp.json");
+}
+var adapters = [
+  jsonMcpServersAdapter({
+    id: "claude-desktop",
+    label: "Claude Desktop",
+    configPath: claudeDesktopConfigPath,
+    configuredMessage: "configured. Restart Claude Desktop to load the Plaud MCP.",
+    restartHint: CLAUDE_DESKTOP_RESTART
+  }),
+  claudeCodeAdapter(),
+  codexAdapter(),
+  jsonMcpServersAdapter({
+    id: "cursor",
+    label: "Cursor",
+    configPath: cursorConfigPath,
+    configuredMessage: "configured. Restart Cursor to load the Plaud MCP.",
+    restartHint: "Restart Cursor to load the Plaud MCP."
+  }),
+  jsonMcpServersAdapter({
+    id: "windsurf",
+    label: "Windsurf",
+    configPath: windsurfConfigPath,
+    configuredMessage: "configured. Restart Windsurf to load the Plaud MCP.",
+    restartHint: "Restart Windsurf to load the Plaud MCP."
+  }),
+  jsonMcpServersAdapter({
+    id: "vscode",
+    label: "VS Code",
+    configPath: vsCodeConfigPath,
+    rootKey: "servers",
+    entry: (entry) => ({ type: "stdio", command: entry.command, args: entry.args }),
+    configuredMessage: "configured. Restart VS Code to load the Plaud MCP.",
+    restartHint: "Restart VS Code to load the Plaud MCP."
+  }),
+  zedAdapter(),
+  webClientAdapter({
+    id: "claude-web",
+    label: "Claude Web",
+    setupUrl: "https://claude.ai/customize/connectors",
+    setupStep: "Click +, choose Add custom connector, paste the Remote MCP URL, then connect."
+  }),
+  webClientAdapter({
+    id: "chatgpt-web",
+    label: "ChatGPT Web",
+    setupUrl: "https://chatgpt.com/apps",
+    setupStep: "Open Settings > Apps, enable Developer mode if needed, create an app from the Remote MCP URL, then connect."
+  })
+];
+
+// src/install.ts
+var promptInterface = null;
+var pipedAnswers = null;
+var pipedAnswersPromise = null;
+function detectClients() {
+  return adapters.map((adapter) => ({ adapter, id: adapter.id, label: adapter.label, ...adapter.detect() }));
+}
+async function prompt(question, defaultYes = true) {
+  const hint = defaultYes ? "Y/n" : "y/N";
+  let answer;
+  if (!process.stdin.isTTY) {
+    process.stdout.write(`${question} [${hint}] `);
+    pipedAnswers ??= await (pipedAnswersPromise ??= readPipedAnswers());
+    answer = (pipedAnswers.shift() ?? "").trim().toLowerCase();
+  } else {
+    promptInterface ??= createInterface({ input: process.stdin, output: process.stdout });
+    answer = (await promptInterface.question(`${question} [${hint}] `)).trim().toLowerCase();
+  }
+  if (answer === "") return defaultYes;
+  return answer.startsWith("y");
+}
+async function readPipedAnswers() {
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += Buffer.isBuffer(chunk) ? chunk.toString("utf-8") : String(chunk);
+  }
+  return input.split(/\r?\n/);
+}
+function closePrompt() {
+  promptInterface?.close();
+  promptInterface = null;
+  pipedAnswers = null;
+  pipedAnswersPromise = null;
+}
+var CALLBACK_PORT = 8199;
+var LOGIN_TIMEOUT_MS = 12e4;
+function pickIdentity(user) {
+  for (const k of ["email", "username", "name", "id"]) {
+    const v = user[k];
+    if (typeof v === "string" && v.length > 0) return v;
+  }
+  return void 0;
+}
+async function runLogin() {
+  const client = getClient();
+  try {
+    const existing = await client.auth.getAccessToken();
+    if (existing) {
+      try {
+        const user = await client.getCurrentUser();
+        return { status: "already-authed", who: pickIdentity(user) };
+      } catch {
+        return { status: "already-authed" };
+      }
+    }
+  } catch {
+    await client.auth.logout().catch(() => void 0);
+  }
+  const { url, codeVerifier, state } = client.auth.createAuthorizationRequest();
+  return new Promise((resolve) => {
+    const httpServer = createServer(async (req, res) => {
+      const reqUrl = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);
+      if (reqUrl.pathname !== "/auth/callback") {
+        res.writeHead(404);
+        res.end();
+        return;
+      }
+      const code = reqUrl.searchParams.get("code");
+      if (!code) {
+        res.writeHead(400);
+        res.end("Missing code");
+        cleanup();
+        resolve({ status: "failed", message: "missing authorization code in callback" });
+        return;
+      }
+      try {
+        await client.auth.exchangeCode(code, codeVerifier, state);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<h1>Authentication successful!</h1><p>You can close this tab.</p>");
+        cleanup();
+        let who;
+        try {
+          const user = await client.getCurrentUser();
+          who = pickIdentity(user);
+        } catch {
+        }
+        resolve({ status: "success", who });
+      } catch (err) {
+        res.writeHead(500, { "Content-Type": "text/html" });
+        res.end("<h1>Token exchange failed</h1>");
+        cleanup();
+        resolve({ status: "failed", message: err instanceof Error ? err.message : String(err) });
+      }
+    });
+    let timeoutId;
+    function cleanup() {
+      clearTimeout(timeoutId);
+      httpServer.closeAllConnections?.();
+      httpServer.close();
+    }
+    timeoutId = setTimeout(() => {
+      cleanup();
+      resolve({ status: "timeout" });
+    }, LOGIN_TIMEOUT_MS);
+    httpServer.listen(CALLBACK_PORT, () => {
+      console.log(`  if no browser opens, open this URL while this command is still running:
+  ${url}`);
+      open(url).catch(() => {
+        console.log("  browser launch failed \u2014 waiting for a manual browser callback.");
+      });
+    });
+    httpServer.on("error", (err) => {
+      cleanup();
+      resolve({ status: "failed", message: `callback server error: ${err.message}` });
+    });
+  });
+}
+async function runInstall(opts = {}) {
+  console.log("Plaud MCP installer\n");
+  const clients = detectClients();
+  console.log("Detected AI clients:");
+  for (const c of clients) {
+    const mark = c.detected ? "\u2713" : "\xB7";
+    console.log(`  ${mark} ${c.label.padEnd(16)} ${c.detected ? c.configPath : "(not detected)"}`);
+  }
+  console.log();
+  const selected = [];
+  if (opts.yes) {
+    for (const c of clients) {
+      if (c.detected && !c.adapter.manualOnly) selected.push(c);
+    }
+    if (selected.length > 0) {
+      console.log(`--yes: configuring ${selected.map((c) => c.label).join(", ")} without prompting.
+`);
+    }
+  } else {
+    for (const c of clients) {
+      if (!c.detected) continue;
+      const yes = await prompt(`Configure ${c.label}?`, true);
+      if (yes) selected.push(c);
+    }
+  }
+  if (selected.length === 0) {
+    console.log("\nNothing to configure. Exiting.");
+    closePrompt();
+    process.exit(0);
+  }
+  console.log();
+  const entry = getMcpEntry();
+  const succeeded = [];
+  for (const c of selected) {
+    process.stdout.write(`\u2192 ${c.label}... `);
+    try {
+      const result = await c.adapter.install({ entry, yes: Boolean(opts.yes) });
+      console.log(result.message);
+      if (isSuccessResult(result)) {
+        succeeded.push({
+          id: c.id,
+          label: c.label,
+          restartHint: result.restartHint,
+          requiresLocalAuth: result.requiresLocalAuth ?? true
+        });
+      }
+    } catch (err) {
+      console.log(`failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  if (succeeded.some((c) => c.id === "claude-code")) {
+    process.stdout.write("\u2192 Claude Code skills... ");
+    try {
+      await writeSkillsToClaudeCode();
+      console.log("written to ~/.claude/CLAUDE.md.");
+    } catch (err) {
+      console.log(`failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const needsLocalAuth = succeeded.some((c) => c.requiresLocalAuth);
+  const loginOutcome = opts.noLogin || !needsLocalAuth ? null : await doLoginStep(Boolean(opts.yes));
+  printNextSteps(succeeded, loginOutcome);
+  closePrompt();
+  process.exit(0);
+}
+function isSuccessResult(result) {
+  return result.status === "configured" || result.status === "already-configured";
+}
+async function doLoginStep(nonInteractive) {
+  console.log();
+  console.log("\u2192 Authenticating with Plaud...");
+  const client = getClient();
+  try {
+    const existing = await client.auth.getAccessToken();
+    if (existing) {
+      try {
+        const user = await client.getCurrentUser();
+        const who = pickIdentity(user);
+        console.log(`  already signed in${who ? ` as ${who}` : ""} \u2014 skipping OAuth.`);
+        return { status: "already-authed", who };
+      } catch {
+        console.log("  token present but user lookup failed \u2014 will re-auth.");
+      }
+    }
+  } catch {
+  }
+  if (!nonInteractive) {
+    const yes = await prompt("Log in to Plaud now? (opens browser)", true);
+    if (!yes) {
+      console.log("  skipped \u2014 you'll be prompted on first tool call after restart.");
+      return null;
+    }
+  }
+  console.log("  opening browser \u2014 click Authorize to finish.");
+  const outcome = await runLogin();
+  switch (outcome.status) {
+    case "already-authed":
+      console.log(`  already signed in${outcome.who ? ` as ${outcome.who}` : ""}.`);
+      break;
+    case "success":
+      console.log(`  \u2713 authenticated${outcome.who ? ` as ${outcome.who}` : ""}.`);
+      break;
+    case "timeout":
+      console.log("  \u2717 timed out after 2 minutes \u2014 you can retry with `plaud-mcp install --yes` or run `login` from your AI client.");
+      break;
+    case "failed":
+      console.log(`  \u2717 failed: ${outcome.message}`);
+      break;
+  }
+  return outcome;
+}
+function printNextSteps(clients, login) {
+  console.log();
+  if (clients.length === 0) {
+    console.log("No clients were configured. Nothing to do.");
+    return;
+  }
+  const localClients = clients.filter((c) => c.requiresLocalAuth);
+  const webClients = clients.filter((c) => !c.requiresLocalAuth);
+  const authed = login?.status === "already-authed" || login?.status === "success";
+  const bar = "\u2500".repeat(60);
+  console.log(bar);
+  console.log(`\u2713 Plaud MCP ${localClients.length > 0 ? "installed" : "setup instructions shown"} for: ${clients.map((c) => c.label).join(", ")}`);
+  if (authed) {
+    console.log(`\u2713 Authenticated${login?.who ? ` as ${login.who}` : ""}`);
+  }
+  console.log(bar);
+  console.log();
+  if (localClients.length === 0) {
+    console.log("NEXT \u2014 finish setup in the web UI:");
+    console.log();
+    for (const c of webClients) {
+      console.log(`  ${c.label}: ${c.restartHint}`);
+    }
+    console.log();
+    console.log(bar);
+    return;
+  }
+  if (authed) {
+    console.log("NEXT \u2014 one thing left:");
+    console.log();
+    if (localClients.length === 1) {
+      console.log(`  ${localClients[0].restartHint}`);
+    } else {
+      console.log("  Restart each configured client:");
+      for (const c of localClients) {
+        console.log(`    \u2022 ${c.label}: ${c.restartHint}`);
+      }
+    }
+    console.log();
+    console.log("  After restart, Plaud tools are live \u2014 just ask your AI client");
+    console.log('  about your recordings (e.g. "list my recent Plaud recordings").');
+  } else {
+    console.log("NEXT \u2014 do these two things:");
+    console.log();
+    if (localClients.length === 1) {
+      console.log(`  1. ${localClients[0].restartHint}`);
+    } else {
+      console.log("  1. Restart each configured client:");
+      for (const c of localClients) {
+        console.log(`       \u2022 ${c.label}: ${c.restartHint}`);
+      }
+    }
+    console.log();
+    console.log("  2. In any chat with your AI client, type:");
+    console.log();
+    console.log("       list my recent Plaud recordings");
+    console.log();
+    console.log("     This triggers OAuth in your browser (once). Tokens are then");
+    console.log("     stored in ~/.plaud/tokens-mcp.json and refreshed automatically.");
+  }
+  if (webClients.length > 0) {
+    console.log();
+    console.log("  Web clients: finish setup using the connector instructions above.");
+  }
+  console.log();
+  console.log(bar);
+}
+export {
+  runInstall
+};