@uzqw/mcp 0.1.0

package/dist/chunk-DEIK42FS.js

@@ -0,0 +1,83 @@
+// src/skills.ts
+import { cp, mkdir, readFile, readdir, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join, 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 = {};
+  for (const line of yaml.split("\n")) {
+    const match = line.match(/^([a-zA-Z_][\w-]*):\s*(.*)$/);
+    if (match && !line.startsWith(" ")) {
+      const [, k, v] = match;
+      if (v !== "") meta[k] = v.replace(/^["']|["']$/g, "");
+    }
+  }
+  return { meta, body };
+}
+function findSkillsDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return resolve(here, "..", "skills");
+}
+async function loadSkills() {
+  const dir = findSkillsDir();
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    return [];
+  }
+  const skills = [];
+  for (const name of entries) {
+    try {
+      const raw = await readFile(join(dir, name, "SKILL.md"), "utf-8");
+      const { meta } = parseFrontmatter(raw);
+      skills.push({
+        name: meta.name ?? name,
+        dir: name,
+        version: meta.version ?? "0.0.0",
+        description: meta.description ?? "",
+        content: raw.trim()
+      });
+    } catch {
+    }
+  }
+  return skills.sort((a, b) => a.name === "recolx-shared" ? -1 : b.name === "recolx-shared" ? 1 : a.name.localeCompare(b.name));
+}
+function installHome() {
+  return process.env.RECOLX_INSTALL_HOME ?? homedir();
+}
+async function installSkillsToClaudeCode() {
+  const skills = await loadSkills();
+  const destRoot = join(installHome(), ".claude", "skills");
+  await mkdir(destRoot, { recursive: true });
+  const installed = [];
+  for (const skill of skills) {
+    await cp(join(findSkillsDir(), skill.dir), join(destRoot, skill.dir), { recursive: true, force: true });
+    installed.push(skill.name);
+  }
+  return installed;
+}
+async function removeSkillsFromClaudeCode() {
+  const skills = await loadSkills();
+  const destRoot = join(installHome(), ".claude", "skills");
+  for (const skill of skills) {
+    await rm(join(destRoot, skill.dir), { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function skillsInstalledMessage(installed) {
+  if (installed.length === 0) return "skills \u76EE\u5F55\u4E3A\u7A7A\uFF0C\u672A\u5B89\u88C5";
+  return `\u5DF2\u5B89\u88C5 ${installed.length} \u4E2A skill \u5230 ~/.claude/skills/\uFF08${installed.join(", ")}\uFF09`;
+}
+
+export {
+  loadSkills,
+  installSkillsToClaudeCode,
+  removeSkillsFromClaudeCode,
+  skillsInstalledMessage
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+import {
+  loadSkills
+} from "./chunk-DEIK42FS.js";
+
+// src/index.ts
+import { writeFileSync } from "fs";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import open from "open";
+import { RecolxClient, runOAuthCallback, LoginInput, LogoutInput } from "@uzqw/shared";
+
+// src/tools.ts
+import {
+  GetCurrentUserInput,
+  ListFilesInput,
+  GetFileInput,
+  GetNoteInput,
+  GetTranscriptInput,
+  localDayStart,
+  localDayEnd
+} from "@uzqw/shared";
+var MAX_FILTER_PAGES = 5;
+var FILTER_PAGE_SIZE = 100;
+var TRANSCRIPT_PAGE_SIZE = 50;
+var READ_ONLY = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+function encodeTranscriptCursor(offset) {
+  return Buffer.from(JSON.stringify({ o: offset }), "utf8").toString("base64url");
+}
+function decodeTranscriptCursor(cursor) {
+  try {
+    const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+    if (typeof parsed.o === "number" && Number.isInteger(parsed.o) && parsed.o >= 0) return parsed.o;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function errText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function registerTools(server2, client2) {
+  server2.registerTool(
+    "get_current_user",
+    {
+      description: "\u83B7\u53D6\u5F53\u524D\u767B\u5F55\u7528\u6237\u7684\u8D26\u53F7\u4FE1\u606F\u4E0E\u8BA2\u9605\u6863\uFF08Pro \u989D\u5EA6/\u4F59\u91CF\uFF09\uFF0C\u7528\u4E8E\u5224\u65AD\u767B\u5F55\u6001\u4E0E\u989D\u5EA6\u95F8\u95E8",
+      annotations: { title: "\u83B7\u53D6\u5F53\u524D\u7528\u6237", ...READ_ONLY },
+      inputSchema: GetCurrentUserInput
+    },
+    async () => {
+      try {
+        const me = await client2.getCurrentUser();
+        return { content: [{ type: "text", text: JSON.stringify(me, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `\u83B7\u53D6\u7528\u6237\u4FE1\u606F\u5931\u8D25\uFF1A${errText(err)}` }], isError: true };
+      }
+    }
+  );
+  server2.registerTool(
+    "list_files",
+    {
+      description: "\u5217\u51FA\u5F55\u97F3\u6587\u4EF6\u3002\u652F\u6301\u5BA2\u6237\u7AEF\u8FC7\u6EE4\uFF1A`query`\uFF08\u6807\u9898\u5927\u5C0F\u5199\u4E0D\u654F\u611F\u5B50\u4E32\uFF09\u3001`date_from`/`date_to`\uFF08YYYY-MM-DD\uFF0C\u542B\u8FB9\u754C\uFF09\u3002\u8BBE\u8FC7\u6EE4\u65F6\u6700\u591A\u626B 5 \u9875 \xD7 100 \u6761\u5E76\u8FD4\u56DE\u5168\u90E8\u5339\u914D",
+      annotations: { title: "\u5217\u51FA\u5F55\u97F3", ...READ_ONLY },
+      inputSchema: ListFilesInput
+    },
+    async ({ page, page_size, query, date_from, date_to }) => {
+      try {
+        const hasFilter = Boolean(query || date_from || date_to);
+        if (!hasFilter) {
+          const result = await client2.listFiles(page, page_size);
+          return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        const q = query?.toLowerCase();
+        const from = localDayStart(date_from);
+        const to = localDayEnd(date_to);
+        const files = [];
+        let scanned = 0;
+        let truncated = false;
+        for (let p = 1; p <= MAX_FILTER_PAGES; p++) {
+          const pageResult = await client2.listFiles(p, FILTER_PAGE_SIZE);
+          const items = pageResult.files ?? [];
+          scanned += items.length;
+          for (const item of items) {
+            const title = String(item.title ?? "");
+            if (q && !title.toLowerCase().includes(q)) continue;
+            if (from !== null || to !== null) {
+              const recordedMs = Number(item.recorded_at) * 1e3;
+              if (Number.isNaN(recordedMs)) continue;
+              if (from !== null && recordedMs < from) continue;
+              if (to !== null && recordedMs > to) continue;
+            }
+            files.push(item);
+          }
+          if (items.length < FILTER_PAGE_SIZE) break;
+          if (p === MAX_FILTER_PAGES) truncated = true;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  files,
+                  scanned,
+                  matched: files.length,
+                  truncated,
+                  note: truncated ? `\u53EA\u626B\u4E86\u524D ${MAX_FILTER_PAGES * FILTER_PAGE_SIZE} \u6761\u5F55\u97F3\uFF1B\u8BF7\u7F29\u5C0F\u8FC7\u6EE4\u6761\u4EF6\u4EE5\u83B7\u5F97\u5B8C\u6574\u7ED3\u679C\u3002` : void 0
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: `\u5217\u51FA\u5F55\u97F3\u5931\u8D25\uFF1A${errText(err)}` }], isError: true };
+      }
+    }
+  );
+  server2.registerTool(
+    "get_file",
+    {
+      description: "\u83B7\u53D6\u5355\u4E2A\u5F55\u97F3\u7684\u8BE6\u60C5\uFF1A\u6807\u9898\u3001\u65F6\u957F\u3001\u8BBE\u5907\uFF08serial + \u578B\u53F7\uFF09\u300124h \u97F3\u9891 presign \u4E0B\u8F7D\u5730\u5740",
+      annotations: { title: "\u83B7\u53D6\u5F55\u97F3\u8BE6\u60C5", ...READ_ONLY },
+      inputSchema: GetFileInput
+    },
+    async ({ file_id }) => {
+      try {
+        const file = await client2.getFile(file_id);
+        let text = JSON.stringify(file, null, 2);
+        if (!file.presigned_url) {
+          text += "\n\n\u63D0\u793A\uFF1Apresigned_url\uFF0824h \u97F3\u9891\u4E0B\u8F7D\u5730\u5740\uFF09\u4E3A\u7A7A\u2014\u2014\u97F3\u9891\u53EF\u80FD\u5C1A\u672A\u5C31\u7EEA\uFF0C\u7A0D\u540E\u91CD\u8BD5 get_file \u83B7\u53D6\u3002";
+        }
+        return { content: [{ type: "text", text }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `\u83B7\u53D6\u6587\u4EF6\u8BE6\u60C5\u5931\u8D25\uFF1A${errText(err)}` }], isError: true };
+      }
+    }
+  );
+  server2.registerTool(
+    "get_note",
+    {
+      description: "\u83B7\u53D6\u5F55\u97F3\u7684\u7B14\u8BB0/\u6458\u8981\uFF0C\u6309\u6A21\u677F tab \u8FD4\u56DE\uFF1Asummary \u6570\u7EC4\u6BCF\u9879\u542B prompt_id/prompt_name\u3002\u4F20 `template`\uFF08\u6A21\u677F\u540D\u6216\u6A21\u677F id\uFF09\u65F6\u53EA\u8FD4\u56DE\u5339\u914D\u6A21\u677F\uFF1B\u7F3A\u7701\u8FD4\u56DE\u5168\u90E8",
+      annotations: { title: "\u83B7\u53D6\u5F55\u97F3\u7B14\u8BB0", ...READ_ONLY },
+      inputSchema: GetNoteInput
+    },
+    async ({ file_id, template }) => {
+      try {
+        const file = await client2.getFile(file_id, { includeTranscript: true });
+        const summaries = file.transcript?.summary ?? [];
+        if (summaries.length === 0) {
+          return { content: [{ type: "text", text: "\u8BE5\u5F55\u97F3\u6682\u65E0\u7B14\u8BB0/\u6458\u8981\uFF08\u53EF\u80FD\u5C1A\u672A\u751F\u6210\uFF09\u3002" }] };
+        }
+        const matched = template ? summaries.filter(
+          (s) => s.prompt_id === template || (s.prompt_name ?? "").toLowerCase().includes(template.toLowerCase())
+        ) : summaries;
+        if (matched.length === 0) {
+          const available = summaries.map((s) => `\`${s.prompt_name}\`\uFF08${s.prompt_id}\uFF09`).join("\u3001");
+          return {
+            content: [{ type: "text", text: `\u672A\u627E\u5230\u6A21\u677F\u300C${template}\u300D\u3002\u53EF\u7528\u6A21\u677F\uFF1A${available}` }]
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(matched, null, 2) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: `\u83B7\u53D6\u7B14\u8BB0\u5931\u8D25\uFF1A${errText(err)}` }], isError: true };
+      }
+    }
+  );
+  server2.registerTool(
+    "get_transcript",
+    {
+      description: "\u83B7\u53D6\u5F55\u97F3\u7684\u8F6C\u5199\uFF08\u4FDD\u7559 language/speaker\uFF09\u3002\u9ED8\u8BA4 raw \u539F\u6587\uFF1B\u540E\u7AEF\u6682\u672A\u63D0\u4F9B polish \u6DA6\u8272\u3002\u652F\u6301 language/speaker \u8FC7\u6EE4\u4E0E cursor \u5206\u9875\uFF08\u6BCF\u6B21 50 \u6761\uFF09",
+      annotations: { title: "\u83B7\u53D6\u5F55\u97F3\u8F6C\u5199", ...READ_ONLY },
+      inputSchema: GetTranscriptInput
+    },
+    async ({ file_id, cursor, language, speaker, mode }) => {
+      try {
+        if (mode === "polish") {
+          return {
+            content: [
+              { type: "text", text: "\u540E\u7AEF\u6682\u672A\u63D0\u4F9B polish \u6DA6\u8272\u8F6C\u5199\uFF0C\u5F53\u524D\u53EA\u6709 raw \u539F\u6587\uFF1B\u7701\u7565 mode \u6216\u4F20 raw \u83B7\u53D6\u3002" }
+            ]
+          };
+        }
+        const file = await client2.getFile(file_id, { includeTranscript: true });
+        const transcript = file.transcript;
+        const all = transcript?.segments ?? [];
+        if (all.length === 0) {
+          return { content: [{ type: "text", text: "\u8BE5\u5F55\u97F3\u6682\u65E0\u8F6C\u5199\uFF08\u53EF\u80FD\u4ECD\u5728\u5904\u7406\u4E2D\uFF09\u3002" }] };
+        }
+        const filtered = all.filter((s) => {
+          if (language && (s.language ?? "") !== language) return false;
+          if (speaker && !(s.speaker ?? "").includes(speaker)) return false;
+          return true;
+        });
+        let offset = 0;
+        if (cursor !== void 0) {
+          const decoded = decodeTranscriptCursor(cursor);
+          if (decoded === null) {
+            return { content: [{ type: "text", text: "\u6E38\u6807\u65E0\u6548\u3002\u7701\u7565 cursor \u4ECE\u5934\u5F00\u59CB\u3002" }], isError: true };
+          }
+          offset = decoded;
+        }
+        const page = filtered.slice(offset, offset + TRANSCRIPT_PAGE_SIZE);
+        const next = offset + page.length;
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  file_id,
+                  language: transcript?.language ?? null,
+                  mode: "raw",
+                  total: filtered.length,
+                  offset,
+                  limit: TRANSCRIPT_PAGE_SIZE,
+                  returned: page.length,
+                  next_cursor: next < filtered.length ? encodeTranscriptCursor(next) : null,
+                  segments: page
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: `\u83B7\u53D6\u8F6C\u5199\u5931\u8D25\uFF1A${errText(err)}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/index.ts
+var CALLBACK_PORT = 8199;
+var LOGIN_TIMEOUT_MS = 12e4;
+var sub = process.argv[2];
+if (sub === "install" || sub === "uninstall") {
+  const { runInstall, runUninstall } = await import("./install-VFWABBBV.js");
+  const args = process.argv.slice(3);
+  const yes = args.includes("--yes") || args.includes("-y");
+  const noLogin = args.includes("--no-login");
+  if (sub === "install") await runInstall({ yes, noLogin });
+  else await runUninstall({ yes });
+  process.exit(0);
+}
+if (sub === "--help" || sub === "-h") {
+  console.log(`recolx-mcp \u2014 Recolx MCP server\uFF08\u53EA\u8BFB\uFF0C7 \u4E2A tool\uFF09
+
+\u7528\u6CD5\uFF1A
+  recolx-mcp                  \u4EE5 stdio \u542F\u52A8 MCP server\uFF08Claude/Codex/Cursor/Zed \u7B49\u5BA2\u6237\u7AEF\u9ED8\u8BA4\u8DEF\u5F84\uFF09
+  recolx-mcp install          \u68C0\u6D4B\u5E76\u5199\u5165\u672C\u5730\u5BA2\u6237\u7AEF\u914D\u7F6E\uFF08Claude Desktop / Codex / Claude Code / Cursor / Windsurf / VS Code / Zed\uFF09
+  recolx-mcp install --yes    \u5168\u81EA\u52A8\uFF1A\u4E0D\u8BE2\u95EE\uFF0C\u76F4\u63A5\u914D\u7F6E\u6240\u6709\u68C0\u6D4B\u5230\u7684\u5BA2\u6237\u7AEF
+  recolx-mcp install --no-login  \u8DF3\u8FC7 OAuth \u767B\u5F55\uFF08CI / \u8DF3\u677F\u673A\uFF09
+  recolx-mcp uninstall        \u79FB\u9664\u5404\u5BA2\u6237\u7AEF\u91CC\u7684 recolx MCP \u914D\u7F6E
+`);
+  process.exit(0);
+}
+var server = new McpServer({ name: "recolx", version: "0.1.0" });
+var client = new RecolxClient({});
+var READ_ONLY2 = { readOnlyHint: true, destructiveHint: false, openWorldHint: true };
+server.registerTool(
+  "login",
+  {
+    description: "\u767B\u5F55 Recolx\uFF08OAuth PKCE\uFF09\uFF1A\u6253\u5F00\u6D4F\u89C8\u5668\u8DF3\u8F6C\u6388\u6743\u9875\uFF0C\u540C\u610F\u540E\u5728\u672C\u5730 8199 \u56DE\u8C03\u6536\u53D6 token \u5E76\u5199\u5165 ~/.recolx/tokens-mcp.json\uFF1B\u5DF2\u767B\u5F55\u65F6\u76F4\u63A5\u8FD4\u56DE",
+    annotations: { title: "\u767B\u5F55 Recolx", ...READ_ONLY2 },
+    inputSchema: LoginInput
+  },
+  async () => {
+    const existingToken = await client.auth.getAccessToken();
+    if (existingToken) {
+      try {
+        await client.getCurrentUser();
+        return { content: [{ type: "text", text: "\u5DF2\u767B\u5F55\u3002" }] };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("401") || msg.includes("\u672A\u767B\u5F55")) {
+          await client.auth.logout();
+        } else {
+          return { content: [{ type: "text", text: `\u767B\u5F55\u6001\u6821\u9A8C\u5931\u8D25\uFF1A${msg}` }], isError: true };
+        }
+      }
+    }
+    const devUserId = process.env.RECOLX_DEV_USER_ID;
+    const authReq = client.auth.createAuthorizationRequest(devUserId ? { user_id: devUserId } : {});
+    const authUrlFile = process.env.RECOLX_DEV_AUTH_URL_FILE;
+    const result = await runOAuthCallback({
+      port: CALLBACK_PORT,
+      expectedState: authReq.state,
+      timeoutMs: LOGIN_TIMEOUT_MS,
+      exchangeCode: (code) => client.auth.exchangeCode(code, authReq.codeVerifier),
+      onListening: () => {
+        if (authUrlFile) {
+          writeFileSync(authUrlFile, `${authReq.url}
+`, "utf8");
+          return;
+        }
+        open(authReq.url).catch(() => {
+        });
+      }
+    });
+    switch (result.status) {
+      case "success": {
+        let nickname = "";
+        try {
+          const me = await client.getCurrentUser();
+          if (me?.nickname) nickname = `\uFF08${me.nickname}\uFF09`;
+        } catch {
+        }
+        return { content: [{ type: "text", text: `\u5DF2\u767B\u5F55 Recolx${nickname}\u3002` }] };
+      }
+      case "timeout":
+        return {
+          content: [
+            {
+              type: "text",
+              text: `\u6388\u6743\u8D85\u65F6\uFF082 \u5206\u949F\uFF09\u3002\u82E5\u6D4F\u89C8\u5668\u672A\u81EA\u52A8\u6253\u5F00\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\uFF1A
+${authReq.url}
+
+\u8FDC\u7A0B/\u65E0\u5934\u673A\u5668\u9700\u5148\u8F6C\u53D1\u672C\u5730\u7AEF\u53E3 ${CALLBACK_PORT}\uFF1Assh -L ${CALLBACK_PORT}:localhost:${CALLBACK_PORT}`
+            }
+          ],
+          isError: true
+        };
+      case "denied":
+        return {
+          content: [{ type: "text", text: `\u6388\u6743\u88AB\u62D2\u7EDD\uFF1A${result.error?.message ?? "\u7528\u6237\u53D6\u6D88\u6388\u6743"}` }],
+          isError: true
+        };
+      case "exchange-failed":
+        return {
+          content: [{ type: "text", text: `\u6388\u6743\u5931\u8D25\uFF1A${result.error?.message ?? "code \u6362 token \u5931\u8D25"}` }],
+          isError: true
+        };
+      case "listen-failed":
+        return {
+          content: [{ type: "text", text: `\u56DE\u8C03\u670D\u52A1\u542F\u52A8\u5931\u8D25\uFF1A${result.error?.message ?? "\u672A\u77E5\u9519\u8BEF"}` }],
+          isError: true
+        };
+    }
+  }
+);
+server.registerTool(
+  "logout",
+  {
+    description: "\u767B\u51FA\u5E76\u64A4\u9500 Recolx \u6388\u6743\uFF1A\u8C03\u670D\u52A1\u7AEF revoke\uFF08\u5F53\u524D access + \u5168\u90E8 refresh \u5931\u6548\uFF09\uFF0C\u5220\u9664\u672C\u5730 token \u6587\u4EF6\uFF1B\u4E0D\u5F71\u54CD App \u767B\u5F55",
+    annotations: { title: "\u767B\u51FA Recolx", ...READ_ONLY2 },
+    inputSchema: LogoutInput
+  },
+  async () => {
+    const existingToken = await client.auth.getAccessToken();
+    if (!existingToken) {
+      return { content: [{ type: "text", text: "\u5C1A\u672A\u767B\u5F55\u3002" }] };
+    }
+    try {
+      await client.revokeCurrentUser();
+    } catch {
+    }
+    await client.auth.logout();
+    return { content: [{ type: "text", text: "\u5DF2\u767B\u51FA\u5E76\u64A4\u9500\u6388\u6743\u3002" }] };
+  }
+);
+registerTools(server, client);
+try {
+  const skills = await loadSkills();
+  for (const skill of skills) {
+    server.registerPrompt(skill.name, { description: skill.description }, () => ({
+      messages: [{ role: "user", content: { type: "text", text: skill.content } }]
+    }));
+  }
+} catch {
+}
+var transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/install-VFWABBBV.js

@@ -0,0 +1,611 @@
+import {
+  installSkillsToClaudeCode,
+  removeSkillsFromClaudeCode,
+  skillsInstalledMessage
+} from "./chunk-DEIK42FS.js";
+
+// src/install.ts
+import { existsSync, writeFileSync } from "fs";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { homedir, platform } from "os";
+import { dirname, join } from "path";
+import { spawnSync } from "child_process";
+import { createInterface } from "readline/promises";
+import open from "open";
+import { RecolxClient, runOAuthCallback } from "@uzqw/shared";
+var SERVER_NAME = "recolx";
+var CALLBACK_PORT = 8199;
+var LOGIN_TIMEOUT_MS = 12e4;
+function findNodeBinCommand(command) {
+  const commandName = platform() === "win32" ? `${command}.cmd` : command;
+  const sibling = join(dirname(process.execPath), commandName);
+  if (existsSync(sibling)) return sibling;
+  const found = spawnSync(platform() === "win32" ? "where" : "which", [commandName], { encoding: "utf-8" });
+  const firstMatch = found.status === 0 ? found.stdout.split(/\r?\n/).find((l) => l.trim())?.trim() : void 0;
+  if (firstMatch) return firstMatch;
+  return commandName;
+}
+function isLocalPackageSpec(spec) {
+  return spec.endsWith(".tgz") || spec.startsWith(".") || spec.startsWith("/") || /^[A-Za-z]:[\\/]/.test(spec);
+}
+function getMcpEntry() {
+  const packageSpec = process.env.RECOLX_MCP_PACKAGE_SPEC?.trim() || "@uzqw/mcp@latest";
+  if (isLocalPackageSpec(packageSpec)) {
+    return { command: findNodeBinCommand("npm"), args: ["exec", "--yes", "--package", packageSpec, "--", "recolx-mcp"] };
+  }
+  return { command: findNodeBinCommand("npx"), args: ["-y", packageSpec] };
+}
+function commandPathIsStale(command) {
+  if (!command) return false;
+  if (command.includes("fnm_multishells")) return true;
+  const isAbsolute = command.startsWith("/") || /^[A-Za-z]:[\\/]/.test(command);
+  return isAbsolute && !existsSync(command);
+}
+function normalizeWindowsPath(p, plat = platform()) {
+  return plat === "win32" ? p.replace(/\\/g, "/") : p;
+}
+function claudeDesktopConfigPath(plat, home, appData) {
+  if (plat === "darwin") return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  if (plat === "win32") return `${appData}\\Claude\\claude_desktop_config.json`;
+  return null;
+}
+function installHome() {
+  return process.env.RECOLX_INSTALL_HOME ?? homedir();
+}
+function configPaths() {
+  const h = installHome();
+  return {
+    claudeDesktop: claudeDesktopConfigPath(platform(), h, process.env.APPDATA ?? ""),
+    codex: join(h, ".codex", "config.toml"),
+    cursor: join(h, ".cursor", "mcp.json"),
+    windsurf: join(h, ".codeium", "windsurf", "mcp_config.json"),
+    vsCode: join(process.cwd(), ".vscode", "mcp.json"),
+    zed: join(h, ".config", "zed", "settings.json"),
+    claudeCodeDir: join(h, ".claude")
+  };
+}
+function isJsonObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isEnoent(err) {
+  return isJsonObject(err) && err.code === "ENOENT";
+}
+function entryAutoUpdates(entry) {
+  if (!isJsonObject(entry)) return false;
+  const args = Array.isArray(entry.args) ? entry.args : [];
+  return args.some((a) => typeof a === "string" && a.includes("@uzqw/mcp@latest"));
+}
+function jsonAdapter(spec) {
+  const rootKey = spec.rootKey ?? "mcpServers";
+  const toEntry = spec.toEntry ?? ((e) => ({ command: e.command, args: e.args }));
+  async function load() {
+    try {
+      const parsed = JSON.parse(await readFile(spec.configPath, "utf8"));
+      if (!isJsonObject(parsed)) return { error: `failed: ${spec.configPath} \u4E0D\u662F JSON \u5BF9\u8C61` };
+      return { config: parsed, exists: true };
+    } catch (err) {
+      if (!isEnoent(err)) return { error: `failed: ${spec.configPath} \u542B\u65E0\u6548 JSON\uFF0C\u4FEE\u590D\u540E\u91CD\u8BD5` };
+      return { config: {}, exists: false };
+    }
+  }
+  return {
+    id: spec.id,
+    label: spec.label,
+    detect() {
+      if (!spec.configPath) return { detected: false, configPath: "(unsupported on this OS)" };
+      return {
+        detected: existsSync(spec.configPath) || existsSync(dirname(spec.configPath)),
+        configPath: spec.configPath
+      };
+    },
+    async install(ctx) {
+      if (!spec.configPath) return { status: "skipped", message: "\u6B64\u64CD\u4F5C\u7CFB\u7EDF\u4E0D\u652F\u6301" };
+      const loaded = await load();
+      if ("error" in loaded) return { status: "failed", message: loaded.error };
+      const servers = isJsonObject(loaded.config[rootKey]) ? loaded.config[rootKey] : {};
+      const existing = servers[SERVER_NAME];
+      if (existing && entryAutoUpdates(existing)) {
+        const cmd = isJsonObject(existing) && typeof existing.command === "string" ? existing.command : void 0;
+        if (!commandPathIsStale(cmd)) {
+          return { status: "already-configured", message: "\u5DF2\u914D\u7F6E\uFF08npx @latest \u81EA\u52A8\u66F4\u65B0\uFF09", restartHint: spec.restartHint };
+        }
+      }
+      loaded.config[rootKey] = { ...servers, [SERVER_NAME]: toEntry(ctx.entry) };
+      await mkdir(dirname(spec.configPath), { recursive: true });
+      await writeFile(spec.configPath, JSON.stringify(loaded.config, null, 2) + "\n", "utf8");
+      return { status: "configured", message: spec.configuredMessage, restartHint: spec.restartHint };
+    },
+    async uninstall() {
+      if (!spec.configPath) return { status: "skipped", message: "\u6B64\u64CD\u4F5C\u7CFB\u7EDF\u4E0D\u652F\u6301" };
+      const loaded = await load();
+      if ("error" in loaded) return { status: "failed", message: loaded.error };
+      if (!loaded.exists) return { status: "skipped", message: "\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8DF3\u8FC7" };
+      const servers = isJsonObject(loaded.config[rootKey]) ? loaded.config[rootKey] : {};
+      if (!(SERVER_NAME in servers)) return { status: "skipped", message: "\u672A\u914D\u7F6E recolx\uFF0C\u8DF3\u8FC7" };
+      const next = { ...servers };
+      delete next[SERVER_NAME];
+      if (Object.keys(next).length > 0) loaded.config[rootKey] = next;
+      else delete loaded.config[rootKey];
+      await writeFile(spec.configPath, JSON.stringify(loaded.config, null, 2) + "\n", "utf8");
+      return { status: "configured", message: "\u5DF2\u79FB\u9664", restartHint: spec.restartHint };
+    }
+  };
+}
+var CODEX_HEADER = "[mcp_servers.recolx]";
+function codexBlockText(entry) {
+  const win = platform() === "win32";
+  const command = win ? normalizeWindowsPath(entry.command, "win32") : entry.command;
+  const args = (win ? entry.args.map((a) => normalizeWindowsPath(a, "win32")) : entry.args).map((a) => JSON.stringify(a)).join(", ");
+  return `${CODEX_HEADER}
+command = ${JSON.stringify(command)}
+args = [${args}]`;
+}
+function codexBlockRange(lines) {
+  const start = lines.findIndex((l) => l.trim() === CODEX_HEADER);
+  if (start === -1) return null;
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i++) {
+    if (/^\s*\[/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  return { start, end };
+}
+function extractTomlCommand(lines) {
+  for (const line of lines) {
+    const m = line.match(/^\s*command\s*=\s*("(?:[^"\\]|\\.)*")\s*$/);
+    if (m) {
+      try {
+        return JSON.parse(m[1]);
+      } catch {
+        return void 0;
+      }
+    }
+  }
+  return void 0;
+}
+function codexAdapter(configPath) {
+  return {
+    id: "codex",
+    label: "Codex",
+    detect() {
+      return { detected: existsSync(configPath) || existsSync(dirname(configPath)), configPath };
+    },
+    async install(ctx) {
+      let content = "";
+      try {
+        content = await readFile(configPath, "utf8");
+      } catch (err) {
+        if (!isEnoent(err)) return { status: "failed", message: `failed: ${configPath} \u8BFB\u53D6\u5931\u8D25` };
+      }
+      const lines = content.split("\n");
+      const range = codexBlockRange(lines);
+      const block = codexBlockText(ctx.entry);
+      if (range) {
+        const existingCommand = extractTomlCommand(lines.slice(range.start, range.end));
+        if (!commandPathIsStale(existingCommand)) {
+          return { status: "already-configured", message: "\u5DF2\u914D\u7F6E\uFF08npx @latest \u81EA\u52A8\u66F4\u65B0\uFF09" };
+        }
+        const rebuilt = [...lines.slice(0, range.start), ...block.split("\n"), ...lines.slice(range.end)].join("\n");
+        await mkdir(dirname(configPath), { recursive: true });
+        await writeFile(configPath, rebuilt, "utf8");
+        return { status: "configured", message: "\u5DF2\u4FEE\u590D\u5931\u6548\u542F\u52A8\u8DEF\u5F84\uFF08npx @latest\uFF09" };
+      }
+      await mkdir(dirname(configPath), { recursive: true });
+      await writeFile(configPath, `${content}${content && !content.endsWith("\n") ? "\n" : ""}
+${block}
+`, "utf8");
+      return { status: "configured", message: "\u5DF2\u5199\u5165 [mcp_servers.recolx]" };
+    },
+    async uninstall() {
+      let content = "";
+      try {
+        content = await readFile(configPath, "utf8");
+      } catch (err) {
+        if (isEnoent(err)) return { status: "skipped", message: "\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8DF3\u8FC7" };
+        return { status: "failed", message: `${configPath} \u8BFB\u53D6\u5931\u8D25` };
+      }
+      const lines = content.split("\n");
+      const range = codexBlockRange(lines);
+      if (!range) return { status: "skipped", message: "\u672A\u914D\u7F6E recolx\uFF0C\u7701\u7565" };
+      const rebuilt = [...lines.slice(0, range.start), ...lines.slice(range.end)].join("\n").replace(/\n{3,}/g, "\n\n");
+      await writeFile(configPath, rebuilt, "utf8");
+      return { status: "configured", message: "\u5DF2\u79FB\u9664" };
+    }
+  };
+}
+var CLAUDE_CODE_RESTART = "\u9000\u51FA\u5F53\u524D Claude Code \u4F1A\u8BDD\uFF0C\u65B0\u5F00 `claude` \u4F1A\u8BDD\u4EE5\u52A0\u8F7D MCP";
+function commandExists(command) {
+  const lookup = platform() === "win32" ? "where" : "which";
+  return spawnSync(lookup, [command], { encoding: "utf-8" }).status === 0;
+}
+function claudeCodeAdapter(claudeCodeDir) {
+  return {
+    id: "claude-code",
+    label: "Claude Code",
+    detect() {
+      return { detected: existsSync(claudeCodeDir), configPath: claudeCodeDir };
+    },
+    async install({ entry }) {
+      const serverCommand = [entry.command, ...entry.args].join(" ");
+      const manualCmd = `claude mcp add --scope user recolx -- ${serverCommand}`;
+      if (!commandExists("claude")) {
+        return {
+          status: "failed",
+          message: `failed: PATH \u4E0A\u627E\u4E0D\u5230 claude CLI\u3002\u53EF\u624B\u52A8\u6267\u884C\uFF1A
+  ${manualCmd}`
+        };
+      }
+      spawnSync("claude", ["mcp", "remove", "recolx", "--scope", "user"], { encoding: "utf-8" });
+      const register = spawnSync(
+        "claude",
+        ["mcp", "add", "--scope", "user", "recolx", "--", entry.command, ...entry.args],
+        { encoding: "utf-8" }
+      );
+      if (register.status !== 0) {
+        const err = (register.stderr || register.stdout || "").trim();
+        return {
+          status: "failed",
+          message: `failed: claude mcp add \u5931\u8D25\uFF08${err || "\u672A\u77E5\u9519\u8BEF"}\uFF09\u3002\u624B\u52A8\u6267\u884C\uFF1A
+  ${manualCmd}`
+        };
+      }
+      let skillsMsg = "";
+      try {
+        const installed = await installSkillsToClaudeCode();
+        skillsMsg = `\uFF1B${skillsInstalledMessage(installed)}`;
+      } catch (err) {
+        skillsMsg = `\uFF1Bskills \u62F7\u8D1D\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}\uFF08\u53EF\u7A0D\u540E\u91CD\u8DD1 install\uFF09`;
+      }
+      return { status: "configured", message: `\u5DF2\u6CE8\u518C\u5230 user scope${skillsMsg}`, restartHint: CLAUDE_CODE_RESTART };
+    },
+    async uninstall() {
+      if (!commandExists("claude")) {
+        return { status: "failed", message: "failed: PATH \u4E0A\u627E\u4E0D\u5230 claude CLI\u3002\u624B\u52A8\u6267\u884C claude mcp remove recolx --scope user" };
+      }
+      const removed = spawnSync("claude", ["mcp", "remove", "recolx", "--scope", "user"], { encoding: "utf-8" });
+      if (removed.status !== 0) return { status: "failed", message: "failed: claude mcp remove \u5931\u8D25" };
+      let skillsMsg = "";
+      try {
+        await removeSkillsFromClaudeCode();
+        skillsMsg = "\uFF1B\u5DF2\u79FB\u9664 ~/.claude/skills/ \u4E2D\u7684 recolx skills";
+      } catch (err) {
+        skillsMsg = `\uFF1Bskills \u79FB\u9664\u5931\u8D25\uFF1A${err instanceof Error ? err.message : String(err)}`;
+      }
+      return { status: "configured", message: `\u5DF2\u79FB\u9664${skillsMsg}`, restartHint: CLAUDE_CODE_RESTART };
+    }
+  };
+}
+function zedAdapter(configPath) {
+  return {
+    id: "zed",
+    label: "Zed",
+    detect() {
+      return { detected: existsSync(configPath) || existsSync(dirname(configPath)), configPath };
+    },
+    async install(ctx) {
+      let config = {};
+      try {
+        const parsed = JSON.parse(await readFile(configPath, "utf8"));
+        if (!isJsonObject(parsed)) return { status: "failed", message: `failed: ${configPath} \u4E0D\u662F JSON \u5BF9\u8C61` };
+        config = parsed;
+      } catch (err) {
+        if (!isEnoent(err)) return { status: "failed", message: `failed: ${configPath} \u542B\u65E0\u6548 JSON\uFF0C\u4FEE\u590D\u540E\u91CD\u8BD5` };
+      }
+      const servers = isJsonObject(config.context_servers) ? config.context_servers : {};
+      const existing = servers[SERVER_NAME];
+      if (existing && entryAutoUpdates(existing)) {
+        const path = isJsonObject(existing) && isJsonObject(existing.command) && typeof existing.command.path === "string" ? existing.command.path : void 0;
+        if (!commandPathIsStale(path)) {
+          return { status: "already-configured", message: "\u5DF2\u914D\u7F6E\uFF08npx @latest \u81EA\u52A8\u66F4\u65B0\uFF09" };
+        }
+      }
+      config.context_servers = {
+        ...servers,
+        [SERVER_NAME]: { command: { path: ctx.entry.command, args: ctx.entry.args } }
+      };
+      await mkdir(dirname(configPath), { recursive: true });
+      await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+      return { status: "configured", message: "\u5DF2\u5199\u5165 context_servers" };
+    },
+    async uninstall() {
+      let config = {};
+      try {
+        const parsed = JSON.parse(await readFile(configPath, "utf8"));
+        if (!isJsonObject(parsed)) return { status: "failed", message: `failed: ${configPath} \u4E0D\u662F JSON \u5BF9\u8C61` };
+        config = parsed;
+      } catch (err) {
+        if (isEnoent(err)) return { status: "skipped", message: "\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF0C\u8DF3\u8FC7" };
+        return { status: "failed", message: `${configPath} \u542B\u65E0\u6548 JSON` };
+      }
+      const servers = isJsonObject(config.context_servers) ? config.context_servers : {};
+      if (!(SERVER_NAME in servers)) return { status: "skipped", message: "\u672A\u914D\u7F6E recolx\uFF0C\u7701\u7565" };
+      const next = { ...servers };
+      delete next[SERVER_NAME];
+      if (Object.keys(next).length > 0) config.context_servers = next;
+      else delete config.context_servers;
+      await writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+      return { status: "configured", message: "\u5DF2\u79FB\u9664" };
+    }
+  };
+}
+var RESTART_HINTS = {
+  "claude-desktop": "\u5B8C\u5168\u9000\u51FA Claude Desktop\uFF08macOS \u2318Q / Windows Alt+F4\uFF09\u540E\u91CD\u65B0\u6253\u5F00\u2014\u2014\u53EA\u5173\u7A97\u53E3\u4E0D\u591F",
+  codex: "\u9000\u51FA Codex \u540E\u91CD\u65B0\u6253\u5F00",
+  "claude-code": CLAUDE_CODE_RESTART,
+  cursor: "\u91CD\u542F Cursor \u4EE5\u52A0\u8F7D MCP",
+  windsurf: "\u91CD\u542F Windsurf \u4EE5\u52A0\u8F7D MCP",
+  vscode: "\u91CD\u8F7D VS Code \u7A97\u53E3\uFF08Command Palette \u2192 Reload Window\uFF09",
+  zed: "\u91CD\u542F Zed \u4EE5\u52A0\u8F7D MCP"
+};
+function detectClients() {
+  const p = configPaths();
+  const adapters = [
+    jsonAdapter({
+      id: "claude-desktop",
+      label: "Claude Desktop",
+      configPath: p.claudeDesktop ?? "",
+      configuredMessage: "\u5DF2\u5199\u5165 mcpServers",
+      restartHint: RESTART_HINTS["claude-desktop"]
+    }),
+    codexAdapter(p.codex),
+    claudeCodeAdapter(p.claudeCodeDir),
+    jsonAdapter({
+      id: "cursor",
+      label: "Cursor",
+      configPath: p.cursor,
+      configuredMessage: "\u5DF2\u5199\u5165 mcp.json",
+      restartHint: RESTART_HINTS.cursor
+    }),
+    jsonAdapter({
+      id: "windsurf",
+      label: "Windsurf",
+      configPath: p.windsurf,
+      configuredMessage: "\u5DF2\u5199\u5165 mcp_config.json",
+      restartHint: RESTART_HINTS.windsurf
+    }),
+    jsonAdapter({
+      id: "vscode",
+      label: "VS Code",
+      configPath: p.vsCode,
+      rootKey: "servers",
+      toEntry: (e) => ({ type: "stdio", command: e.command, args: e.args }),
+      configuredMessage: "\u5DF2\u5199\u5165 .vscode/mcp.json",
+      restartHint: RESTART_HINTS.vscode
+    }),
+    zedAdapter(p.zed)
+  ];
+  return adapters.map((a) => ({ adapter: a, id: a.id, label: a.label, ...a.detect() }));
+}
+var promptInterface = null;
+var pipedAnswers = null;
+var pipedAnswersPromise = null;
+async function readPipedAnswers() {
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+  }
+  return input.split(/\r?\n/);
+}
+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");
+}
+function pickIdentity(user) {
+  if (!isJsonObject(user)) return void 0;
+  for (const k of ["nickname", "user_id", "id"]) {
+    const v = user[k];
+    if (typeof v === "string" && v.length > 0) return v;
+    if (typeof v === "number") return String(v);
+  }
+  return void 0;
+}
+async function runLogin() {
+  const client = new RecolxClient({});
+  const devUserId = process.env.RECOLX_DEV_USER_ID;
+  const authReq = client.auth.createAuthorizationRequest(devUserId ? { user_id: devUserId } : {});
+  const authUrlFile = process.env.RECOLX_DEV_AUTH_URL_FILE;
+  const result = await runOAuthCallback({
+    port: CALLBACK_PORT,
+    expectedState: authReq.state,
+    timeoutMs: LOGIN_TIMEOUT_MS,
+    exchangeCode: (code) => client.auth.exchangeCode(code, authReq.codeVerifier),
+    onListening: () => {
+      if (authUrlFile) {
+        writeFileSync(authUrlFile, `${authReq.url}
+`, "utf8");
+        return;
+      }
+      console.log(`  \u82E5\u6D4F\u89C8\u5668\u672A\u81EA\u52A8\u6253\u5F00\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\uFF1A
+  ${authReq.url}`);
+      open(authReq.url).catch(() => {
+      });
+    }
+  });
+  switch (result.status) {
+    case "success": {
+      let who;
+      try {
+        who = pickIdentity(await client.getCurrentUser());
+      } catch {
+      }
+      return { status: "success", who };
+    }
+    case "timeout":
+      return { status: "timeout", message: `\u6388\u6743\u8D85\u65F6\uFF082 \u5206\u949F\uFF09\u3002\u53EF\u91CD\u8BD5 recolx-mcp install --yes\uFF0C\u6216\u5728\u5BA2\u6237\u7AEF\u91CC\u8FD0\u884C login tool` };
+    case "denied":
+      return { status: "failed", message: result.error?.message ?? "\u6388\u6743\u88AB\u62D2\u7EDD" };
+    case "exchange-failed":
+      return { status: "failed", message: result.error?.message ?? "code \u6362 token \u5931\u8D25" };
+    case "listen-failed":
+      return { status: "failed", message: result.error?.message ?? "\u56DE\u8C03\u670D\u52A1\u542F\u52A8\u5931\u8D25\uFF08\u7AEF\u53E3 8199 \u88AB\u5360\u7528\uFF1F\uFF09" };
+  }
+}
+async function loginStep(nonInteractive) {
+  console.log();
+  console.log("\u2192 \u767B\u5F55 Recolx\u2026");
+  const client = new RecolxClient({});
+  const existing = await client.auth.getAccessToken();
+  if (existing) {
+    try {
+      const me = await client.getCurrentUser();
+      const who = pickIdentity(me);
+      console.log(`  \u5DF2\u767B\u5F55${who ? `\uFF08${who}\uFF09` : ""}\uFF0C\u8DF3\u8FC7 OAuth\u3002`);
+      return { status: "already-authed", who };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("401") || msg.includes("\u672A\u767B\u5F55")) {
+        console.log("  \u672C\u5730 token \u5DF2\u5931\u6548\u2014\u2014\u6E05\u6389\u91CD\u65B0\u8D70\u6388\u6743\u3002");
+        await client.auth.logout().catch(() => {
+        });
+      } else {
+        console.log("  token \u5B58\u5728\u4F46\u6821\u9A8C\u5931\u8D25\uFF0C\u5C06\u91CD\u65B0\u6388\u6743\u3002");
+      }
+    }
+  }
+  if (!nonInteractive) {
+    const yes = await prompt("\u73B0\u5728\u767B\u5F55 Recolx\uFF1F\uFF08\u6253\u5F00\u6D4F\u89C8\u5668\uFF09", true);
+    if (!yes) {
+      console.log("  \u8DF3\u8FC7 \u2014\u2014 \u91CD\u542F\u5BA2\u6237\u7AEF\u540E\u9996\u6B21\u8C03\u7528 tool \u65F6\u518D\u767B\u5F55\u3002");
+      return null;
+    }
+  }
+  console.log("  \u6253\u5F00\u6D4F\u89C8\u5668 \u2014\u2014 \u70B9\u51FB\u300C\u6388\u6743\u300D\u5B8C\u6210\u767B\u5F55\u3002");
+  const outcome = await runLogin();
+  switch (outcome.status) {
+    case "success":
+      console.log(`  \u2713 \u5DF2\u8BA4\u8BC1${outcome.who ? `\uFF08${outcome.who}\uFF09` : ""}\u3002`);
+      return { status: "success", who: outcome.who };
+    case "timeout":
+      console.log(`  \u2717 ${outcome.message}`);
+      return { status: "timeout" };
+    case "failed":
+      console.log(`  \u2717 \u767B\u5F55\u5931\u8D25\uFF1A${outcome.message}`);
+      return { status: "failed" };
+  }
+}
+var BAR = "\u2500".repeat(60);
+function printNextSteps(clients, login) {
+  if (clients.length === 0) return;
+  const authed = login?.status === "success" || login?.status === "already-authed";
+  console.log();
+  console.log(BAR);
+  console.log(`\u2713 Recolx MCP \u5DF2\u914D\u7F6E\uFF1A${clients.map((c) => c.label).join(", ")}`);
+  if (authed && login?.who) console.log(`\u2713 \u5DF2\u8BA4\u8BC1\uFF08${login.who}\uFF09`);
+  console.log(BAR);
+  console.log();
+  if (clients.length === 1) {
+    console.log(`\u4E0B\u4E00\u6B65\uFF1A${clients[0].restartHint ?? "\u91CD\u542F\u5BA2\u6237\u7AEF"}`);
+  } else {
+    console.log("\u4E0B\u4E00\u6B65\uFF1A\u91CD\u542F\u5404\u5BA2\u6237\u7AEF");
+    for (const c of clients) console.log(`  \u2022 ${c.label}\uFF1A${c.restartHint ?? "\u91CD\u542F"}`);
+  }
+  if (!authed) {
+    console.log();
+    console.log("  \u7136\u540E\u4EFB\u9009\u4E00\u4E2A\u5BA2\u6237\u7AEF\u91CC\u8F93\u5165\u300CList my Recolx recordings\u300D\uFF0C\u4F1A\u89E6\u53D1\u4E00\u6B21 OAuth \u767B\u5F55\u3002");
+  }
+  console.log();
+  console.log("  \u8FDC\u7A0B\u673A\u5668\uFF08\u65E0\u6D4F\u89C8\u5668 / \u8DF3\u677F\u673A\uFF09\uFF1A\u5148\u8F6C\u53D1 OAuth \u56DE\u8C03\u7AEF\u53E3\u518D\u767B\u5F55\uFF1A");
+  console.log(`    ssh -L ${CALLBACK_PORT}:localhost:${CALLBACK_PORT} <host>`);
+  console.log();
+  console.log(BAR);
+}
+async function runInstall(opts = {}) {
+  console.log("Recolx MCP installer\n");
+  const clients = detectClients();
+  console.log("\u68C0\u6D4B\u5230\u7684 AI \u5BA2\u6237\u7AEF\uFF1A");
+  for (const c of clients) {
+    const mark = c.detected ? "\u2713" : "\xB7";
+    console.log(`  ${mark} ${c.label.padEnd(16)} ${c.detected ? c.configPath : "(\u672A\u68C0\u6D4B\u5230)"}`);
+  }
+  console.log();
+  const selected = [];
+  if (opts.yes) {
+    for (const c of clients) if (c.detected) selected.push(c);
+    if (selected.length > 0) {
+      console.log(`--yes\uFF1A\u81EA\u52A8\u914D\u7F6E ${selected.map((c) => c.label).join(", ")}\uFF0C\u4E0D\u518D\u8BE2\u95EE\u3002
+`);
+    }
+  } else {
+    for (const c of clients) {
+      if (!c.detected) continue;
+      if (await prompt(`\u914D\u7F6E ${c.label}\uFF1F`, true)) selected.push(c);
+    }
+  }
+  if (selected.length === 0) {
+    console.log("\n\u6CA1\u6709\u53EF\u914D\u7F6E\u7684\u5BA2\u6237\u7AEF\uFF0C\u9000\u51FA\u3002");
+    return;
+  }
+  const entry = getMcpEntry();
+  const succeeded = [];
+  for (const c of selected) {
+    process.stdout.write(`\u2192 ${c.label}... `);
+    try {
+      const result = await c.adapter.install({ entry });
+      console.log(result.message);
+      if (result.status === "configured" || result.status === "already-configured") {
+        succeeded.push({ id: c.id, label: c.label, restartHint: result.restartHint });
+      }
+    } catch (err) {
+      console.log(`failed\uFF1A${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const login = opts.noLogin ? null : await loginStep(Boolean(opts.yes));
+  if (opts.noLogin) {
+    console.log();
+    console.log("--no-login\uFF1A\u8DF3\u8FC7 OAuth\u3002\u4E4B\u540E\u5728\u4EFB\u4E00\u5BA2\u6237\u7AEF\u91CC\u89E6\u53D1 login\uFF08\u6216\u8FD0\u884C recolx-mcp login\uFF09\u3002");
+  }
+  printNextSteps(succeeded, login);
+}
+async function runUninstall(opts = {}) {
+  console.log("Recolx MCP uninstaller\n");
+  const clients = detectClients();
+  const selected = [];
+  if (opts.yes) {
+    for (const c of clients) if (c.detected) selected.push(c);
+  } else {
+    for (const c of clients) {
+      if (!c.detected) continue;
+      if (await prompt(`\u79FB\u9664 ${c.label} \u91CC\u7684 recolx \u914D\u7F6E\uFF1F`, true)) selected.push(c);
+    }
+  }
+  if (selected.length === 0) {
+    console.log("\n\u6CA1\u6709\u9700\u8981\u6E05\u7406\u7684\u5BA2\u6237\u7AEF\uFF0C\u9000\u51FA\u3002");
+    return;
+  }
+  for (const c of selected) {
+    process.stdout.write(`\u2192 ${c.label}... `);
+    try {
+      const result = await c.adapter.uninstall();
+      console.log(result.message);
+    } catch (err) {
+      console.log(`failed\uFF1A${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  console.log();
+  console.log("\u5DF2\u6E05\u7406\u5BA2\u6237\u7AEF\u914D\u7F6E\u3002token \u6587\u4EF6 ~/.recolx/tokens-mcp.json \u4FDD\u7559\uFF08\u5982\u9700\u5F7B\u5E95\u79FB\u9664\u8BF7\u5220\u9664\u8BE5\u6587\u4EF6\uFF09\u3002");
+}
+export {
+  CALLBACK_PORT,
+  LOGIN_TIMEOUT_MS,
+  SERVER_NAME,
+  claudeDesktopConfigPath,
+  codexBlockRange,
+  codexBlockText,
+  commandPathIsStale,
+  getMcpEntry,
+  normalizeWindowsPath,
+  runInstall,
+  runUninstall
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@uzqw/mcp",
+  "version": "0.1.0",
+  "description": "Recolx read-only MCP server (stdio) — 7 read-only tools, readOnlyHint: true",
+  "mcpName": "io.github.uzqw/recolx-mcp",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "bin": {
+    "recolx-mcp": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": ["dist", "skills"],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "test": "tsx --test test/*.test.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@uzqw/shared": "*",
+    "open": "^10.1.0",
+    "zod": "^3.23.8"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/skills/recolx-digest/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: recolx-digest
+version: 1.0.0
+description: "Summarize multiple Recolx recordings into a digest. Use when the user says 'weekly report', '周报', 'digest of this month', 'what meetings did I have this week', 'recap of last quarter', or asks to roll up multiple recordings into one overview. This is the Loop Leverage phase: turn a window of recordings into a reusable summary."
+metadata:
+  requires:
+    bins: []
+---
+
+# recolx-digest
+
+**Read [`recolx-shared`](../recolx-shared/SKILL.md) first.**
+
+## When to use
+
+- User asks for a roll-up across multiple recordings.
+- Time window is explicit ("this week", "上个月") or implicit ("recap of recent meetings").
+- Scope is "what happened", not "find one specific meeting".
+
+## Steps
+
+1. **Resolve the window.** Interpret relative phrases against the **current date** (from conversation context, not training cutoff):
+
+   | User phrase | date_from / date_to |
+   |---|---|
+   | "today" | today → today |
+   | "yesterday" | yesterday → yesterday |
+   | "this week" | Monday of this week → today |
+   | "last week" | Monday → Sunday of last week |
+   | "this month" | 1st of this month → today |
+   | "last month" | 1st → last day of previous month |
+
+2. **List the corpus.** `list_files` with `date_from` / `date_to`. Cap at 50 recordings — if the window returns more, ask the user to narrow it.
+3. **Fetch notes in batch.** For each recording, call `get_note`. Do **not** call `get_transcript` unless a specific recording merits a deeper pull.
+4. **Synthesize.** Produce a structured digest:
+   - **Headline** — one-line theme of the window.
+   - **By recording** — one bullet per recording: `• name (date, duration) — one-sentence takeaway`.
+   - **Recurring themes** — topics that appeared in ≥ 2 recordings.
+   - **Open action items** — aggregated across recordings, deduplicated.
+5. **Cite sources.** Every non-trivial claim must reference the recording it came from, using the file title (not the raw ID unless the user asked).
+
+## Budget
+
+- Hard cap: 50 `get_note` calls per digest. If the window has more recordings, ask the user to narrow.
+- Skip recordings where `get_note` returns empty — mention them at the end under "未生成摘要" (unsummarized).
+
+## Anti-patterns
+
+- Do not load transcripts just to pad the digest.
+- Do not synthesize across windows the user didn't ask for ("while we're at it, here's last month too").
+- Do not invent action items that aren't in the notes — only aggregate what's there.

package/skills/recolx-export/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: recolx-export
+version: 1.0.0
+description: "Push Recolx content or a generated artifact to Notion, Slack, Gmail, or a custom webhook. Use when the user says 'save to Notion', '存到 Notion', 'post to Slack', 'send to webhook', or asks to deliver recording content to an external system. This skill calls other MCPs the user has already connected — it never writes its own connectors."
+metadata:
+  requires:
+    bins: []
+---
+
+# recolx-export
+
+**Read [`recolx-shared`](../recolx-shared/SKILL.md) first.**
+
+## When to use
+
+- User has a ready artifact (from `recolx-followup`) or recording content and wants to **deliver** it somewhere.
+- Destination is an external system (not the chat).
+
+## Out of scope
+
+- Generating the artifact — that's `recolx-followup`.
+- Reading recording content — that's `get_note` / `get_transcript`.
+
+This skill is the final leg: take content that already exists and send it.
+
+## How it works
+
+Recolx itself exposes no `push` tool and stores no destination credentials. Delivery uses an **MCP tool that is already available in the session** — the Notion MCP, Slack MCP, a webhook tool, Gmail send, etc. — whichever the user has connected. We call that tool; we don't build connectors.
+
+## Steps
+
+1. **Confirm the payload.** Recording summary (raw `get_note` content)? Generated artifact (email, brief — already drafted)? Raw transcript excerpt?
+2. **Confirm the destination + identifiers.** Ask for the exact target. Recolx does not store destination credentials.
+3. **Deliver using the MCP tool or integration available in the user's environment.** If none is available in the session, say so and list what the user would need to connect — do not improvise a delivery channel.
+4. **Report the delivery URL** (Notion page URL, Slack message permalink, webhook HTTP status) back to the user.
+
+## Destination identifier cheat-sheet
+
+| Destination | Required identifier | Typical ask |
+|---|---|---|
+| Notion | page ID or database ID | "Which Notion page should this go under?" |
+| Slack | channel name or ID | "Which channel? (e.g., `#sales` or `C0123`)" |
+| Gmail | recipient email(s) | "Who should this email go to?" |
+| Webhook | full URL | "Paste the webhook URL" |
+
+## Anti-patterns
+
+- Never persist destination credentials in the conversation or in files. Assume the MCP host provides them.
+- Never send to a default destination ("I'll put it in `#general`") — always confirm.
+- Never alter the artifact content during delivery. If Slack needs mrkdwn, convert format without changing meaning.

package/skills/recolx-followup/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: recolx-followup
+version: 1.0.0
+description: "Turn a Recolx recording into a follow-up email, thank-you note, action-item list, or meeting brief. Use when the user says 'draft follow-up', 'what were the action items', 'send thank-you email', 'write the recap', '起草跟进邮件', or names an artifact to generate from a recording."
+metadata:
+  requires:
+    bins: []
+---
+
+# recolx-followup
+
+**Read [`recolx-shared`](../recolx-shared/SKILL.md) first.**
+
+## When to use
+
+- User wants a **generated document** grounded in one recording.
+- Target format is explicit (email, brief, action-item list) or implicit ("write the follow-up").
+- If the user wants to *send* the output to Notion / Slack / a webhook, chain into `recolx-export` after drafting.
+
+## Steps
+
+1. **Identify the recording.** If the user didn't name one, ask them to pick from a `list_files` result.
+2. **Fetch source content.**
+   - `get_note` first — usually enough for summaries and action items.
+   - `get_transcript` only if the artifact needs verbatim quotes or speaker attribution.
+3. **Generate the artifact** in the requested format. Ground every claim in the source; do not invent attendees, dates, decisions, or numbers.
+4. **Present to the user** in the chat, then ask if they want to refine or export.
+
+## Artifact templates
+
+### Follow-up email
+- To: attendees (from notes if listed).
+- Subject: "Follow-up — {recording title}, {date}".
+- Opening line: thanks + one-line meeting summary.
+- Body: 3–5 bullets of key points.
+- Action items: numbered list with owner and due date if mentioned.
+- Closing: "Let me know if I missed anything."
+
+### Thank-you email
+- Short. One paragraph. One concrete thing you learned or appreciated from the call.
+
+### Action-item list
+- Plain markdown: `- [ ] {owner}: {item} (due {date})`.
+- Mark owner as `?` if unclear from notes — do not guess.
+
+### Meeting brief
+- Attendees, date, duration, decisions, risks, next steps.
+
+## Anti-patterns
+
+- Never invent email recipients. If attendees weren't captured, ask the user.
+- Never invent due dates. Mark as `due: TBD` if not stated.
+- Do not send the email — this skill drafts. Hand off to `recolx-export` for delivery.

package/skills/recolx-shared/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: recolx-shared
+version: 1.0.0
+description: "First read before any Recolx operation. Auth flow, tool inventory, error semantics, output conventions, token refresh. Use when the user mentions Recolx for the first time in a session, or when any other recolx-* skill is invoked."
+metadata:
+  requires:
+    bins: []
+---
+
+# recolx-shared
+
+**CRITICAL — read this before calling any Recolx tool.** Applies to every other `recolx-*` skill.
+
+## Authentication
+
+- Recolx uses developer OAuth (PKCE S256). MCP tokens are stored in `~/.recolx/tokens-mcp.json` and refreshed automatically. The terminal CLI (`recolx`) keeps a separate `~/.recolx/tokens-cli.json` — the two never share tokens.
+- If any tool returns an auth error (message includes `401` or `Not authenticated`), call the `login` tool and wait for the browser callback. Do **not** retry the original tool until login returns success.
+- Never ask the user to paste tokens. The `login` tool handles the whole flow (authorize page → local `:8199` callback → token stored).
+- Remote/headless machines need the callback port forwarded first: `ssh -L 8199:localhost:8199 <host>`.
+
+## Tool inventory
+
+| Tool | Purpose |
+|---|---|
+| `login` | Open browser for OAuth; blocks until callback or 2-min timeout |
+| `logout` | Revoke all tokens server-side and clear local token file |
+| `get_current_user` | Verify who is signed in (nickname, subscription tier / Pro quota) |
+| `list_files` | List recordings; supports `query`, `date_from`, `date_to` (client-side filter) |
+| `get_file` | Single recording detail incl. 24h `presigned_url` audio link + device |
+| `get_note` | AI summary / notes for one recording (by template tab) |
+| `get_transcript` | Timestamped transcript with speaker/language labels, cursor-paginated |
+
+All tools are read-only (`readOnlyHint: true`). Some hosts namespace tool names with a connector prefix (e.g. `recolx_list_files`) — resolve tools from the list you were actually given, matching on the canonical suffix (`…list_files`, `…get_note`). Never assume a bare name, never hard-code a prefix.
+
+## Error semantics
+
+| Pattern in error message | Meaning | What to do |
+|---|---|---|
+| `401` / `Not authenticated` / 未登录 | Token missing or expired | Call `login`, then retry |
+| `404` | File ID does not exist | Tell the user the ID is wrong; do not retry |
+| `500` | Backend error | Retry once; if still failing treat as not-found |
+| `fetch failed` / `ECONNREFUSED` | Local backend unreachable | Abort; ask user to check the Recolx service |
+
+## Output conventions
+
+When presenting recordings:
+
+- Always show name, date, duration, and file ID — users need the ID to ask follow-ups.
+- Durations are **seconds** in the API: render human-readable `23s`, `5m23s`, `1h05m`. Raw seconds are for logs only.
+- Dates as `YYYY-MM-DD` in local time (`recorded_at` is a Unix timestamp in seconds).
+- Transcripts: preserve `[MM:SS - MM:SS] Speaker: content`. Do not reformat timestamps.
+- Notes (`get_note` returns `summary[]` with `prompt_id` / `prompt_name`): render the `text` as Markdown.
+
+## Data model quick reference
+
+- `file_id` — string. `title`, `recorded_at` (Unix seconds), `duration` (seconds), `file_size` (bytes), `device: {name, serial, model}`.
+- `get_note` → `[{task_id, text, prompt_id, prompt_name}]`; empty when the note is not generated yet.
+- `get_transcript` → `{language, segments: [{start, end, text, speaker, language}], next_cursor}` — follow `next_cursor` for long recordings; `start`/`end` are seconds.
+- `presigned_url` — audio download link, expires in 24h; re-fetch with `get_file` if stale.
+
+## When to load which sibling skill
+
+| User intent | Skill to follow |
+|---|---|
+| "List / show my recordings" | `recolx-digest` (roll-up) or plain `list_files` browsing |
+| "Weekly report / 周报 / digest of this month" | `recolx-digest` |
+| "Draft follow-up / action items / thank-you email" | `recolx-followup` |
+| "Save to Notion / Slack / webhook / 存到" | `recolx-export` |