@plaud-ai/mcp 0.1.58 → 0.2.1

package/dist/chunk-4QBEOJPX.js

@@ -0,0 +1,92 @@
+// src/skills.ts
+import { readdir, readFile } from "fs/promises";
+import { statSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---\n")) return { meta: {}, body: raw };
+  const end = raw.indexOf("\n---\n", 4);
+  if (end === -1) return { meta: {}, body: raw };
+  const yaml = raw.slice(4, end);
+  const body = raw.slice(end + 5);
+  const meta = {};
+  let currentKey = null;
+  for (const line of yaml.split("\n")) {
+    if (!line.trim()) continue;
+    const topMatch = line.match(/^([a-zA-Z_][\w-]*):\s*(.*)$/);
+    if (topMatch && !line.startsWith(" ")) {
+      const [, k, v] = topMatch;
+      currentKey = k;
+      if (v !== "") {
+        const unq = v.replace(/^["']|["']$/g, "");
+        meta[k] = unq;
+        currentKey = null;
+      } else {
+        meta[k] = {};
+      }
+    }
+  }
+  return { meta, body };
+}
+function findSkillsDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "skills"),
+    resolve(here, "..", "..", "skills")
+  ];
+  for (const c of candidates) {
+    try {
+      if (statSync(c).isDirectory()) return c;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+var cached = null;
+async function loadSkills() {
+  if (cached) return cached;
+  const dir = findSkillsDir();
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    cached = [];
+    return cached;
+  }
+  const skills = [];
+  for (const name of entries) {
+    try {
+      const skillPath = join(dir, name, "SKILL.md");
+      const raw = await readFile(skillPath, "utf-8");
+      const { meta, body } = parseFrontmatter(raw);
+      const skillName = typeof meta.name === "string" ? meta.name : name;
+      const description = typeof meta.description === "string" ? meta.description : "";
+      const version = typeof meta.version === "string" ? meta.version : "0.0.0";
+      skills.push({
+        name: skillName,
+        version,
+        description,
+        body: body.trimStart(),
+        content: raw,
+        supported: true
+      });
+    } catch {
+    }
+  }
+  skills.sort((a, b) => {
+    if (a.name === "plaud-shared") return -1;
+    if (b.name === "plaud-shared") return 1;
+    return a.name.localeCompare(b.name);
+  });
+  cached = skills;
+  return cached;
+}
+async function skillsCombined() {
+  const skills = await loadSkills();
+  return skills.map((s) => s.content).join("\n\n---\n\n");
+}
+
+export {
+  loadSkills,
+  skillsCombined
+};

package/dist/chunk-7KGB7GSZ.js

@@ -0,0 +1,33 @@
+import {
+  PlaudClient
+} from "./chunk-SNSGVRCU.js";
+
+// src/config.ts
+function buildExtraHeaders() {
+  const headers = {};
+  if (process.env.PLAUD_ENV) headers["x-pld-env"] = process.env.PLAUD_ENV;
+  if (process.env.PLAUD_REGION) headers["x-pld-region"] = process.env.PLAUD_REGION;
+  return headers;
+}
+var CONFIG = {
+  clientId: process.env.PLAUD_MCP_CLIENT_ID ?? process.env.PLAUD_CLIENT_ID ?? "client_9c501dad-8a0d-40b2-a7b0-d1cb8787f674",
+  clientSecret: process.env.PLAUD_CLIENT_SECRET ?? "",
+  redirectUri: "http://localhost:8199/auth/callback",
+  tokenFile: "tokens-mcp.json",
+  apiBase: process.env.PLAUD_API_BASE,
+  authorizationUrl: process.env.PLAUD_AUTH_URL,
+  tokenUrl: process.env.PLAUD_TOKEN_URL,
+  refreshUrl: process.env.PLAUD_REFRESH_URL,
+  extraHeaders: buildExtraHeaders()
+};
+var client = null;
+function getClient() {
+  if (!client) {
+    client = new PlaudClient(CONFIG);
+  }
+  return client;
+}
+
+export {
+  getClient
+};

package/dist/chunk-K22WPZ7P.js

@@ -0,0 +1,79 @@
+import {
+  skillsCombined
+} from "./chunk-4QBEOJPX.js";
+
+// src/install-utils.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join, dirname } from "path";
+import { homedir, platform } from "os";
+import { spawnSync } from "child_process";
+var SKILLS_MARKER_START = "<!-- plaud-skills:start -->";
+var SKILLS_MARKER_END = "<!-- plaud-skills:end -->";
+function findNpxCommand() {
+  const npxName = platform() === "win32" ? "npx.cmd" : "npx";
+  const found = spawnSync(platform() === "win32" ? "where" : "which", [npxName], { encoding: "utf-8" });
+  const firstMatch = found.status === 0 ? found.stdout.split(/\r?\n/).find((line) => line.trim())?.trim() : void 0;
+  if (firstMatch) return firstMatch;
+  const sibling = join(dirname(process.execPath), npxName);
+  return existsSync(sibling) ? sibling : npxName;
+}
+function getMcpEntry() {
+  return {
+    command: findNpxCommand(),
+    args: ["-y", "@plaud-ai/mcp@latest"]
+  };
+}
+function copyToClipboard(content) {
+  if (platform() === "win32") {
+    return spawnSync("clip", [], { input: content }).status === 0;
+  }
+  if (platform() === "darwin") {
+    return spawnSync("pbcopy", [], { input: content }).status === 0;
+  }
+  return false;
+}
+async function writeSkillsToClaudeCode() {
+  const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+  const combined = await skillsCombined();
+  const block = `${SKILLS_MARKER_START}
+${combined}
+${SKILLS_MARKER_END}`;
+  let existing = "";
+  try {
+    existing = await readFile(claudeMdPath, "utf-8");
+  } catch {
+  }
+  if (existing.includes(SKILLS_MARKER_START)) {
+    const updated = existing.replace(
+      new RegExp(`${SKILLS_MARKER_START}[\\s\\S]*?${SKILLS_MARKER_END}`),
+      block
+    );
+    await mkdir(dirname(claudeMdPath), { recursive: true });
+    await writeFile(claudeMdPath, updated, "utf-8");
+  } else {
+    await mkdir(dirname(claudeMdPath), { recursive: true });
+    await writeFile(claudeMdPath, existing + (existing.endsWith("\n") ? "" : "\n") + block + "\n", "utf-8");
+  }
+}
+async function removeSkillsFromClaudeCode() {
+  const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+  let existing = "";
+  try {
+    existing = await readFile(claudeMdPath, "utf-8");
+  } catch {
+    return;
+  }
+  if (!existing.includes(SKILLS_MARKER_START)) {
+    return;
+  }
+  const updated = existing.replace(new RegExp(`\\n?${SKILLS_MARKER_START}[\\s\\S]*?${SKILLS_MARKER_END}\\n?`), "").trimEnd();
+  await writeFile(claudeMdPath, updated ? updated + "\n" : "", "utf-8");
+}
+
+export {
+  getMcpEntry,
+  copyToClipboard,
+  writeSkillsToClaudeCode,
+  removeSkillsFromClaudeCode
+};

package/dist/chunk-MPCF6HMK.js

@@ -0,0 +1,151 @@
+// src/logger.ts
+import pino from "pino";
+var logger = pino(
+  { level: process.env.LOG_LEVEL ?? "info" },
+  pino.destination(2)
+);
+
+// src/tools/index.ts
+import { z } from "zod";
+var MAX_FILTER_PAGES = 5;
+var FILTER_PAGE_SIZE = 100;
+function parseDate(s) {
+  if (!s) return null;
+  const d = new Date(s);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.getTime();
+}
+function registerTools(server, client) {
+  server.tool(
+    "list_files",
+    "List Plaud recordings. Supports optional client-side filtering: `query` (case-insensitive name substring), `date_from`/`date_to` (YYYY-MM-DD, inclusive). When any filter is set, paginates up to 5 pages \xD7 100 recordings and returns all matches.",
+    {
+      page: z.number().optional().default(1).describe("Page number (ignored when filters are set)"),
+      page_size: z.number().optional().default(20).describe("Items per page (ignored when filters are set)"),
+      query: z.string().optional().describe("Case-insensitive substring match on recording name"),
+      date_from: z.string().optional().describe("Start date inclusive, YYYY-MM-DD"),
+      date_to: z.string().optional().describe("End date inclusive, YYYY-MM-DD")
+    },
+    async ({ page, page_size, query, date_from, date_to }) => {
+      const start = Date.now();
+      const hasFilter = Boolean(query || date_from || date_to);
+      logger.info({ event: "tool_call", tool: "list_files", has_filter: hasFilter });
+      try {
+        if (!hasFilter) {
+          const result = await client.listFiles(page, page_size);
+          logger.info({ event: "tool_call_end", tool: "list_files", duration_ms: Date.now() - start });
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        const q = query?.toLowerCase();
+        const from = parseDate(date_from);
+        const toRaw = parseDate(date_to);
+        const to = toRaw !== null ? toRaw + 24 * 60 * 60 * 1e3 - 1 : null;
+        const matches = [];
+        let scanned = 0;
+        let truncated = false;
+        for (let p = 1; p <= MAX_FILTER_PAGES; p++) {
+          const pageResult = await client.listFiles(p, FILTER_PAGE_SIZE);
+          const items = pageResult.data;
+          scanned += items.length;
+          for (const item of items) {
+            if (q && !(item.name ?? "").toLowerCase().includes(q)) continue;
+            if (from !== null || to !== null) {
+              const created = parseDate(item.created_at);
+              if (created === null) continue;
+              if (from !== null && created < from) continue;
+              if (to !== null && created > to) continue;
+            }
+            matches.push(item);
+          }
+          if (items.length < FILTER_PAGE_SIZE) break;
+          if (p === MAX_FILTER_PAGES) truncated = true;
+        }
+        logger.info({ event: "tool_call_end", tool: "list_files", duration_ms: Date.now() - start, scanned, matched: matches.length, truncated });
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            data: matches,
+            scanned,
+            matched: matches.length,
+            truncated,
+            note: truncated ? `Scanned first ${MAX_FILTER_PAGES * FILTER_PAGE_SIZE} recordings; narrow filters for a complete match.` : void 0
+          }, null, 2) }]
+        };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "list_files", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to list files: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_file",
+    "Get details of a specific Plaud recording by ID",
+    { file_id: z.string().describe("The file ID to retrieve") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_file", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_file", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file, null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_file", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get file: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_note",
+    "Fetch AI-generated notes for a Plaud recording \u2014 compact summary, action items, and key topics",
+    { file_id: z.string().describe("The file ID to retrieve notes for") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_note", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_note", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file.note_list ?? [], null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_note", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get note: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_transcript",
+    "Fetch the full timestamped transcript with speaker attribution for a Plaud recording",
+    { file_id: z.string().describe("The file ID to retrieve transcript for") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_transcript", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_transcript", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file.source_list ?? [], null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_transcript", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get transcript: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_current_user",
+    "Get current authenticated user info",
+    async () => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_current_user" });
+      try {
+        const user = await client.getCurrentUser();
+        logger.info({ event: "tool_call_end", tool: "get_current_user", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(user, null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_current_user", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get user info: ${err}` }], isError: true };
+      }
+    }
+  );
+}
+
+export {
+  logger,
+  registerTools
+};

package/dist/{chunk-YMQLKZLW.js → chunk-SNSGVRCU.js}

@@ -229,106 +229,6 @@ var PlaudClient = class {
   }
 };
 
-// src/logger.ts
-import pino from "pino";
-var logger = pino({
-  level: process.env.LOG_LEVEL ?? "info"
-});
-
-// src/tools/index.ts
-import { z } from "zod";
-function registerTools(server, client) {
-  server.tool(
-    "list_files",
-    "List Plaud recordings",
-    {
-      page: z.number().optional().default(1).describe("Page number"),
-      page_size: z.number().optional().default(20).describe("Items per page")
-    },
-    async ({ page, page_size }) => {
-      const start = Date.now();
-      logger.info({ event: "tool_call", tool: "list_files" });
-      try {
-        const result = await client.listFiles(page, page_size);
-        logger.info({ event: "tool_call_end", tool: "list_files", duration_ms: Date.now() - start });
-        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-      } catch (err) {
-        logger.error({ event: "tool_call_error", tool: "list_files", duration_ms: Date.now() - start, error: String(err) });
-        return { content: [{ type: "text", text: `Failed to list files: ${err}` }], isError: true };
-      }
-    }
-  );
-  server.tool(
-    "get_file",
-    "Get details of a specific Plaud recording by ID",
-    { file_id: z.string().describe("The file ID to retrieve") },
-    async ({ file_id }) => {
-      const start = Date.now();
-      logger.info({ event: "tool_call", tool: "get_file", file_id });
-      try {
-        const file = await client.getFile(file_id);
-        logger.info({ event: "tool_call_end", tool: "get_file", duration_ms: Date.now() - start });
-        return { content: [{ type: "text", text: JSON.stringify(file, null, 2) }] };
-      } catch (err) {
-        logger.error({ event: "tool_call_error", tool: "get_file", duration_ms: Date.now() - start, error: String(err) });
-        return { content: [{ type: "text", text: `Failed to get file: ${err}` }], isError: true };
-      }
-    }
-  );
-  server.tool(
-    "get_note",
-    "Fetch AI-generated notes for a Plaud recording \u2014 compact summary, action items, and key topics",
-    { file_id: z.string().describe("The file ID to retrieve notes for") },
-    async ({ file_id }) => {
-      const start = Date.now();
-      logger.info({ event: "tool_call", tool: "get_note", file_id });
-      try {
-        const file = await client.getFile(file_id);
-        logger.info({ event: "tool_call_end", tool: "get_note", duration_ms: Date.now() - start });
-        return { content: [{ type: "text", text: JSON.stringify(file.note_list ?? [], null, 2) }] };
-      } catch (err) {
-        logger.error({ event: "tool_call_error", tool: "get_note", duration_ms: Date.now() - start, error: String(err) });
-        return { content: [{ type: "text", text: `Failed to get note: ${err}` }], isError: true };
-      }
-    }
-  );
-  server.tool(
-    "get_transcript",
-    "Fetch the full timestamped transcript with speaker attribution for a Plaud recording",
-    { file_id: z.string().describe("The file ID to retrieve transcript for") },
-    async ({ file_id }) => {
-      const start = Date.now();
-      logger.info({ event: "tool_call", tool: "get_transcript", file_id });
-      try {
-        const file = await client.getFile(file_id);
-        logger.info({ event: "tool_call_end", tool: "get_transcript", duration_ms: Date.now() - start });
-        return { content: [{ type: "text", text: JSON.stringify(file.source_list ?? [], null, 2) }] };
-      } catch (err) {
-        logger.error({ event: "tool_call_error", tool: "get_transcript", duration_ms: Date.now() - start, error: String(err) });
-        return { content: [{ type: "text", text: `Failed to get transcript: ${err}` }], isError: true };
-      }
-    }
-  );
-  server.tool(
-    "get_current_user",
-    "Get current authenticated user info",
-    async () => {
-      const start = Date.now();
-      logger.info({ event: "tool_call", tool: "get_current_user" });
-      try {
-        const user = await client.getCurrentUser();
-        logger.info({ event: "tool_call_end", tool: "get_current_user", duration_ms: Date.now() - start });
-        return { content: [{ type: "text", text: JSON.stringify(user, null, 2) }] };
-      } catch (err) {
-        logger.error({ event: "tool_call_error", tool: "get_current_user", duration_ms: Date.now() - start, error: String(err) });
-        return { content: [{ type: "text", text: `Failed to get user info: ${err}` }], isError: true };
-      }
-    }
-  );
-}
-
 export {
-  PlaudClient,
-  logger,
-  registerTools
+  PlaudClient
 };

package/dist/index.js

@@ -1,58 +1,33 @@
 #!/usr/bin/env node
 import {
-  ACTIVE_SKILLS
-} from "./chunk-7PYQFJJW.js";
+  getClient
+} from "./chunk-7KGB7GSZ.js";
+import {
+  loadSkills
+} from "./chunk-4QBEOJPX.js";
 import {
-  PlaudClient,
   registerTools
-} from "./chunk-YMQLKZLW.js";
+} from "./chunk-MPCF6HMK.js";
+import "./chunk-SNSGVRCU.js";
 
 // src/index.ts
 import { createServer } from "http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import open from "open";
-
-// src/config.ts
-function buildExtraHeaders() {
-  const headers = {};
-  if (process.env.PLAUD_ENV) headers["x-pld-env"] = process.env.PLAUD_ENV;
-  if (process.env.PLAUD_REGION) headers["x-pld-region"] = process.env.PLAUD_REGION;
-  return headers;
-}
-var CONFIG = {
-  clientId: process.env.PLAUD_MCP_CLIENT_ID ?? process.env.PLAUD_CLIENT_ID ?? "client_9c501dad-8a0d-40b2-a7b0-d1cb8787f674",
-  clientSecret: process.env.PLAUD_CLIENT_SECRET ?? "",
-  redirectUri: "http://localhost:8199/auth/callback",
-  tokenFile: "tokens-mcp.json",
-  apiBase: process.env.PLAUD_API_BASE,
-  authorizationUrl: process.env.PLAUD_AUTH_URL,
-  tokenUrl: process.env.PLAUD_TOKEN_URL,
-  refreshUrl: process.env.PLAUD_REFRESH_URL,
-  extraHeaders: buildExtraHeaders()
-};
-var client = null;
-function getClient() {
-  if (!client) {
-    client = new PlaudClient(CONFIG);
-  }
-  return client;
-}
-
-// src/index.ts
 var server = new McpServer({
   name: "plaud",
-  version: "0.1.0"
+  version: "0.2.0"
 });
 var CALLBACK_PORT = 8199;
 var LOGIN_TIMEOUT_MS = 12e4;
 server.tool("login", "Log in, sign in, or authenticate with Plaud account via OAuth (opens browser)", async () => {
-  const client2 = getClient();
-  const existingToken = await client2.auth.getAccessToken();
+  const client = getClient();
+  const existingToken = await client.auth.getAccessToken();
   if (existingToken) {
     return { content: [{ type: "text", text: "Already logged in." }] };
   }
-  const { url, codeVerifier, state } = client2.auth.createAuthorizationRequest();
+  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}`);
@@ -73,7 +48,7 @@ server.tool("login", "Log in, sign in, or authenticate with Plaud account via OA
         return;
       }
       try {
-        await client2.auth.exchangeCode(code, codeVerifier, state);
+        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();
@@ -106,10 +81,14 @@ server.tool("login", "Log in, sign in, or authenticate with Plaud account via OA
     }, LOGIN_TIMEOUT_MS);
     httpServer.listen(CALLBACK_PORT, () => {
       open(url).catch(() => {
-        cleanup();
         resolve({
-          content: [{ type: "text", text: `Could not open browser automatically. Please open this URL to authenticate:
-${url}` }],
+          content: [{
+            type: "text",
+            text: `Could not open browser automatically. Open this URL within 2 minutes to authenticate:
+${url}
+
+If this is a remote/headless machine, forward local port 8199 to this machine first, then open the URL locally.`
+          }],
           isError: true
         });
       });
@@ -125,56 +104,87 @@ ${url}` }],
 });
 registerTools(server, getClient());
 server.tool("logout", "Log out, sign out, revoke authorization, and disconnect from Plaud account", async () => {
-  const client2 = getClient();
-  const existingToken = await client2.auth.getAccessToken();
+  const client = getClient();
+  const existingToken = await client.auth.getAccessToken();
   if (!existingToken) {
     return { content: [{ type: "text", text: "Already logged out." }] };
   }
   try {
-    await client2.revokeCurrentUser();
+    await client.revokeCurrentUser();
   } catch {
   }
-  await client2.auth.logout();
+  await client.auth.logout();
   return {
     content: [{ type: "text", text: "Logged out and revoked authorization." }]
   };
 });
-for (const skill of ACTIVE_SKILLS) {
-  server.prompt(skill.name, skill.description, () => ({
-    messages: [{ role: "user", content: { type: "text", text: skill.content } }]
-  }));
+async function registerSkillPrompts() {
+  const skills = await loadSkills();
+  for (const skill of skills) {
+    server.prompt(skill.name, skill.description, () => ({
+      messages: [{ role: "user", content: { type: "text", text: skill.content } }]
+    }));
+  }
 }
 async function main() {
-  if (process.argv[2] === "clean-plugin") {
-    const { runCleanPlugin } = await import("./setup-KGUMS567.js");
+  const sub = process.argv[2];
+  const sub2 = process.argv[3];
+  if (sub === "install") {
+    const { runInstall } = await import("./install-I2N3DJG4.js");
+    const args = process.argv.slice(3);
+    const yes = args.some((a) => a === "--yes" || a === "-y");
+    const noLogin = args.some((a) => a === "--no-login");
+    await runInstall({ yes, noLogin });
+    return;
+  }
+  if (sub === "clean-plugin") {
+    const { runCleanPlugin } = await import("./setup-QRUDA7ES.js");
     await runCleanPlugin();
     return;
   }
-  if (process.argv[2] === "setup" && process.argv[3] === "codex") {
-    const { runSetupCodex } = await import("./setup-KGUMS567.js");
+  if (sub === "setup" && sub2 === "codex") {
+    const { runSetupCodex } = await import("./setup-QRUDA7ES.js");
     await runSetupCodex();
     return;
   }
-  if (process.argv[2] === "unsetup" && process.argv[3] === "codex") {
-    const { runUnsetupCodex } = await import("./setup-KGUMS567.js");
+  if (sub === "unsetup" && sub2 === "codex") {
+    const { runUnsetupCodex } = await import("./setup-QRUDA7ES.js");
     await runUnsetupCodex();
     return;
   }
-  if (process.argv[2] === "setup") {
-    const { runSetup } = await import("./setup-KGUMS567.js");
+  if (sub === "setup") {
+    const { runSetup } = await import("./setup-QRUDA7ES.js");
     await runSetup();
     return;
   }
-  if (process.argv[2] === "unsetup") {
-    const { runUnsetup } = await import("./setup-KGUMS567.js");
+  if (sub === "unsetup") {
+    const { runUnsetup } = await import("./setup-QRUDA7ES.js");
     await runUnsetup();
     return;
   }
-  if (process.argv[2] === "http") {
-    const { startHttpServer } = await import("./server-5L7BYLYR.js");
+  if (sub === "http") {
+    const { startHttpServer } = await import("./server-D3H6AMVD.js");
     startHttpServer();
     return;
   }
+  if (sub === "--help" || sub === "-h") {
+    console.log(`plaud-mcp \u2014 Plaud MCP server
+
+Usage:
+  plaud-mcp                  start MCP over stdio
+  plaud-mcp install             detect AI clients, configure them, and run OAuth inline (recommended)
+  plaud-mcp install --yes       non-interactive; auto-configure every detected client (for agent-driven install)
+  plaud-mcp install --no-login  skip the OAuth step (for CI / headless setup)
+  plaud-mcp http             start HTTP MCP server (advanced)
+  plaud-mcp setup            [deprecated] alias for install (Claude Desktop only)
+  plaud-mcp setup codex      [deprecated] alias for install (Codex only)
+  plaud-mcp unsetup          remove Plaud from Claude Desktop
+  plaud-mcp unsetup codex    remove Plaud from Codex Desktop
+  plaud-mcp clean-plugin     clear Claude Code plugin cache
+`);
+    return;
+  }
+  await registerSkillPrompts();
   const transport = new StdioServerTransport();
   await server.connect(transport);
 }