@claudeink/mcp-server 0.0.1

package/dist/index.js

@@ -0,0 +1,1232 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/auth.ts
+import { z } from "zod";
+
+// src/lib/config.ts
+import { readFile, writeFile, mkdir, chmod, access } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var CLAUDEINK_DIR = join(homedir(), ".claudeink");
+var PATHS = {
+  credentials: join(CLAUDEINK_DIR, "credentials.json"),
+  config: join(CLAUDEINK_DIR, "config.json"),
+  syncState: join(CLAUDEINK_DIR, "sync-state.json"),
+  tagQueue: join(CLAUDEINK_DIR, "tag-queue.json"),
+  crawlSchedules: join(CLAUDEINK_DIR, "crawl-schedules.json"),
+  logs: join(CLAUDEINK_DIR, "logs")
+};
+var DEFAULT_CONFIG = {
+  apiBaseUrl: "https://api.claudeink.app",
+  syncIntervalMs: 3e5,
+  // 5 minutes
+  heartbeatIntervalMs: 3e5,
+  maxTagQueueBatch: 20,
+  workflowDir: ""
+};
+var DEFAULT_SYNC_STATE = {
+  lastSyncAt: null,
+  configVersion: "0.0.0",
+  pendingPushCount: 0
+};
+var DEFAULT_TAG_QUEUE = {
+  queue: [],
+  failed: [],
+  history: {
+    lastProcessed: null,
+    totalProcessed: 0,
+    avgTagsPerItem: 0
+  }
+};
+var DEFAULT_CRAWL_SCHEDULES = {
+  schedules: []
+};
+async function ensureDir() {
+  await mkdir(CLAUDEINK_DIR, { recursive: true });
+  await mkdir(PATHS.logs, { recursive: true });
+}
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(path, defaultValue) {
+  try {
+    const content = await readFile(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return defaultValue;
+  }
+}
+async function writeJson(path, data, secure = false) {
+  await ensureDir();
+  await writeFile(path, JSON.stringify(data, null, 2), "utf-8");
+  if (secure) {
+    await chmod(path, 384);
+  }
+}
+async function getCredentials() {
+  if (!await fileExists(PATHS.credentials)) return null;
+  return readJson(PATHS.credentials, null);
+}
+async function saveCredentials(creds) {
+  await writeJson(PATHS.credentials, creds, true);
+}
+async function getConfig() {
+  return readJson(PATHS.config, DEFAULT_CONFIG);
+}
+async function saveConfig(config) {
+  const current = await getConfig();
+  await writeJson(PATHS.config, { ...current, ...config });
+}
+async function getSyncState() {
+  return readJson(PATHS.syncState, DEFAULT_SYNC_STATE);
+}
+async function saveSyncState(state) {
+  const current = await getSyncState();
+  await writeJson(PATHS.syncState, { ...current, ...state });
+}
+async function getTagQueue() {
+  return readJson(PATHS.tagQueue, DEFAULT_TAG_QUEUE);
+}
+async function saveTagQueue(queue) {
+  await writeJson(PATHS.tagQueue, queue);
+}
+async function getCrawlSchedules() {
+  return readJson(PATHS.crawlSchedules, DEFAULT_CRAWL_SCHEDULES);
+}
+async function saveCrawlSchedules(schedules) {
+  await writeJson(PATHS.crawlSchedules, schedules);
+}
+
+// src/lib/api-client.ts
+async function request(path, options = {}) {
+  const config = await getConfig();
+  const url = `${config.apiBaseUrl}${path}`;
+  try {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": "ClaudeInk-MCP/0.1.0"
+    };
+    if (options.token) {
+      headers["Authorization"] = `Bearer ${options.token}`;
+    } else {
+      const creds = await getCredentials();
+      if (creds?.token) {
+        headers["Authorization"] = `Bearer ${creds.token}`;
+      }
+    }
+    const res = await fetch(url, {
+      method: options.method || "GET",
+      headers,
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    const data = await res.json().catch(() => null);
+    return {
+      ok: res.ok,
+      status: res.status,
+      data: data ?? void 0,
+      error: res.ok ? void 0 : `HTTP ${res.status}`
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+async function activateLicense(key) {
+  return request("/api/auth/activate", {
+    method: "POST",
+    body: { key }
+  });
+}
+async function fetchLatestConfig(localVersion) {
+  return request(
+    `/api/config/latest?version=${localVersion}`
+  );
+}
+async function pushSyncBatch(payload) {
+  return request("/api/sync/batch", {
+    method: "POST",
+    body: payload
+  });
+}
+async function checkAuthStatus() {
+  return request(
+    "/api/auth/status"
+  );
+}
+
+// src/tools/auth.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+var activateSchema = z.object({
+  key: z.string().describe("License key, e.g. WF-XXXX-XXXX-XXXX"),
+  workflowDir: z.string().describe("\u5DE5\u4F5C\u6D41\u6839\u76EE\u5F55\u8DEF\u5F84")
+});
+async function authActivate(input) {
+  const res = await activateLicense(input.key);
+  if (!res.ok || !res.data) {
+    return {
+      success: false,
+      message: `License key \u9A8C\u8BC1\u5931\u8D25: ${res.error || "\u672A\u77E5\u9519\u8BEF"}`
+    };
+  }
+  await saveCredentials({
+    licenseKey: input.key,
+    token: res.data.token,
+    userId: res.data.userId,
+    plan: res.data.plan,
+    expiresAt: res.data.expiresAt
+  });
+  await saveConfig({ workflowDir: input.workflowDir });
+  const configRes = await fetchLatestConfig("0.0.0");
+  if (configRes.ok && configRes.data) {
+    for (const [filePath, content] of Object.entries(configRes.data.files)) {
+      const fullPath = join2(input.workflowDir, filePath);
+      const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+      await mkdir2(dir, { recursive: true });
+      await writeFile2(fullPath, content, "utf-8");
+    }
+    await saveSyncState({ configVersion: configRes.data.version });
+  }
+  return {
+    success: true,
+    message: `\u6FC0\u6D3B\u6210\u529F\uFF01\u5957\u9910: ${res.data.plan}\uFF0C\u5230\u671F: ${res.data.expiresAt}`,
+    data: {
+      plan: res.data.plan,
+      expiresAt: res.data.expiresAt,
+      configVersion: configRes.data?.version || "unknown"
+    }
+  };
+}
+async function authStatus() {
+  const creds = await getCredentials();
+  if (!creds) {
+    return {
+      success: false,
+      message: "\u672A\u6FC0\u6D3B\u3002\u8BF7\u5148\u4F7F\u7528 auth.activate \u6FC0\u6D3B license key\u3002"
+    };
+  }
+  const res = await checkAuthStatus();
+  if (res.ok && res.data) {
+    return {
+      success: true,
+      message: `\u5DF2\u6FC0\u6D3B\u3002\u5957\u9910: ${res.data.plan}\uFF0C\u5230\u671F: ${res.data.expiresAt}\uFF0C\u72B6\u6001: ${res.data.valid ? "\u6709\u6548" : "\u5DF2\u8FC7\u671F"}`,
+      data: res.data
+    };
+  }
+  const expired = new Date(creds.expiresAt) < /* @__PURE__ */ new Date();
+  return {
+    success: true,
+    message: `\u5DF2\u6FC0\u6D3B\uFF08\u79BB\u7EBF\u6A21\u5F0F\uFF09\u3002\u5957\u9910: ${creds.plan}\uFF0C\u5230\u671F: ${creds.expiresAt}${expired ? "\uFF08\u5DF2\u8FC7\u671F\uFF09" : ""}`,
+    data: {
+      plan: creds.plan,
+      expiresAt: creds.expiresAt,
+      valid: !expired,
+      offline: true
+    }
+  };
+}
+async function configSync() {
+  const syncState = await getSyncState();
+  const res = await fetchLatestConfig(syncState.configVersion);
+  if (!res.ok || !res.data) {
+    return {
+      success: false,
+      message: `\u914D\u7F6E\u540C\u6B65\u5931\u8D25: ${res.error || "\u65E0\u6CD5\u8FDE\u63A5\u4E91\u7AEF"}`
+    };
+  }
+  if (res.data.version === syncState.configVersion) {
+    return {
+      success: true,
+      message: `\u914D\u7F6E\u5DF2\u662F\u6700\u65B0\u7248\u672C (${syncState.configVersion})`
+    };
+  }
+  const config = await getConfig();
+  for (const [filePath, content] of Object.entries(res.data.files)) {
+    const fullPath = join2(config.workflowDir, filePath);
+    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    await mkdir2(dir, { recursive: true });
+    await writeFile2(fullPath, content, "utf-8");
+  }
+  await saveSyncState({ configVersion: res.data.version });
+  return {
+    success: true,
+    message: `\u914D\u7F6E\u5DF2\u66F4\u65B0: ${syncState.configVersion} \u2192 ${res.data.version}
+\u53D8\u66F4: ${res.data.changelog}`,
+    data: { version: res.data.version, changelog: res.data.changelog }
+  };
+}
+async function configVersion() {
+  const syncState = await getSyncState();
+  return {
+    success: true,
+    message: `\u5F53\u524D\u672C\u5730\u914D\u7F6E\u7248\u672C: ${syncState.configVersion}`,
+    data: { version: syncState.configVersion }
+  };
+}
+
+// src/tools/source.ts
+import { z as z2 } from "zod";
+import { mkdir as mkdir3 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/lib/sources.ts
+import { readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { join as join3, relative } from "path";
+import matter from "gray-matter";
+import { glob } from "glob";
+async function readSourceFile(filePath) {
+  const raw = await readFile2(filePath, "utf-8");
+  const { data, content } = matter(raw);
+  const config = await getConfig();
+  return {
+    filePath,
+    relativePath: relative(config.workflowDir, filePath),
+    meta: data,
+    content: content.trim()
+  };
+}
+async function writeSourceFile(filePath, meta, content) {
+  const output = matter.stringify(content, meta);
+  await writeFile3(filePath, output, "utf-8");
+}
+async function updateSourceTags(filePath, tags) {
+  const source = await readSourceFile(filePath);
+  source.meta.tags = tags;
+  source.meta.taggedAt = (/* @__PURE__ */ new Date()).toISOString();
+  source.meta.taggedBy = "local-claude";
+  await writeSourceFile(filePath, source.meta, source.content);
+}
+async function listSources(options) {
+  const config = await getConfig();
+  const baseDir = options.folder ? join3(config.workflowDir, "sources", options.folder) : join3(config.workflowDir, "sources");
+  const files = await glob("**/*.md", { cwd: baseDir, absolute: true });
+  const sources = [];
+  for (const file of files) {
+    try {
+      const source = await readSourceFile(file);
+      if (options.tagged === true && (!source.meta.tags || source.meta.tags.length === 0)) {
+        continue;
+      }
+      if (options.tagged === false && source.meta.tags && source.meta.tags.length > 0) {
+        continue;
+      }
+      sources.push(source);
+    } catch {
+      continue;
+    }
+  }
+  sources.sort(
+    (a, b) => new Date(b.meta.published || 0).getTime() - new Date(a.meta.published || 0).getTime()
+  );
+  if (options.limit && options.limit > 0) {
+    return sources.slice(0, options.limit);
+  }
+  return sources;
+}
+async function searchSources(options) {
+  const all = await listSources({ tagged: true });
+  let results = all;
+  if (options.tags && options.tags.length > 0) {
+    results = results.filter(
+      (s) => options.tags.some((tag) => s.meta.tags?.includes(tag))
+    );
+  }
+  if (options.dateFrom) {
+    const from = new Date(options.dateFrom).getTime();
+    results = results.filter(
+      (s) => new Date(s.meta.published || 0).getTime() >= from
+    );
+  }
+  if (options.dateTo) {
+    const to = new Date(options.dateTo).getTime();
+    results = results.filter(
+      (s) => new Date(s.meta.published || 0).getTime() <= to
+    );
+  }
+  if (options.query) {
+    const q = options.query.toLowerCase();
+    results = results.filter(
+      (s) => s.meta.title.toLowerCase().includes(q) || s.content.toLowerCase().includes(q)
+    );
+  }
+  if (options.limit && options.limit > 0) {
+    return results.slice(0, options.limit);
+  }
+  return results;
+}
+async function addToTagQueue(file, title, source) {
+  const queue = await getTagQueue();
+  if (queue.queue.some((item) => item.file === file)) return;
+  queue.queue.push({
+    file,
+    title,
+    addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source
+  });
+  queue.queue.sort((a, b) => {
+    if (a.source === "manual" && b.source === "crawl") return -1;
+    if (a.source === "crawl" && b.source === "manual") return 1;
+    return new Date(a.addedAt).getTime() - new Date(b.addedAt).getTime();
+  });
+  await saveTagQueue(queue);
+}
+async function getNextTagBatch() {
+  const config = await getConfig();
+  const queue = await getTagQueue();
+  return queue.queue.slice(0, config.maxTagQueueBatch);
+}
+async function markTagged(file, tagsCount) {
+  const queue = await getTagQueue();
+  queue.queue = queue.queue.filter((item) => item.file !== file);
+  const totalBefore = queue.history.totalProcessed;
+  const avgBefore = queue.history.avgTagsPerItem;
+  queue.history.totalProcessed = totalBefore + 1;
+  queue.history.avgTagsPerItem = (avgBefore * totalBefore + tagsCount) / (totalBefore + 1);
+  queue.history.lastProcessed = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTagQueue(queue);
+}
+async function markTagFailed(file) {
+  const queue = await getTagQueue();
+  const idx = queue.queue.findIndex((item2) => item2.file === file);
+  if (idx === -1) return;
+  const item = queue.queue[idx];
+  item.retryCount = (item.retryCount || 0) + 1;
+  if (item.retryCount >= 3) {
+    queue.queue.splice(idx, 1);
+    queue.failed.push(item);
+  }
+  await saveTagQueue(queue);
+}
+
+// src/tools/source.ts
+var sourceAddSchema = z2.object({
+  title: z2.string().describe("\u7D20\u6750\u6807\u9898"),
+  content: z2.string().describe("\u7D20\u6750\u6B63\u6587"),
+  url: z2.string().optional().describe("\u6765\u6E90 URL"),
+  tags: z2.array(z2.string()).optional().describe("\u6807\u7B7E\uFF08\u5982\u4E0D\u63D0\u4F9B\u5219\u52A0\u5165\u6807\u7B7E\u961F\u5217\u7531 Claude \u540E\u7EED\u6253\u6807\u7B7E\uFF09"),
+  folder: z2.string().optional().describe("\u5B58\u653E\u5B50\u76EE\u5F55\uFF0C\u5982 articles/techcrunch")
+});
+async function sourceAdd(input) {
+  const config = await getConfig();
+  const folder = input.folder || "articles";
+  const dir = join4(config.workflowDir, "sources", folder);
+  await mkdir3(dir, { recursive: true });
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = input.title.replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s-]/g, "").replace(/\s+/g, "-").slice(0, 50);
+  const filename = `${date}-${slug}.md`;
+  const filePath = join4(dir, filename);
+  const meta = {
+    title: input.title,
+    source: input.url ? new URL(input.url).hostname : "manual",
+    published: date,
+    url: input.url
+  };
+  if (input.tags && input.tags.length > 0) {
+    meta.tags = input.tags;
+    meta.taggedAt = (/* @__PURE__ */ new Date()).toISOString();
+    meta.taggedBy = "local-claude";
+    await writeSourceFile(filePath, meta, input.content);
+    return {
+      success: true,
+      message: `\u7D20\u6750\u5DF2\u5165\u5E93: ${filename}\uFF08\u542B ${input.tags.length} \u4E2A\u6807\u7B7E\uFF09`,
+      data: { file: filePath, tags: input.tags }
+    };
+  } else {
+    await writeSourceFile(filePath, meta, input.content);
+    const relativePath = `sources/${folder}/${filename}`;
+    await addToTagQueue(relativePath, input.title, "manual");
+    return {
+      success: true,
+      message: `\u7D20\u6750\u5DF2\u5165\u5E93: ${filename}\uFF08\u5DF2\u52A0\u5165\u6807\u7B7E\u961F\u5217\uFF0C\u7B49\u5F85 Claude \u6253\u6807\u7B7E\uFF09`,
+      data: { file: filePath, queued: true }
+    };
+  }
+}
+var sourceSearchSchema = z2.object({
+  query: z2.string().optional().describe("\u5173\u952E\u8BCD\u641C\u7D22"),
+  tags: z2.array(z2.string()).optional().describe("\u6309\u6807\u7B7E\u7B5B\u9009"),
+  dateFrom: z2.string().optional().describe("\u8D77\u59CB\u65E5\u671F YYYY-MM-DD"),
+  dateTo: z2.string().optional().describe("\u622A\u6B62\u65E5\u671F YYYY-MM-DD"),
+  limit: z2.number().optional().describe("\u8FD4\u56DE\u6570\u91CF\u4E0A\u9650")
+});
+async function sourceSearch(input) {
+  const results = await searchSources({
+    query: input.query,
+    tags: input.tags,
+    dateFrom: input.dateFrom,
+    dateTo: input.dateTo,
+    limit: input.limit
+  });
+  return {
+    success: true,
+    message: `\u627E\u5230 ${results.length} \u7BC7\u76F8\u5173\u7D20\u6750`,
+    data: results.map((s) => ({
+      file: s.relativePath,
+      title: s.meta.title,
+      tags: s.meta.tags,
+      published: s.meta.published,
+      source: s.meta.source
+    }))
+  };
+}
+var sourceListSchema = z2.object({
+  folder: z2.string().optional().describe("\u5B50\u76EE\u5F55"),
+  tagged: z2.boolean().optional().describe("true=\u5DF2\u6253\u6807\u7B7E, false=\u672A\u6253\u6807\u7B7E, \u4E0D\u4F20=\u5168\u90E8"),
+  limit: z2.number().optional().describe("\u8FD4\u56DE\u6570\u91CF\u4E0A\u9650")
+});
+async function sourceList(input) {
+  const results = await listSources({
+    folder: input.folder,
+    tagged: input.tagged,
+    limit: input.limit
+  });
+  return {
+    success: true,
+    message: `\u5171 ${results.length} \u7BC7\u7D20\u6750`,
+    data: results.map((s) => ({
+      file: s.relativePath,
+      title: s.meta.title,
+      tags: s.meta.tags || [],
+      published: s.meta.published
+    }))
+  };
+}
+var sourceCrawlSchema = z2.object({
+  sourceId: z2.string().optional().describe("\u6307\u5B9A\u722C\u866B\u6E90\u540D\u79F0\uFF0C\u4E0D\u4F20\u5219\u5168\u91CF")
+});
+async function sourceCrawl(input) {
+  const schedules = await getCrawlSchedules();
+  if (schedules.schedules.length === 0) {
+    return {
+      success: false,
+      message: "\u6682\u65E0\u914D\u7F6E\u722C\u866B\u6E90\u3002\u8BF7\u5148\u7528 source.schedule \u6DFB\u52A0\u3002"
+    };
+  }
+  const targets = input.sourceId ? schedules.schedules.filter((s) => s.name === input.sourceId) : schedules.schedules.filter((s) => s.enabled);
+  if (targets.length === 0) {
+    return {
+      success: false,
+      message: `\u672A\u627E\u5230\u722C\u866B\u6E90: ${input.sourceId}`
+    };
+  }
+  return {
+    success: true,
+    message: `\u5DF2\u89E6\u53D1 ${targets.length} \u4E2A\u722C\u866B\u6E90: ${targets.map((t) => t.name).join(", ")}`,
+    data: { triggered: targets.map((t) => t.name) }
+  };
+}
+var sourceScheduleSchema = z2.object({
+  action: z2.enum(["add", "remove", "list"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
+  name: z2.string().optional().describe("\u722C\u866B\u6E90\u540D\u79F0"),
+  url: z2.string().optional().describe("RSS/Sitemap URL"),
+  type: z2.enum(["rss", "sitemap", "custom"]).optional().describe("\u6E90\u7C7B\u578B"),
+  cron: z2.string().optional().describe("Cron \u8868\u8FBE\u5F0F"),
+  targetFolder: z2.string().optional().describe("\u76EE\u6807\u5B58\u653E\u76EE\u5F55")
+});
+async function sourceSchedule(input) {
+  const schedules = await getCrawlSchedules();
+  if (input.action === "list") {
+    return {
+      success: true,
+      message: `\u5171 ${schedules.schedules.length} \u4E2A\u722C\u866B\u6E90`,
+      data: schedules.schedules
+    };
+  }
+  if (input.action === "add") {
+    if (!input.name || !input.url || !input.cron) {
+      return {
+        success: false,
+        message: "\u6DFB\u52A0\u722C\u866B\u6E90\u9700\u8981 name, url, cron \u53C2\u6570"
+      };
+    }
+    if (schedules.schedules.some((s) => s.name === input.name)) {
+      return { success: false, message: `\u722C\u866B\u6E90 ${input.name} \u5DF2\u5B58\u5728` };
+    }
+    schedules.schedules.push({
+      name: input.name,
+      url: input.url,
+      type: input.type || "rss",
+      cron: input.cron,
+      targetFolder: input.targetFolder || `sources/articles/${input.name}/`,
+      enabled: true,
+      lastRun: null
+    });
+    await saveCrawlSchedules(schedules);
+    return {
+      success: true,
+      message: `\u722C\u866B\u6E90 ${input.name} \u5DF2\u6DFB\u52A0\uFF0CCron: ${input.cron}`
+    };
+  }
+  if (input.action === "remove") {
+    if (!input.name) {
+      return { success: false, message: "\u5220\u9664\u722C\u866B\u6E90\u9700\u8981 name \u53C2\u6570" };
+    }
+    schedules.schedules = schedules.schedules.filter(
+      (s) => s.name !== input.name
+    );
+    await saveCrawlSchedules(schedules);
+    return { success: true, message: `\u722C\u866B\u6E90 ${input.name} \u5DF2\u5220\u9664` };
+  }
+  return { success: false, message: "\u672A\u77E5\u64CD\u4F5C" };
+}
+var sourceTagSchema = z2.object({
+  mode: z2.enum(["queue", "single"]).describe("queue=\u5904\u7406\u6807\u7B7E\u961F\u5217, single=\u5355\u4E2A\u6587\u4EF6\u6253\u6807\u7B7E"),
+  file: z2.string().optional().describe("single \u6A21\u5F0F\u9700\u8981\u6307\u5B9A\u6587\u4EF6\u8DEF\u5F84")
+});
+async function sourceTag(input) {
+  if (input.mode === "single") {
+    if (!input.file) {
+      return { success: false, message: "single \u6A21\u5F0F\u9700\u8981 file \u53C2\u6570" };
+    }
+    try {
+      const source = await readSourceFile(input.file);
+      return {
+        success: true,
+        message: `\u8BF7\u4E3A\u4EE5\u4E0B\u7D20\u6750\u751F\u6210 3-8 \u4E2A\u6807\u7B7E:
+
+\u6807\u9898: ${source.meta.title}
+\u6765\u6E90: ${source.meta.source}
+
+\u5185\u5BB9\u6458\u8981: ${source.content.slice(0, 500)}...`,
+        data: {
+          file: input.file,
+          title: source.meta.title,
+          contentPreview: source.content.slice(0, 1e3),
+          needsTags: true
+        }
+      };
+    } catch {
+      return { success: false, message: `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6: ${input.file}` };
+    }
+  }
+  const batch = await getNextTagBatch();
+  if (batch.length === 0) {
+    return {
+      success: true,
+      message: "\u6807\u7B7E\u961F\u5217\u4E3A\u7A7A\uFF0C\u65E0\u9700\u5904\u7406\u3002",
+      data: { pending: 0 }
+    };
+  }
+  const items = [];
+  for (const item of batch) {
+    try {
+      const config = await getConfig();
+      const fullPath = join4(config.workflowDir, item.file);
+      const source = await readSourceFile(fullPath);
+      items.push({
+        file: item.file,
+        title: item.title,
+        contentPreview: source.content.slice(0, 500),
+        source: item.source
+      });
+    } catch {
+      items.push({
+        file: item.file,
+        title: item.title,
+        contentPreview: "[\u65E0\u6CD5\u8BFB\u53D6]",
+        source: item.source
+      });
+    }
+  }
+  const queue = await getTagQueue();
+  return {
+    success: true,
+    message: `\u6807\u7B7E\u961F\u5217\u4E2D\u6709 ${queue.queue.length} \u7BC7\u5F85\u5904\u7406\uFF0C\u672C\u6B21\u6279\u6B21 ${items.length} \u7BC7\u3002\u8BF7\u9010\u6761\u5206\u6790\u5E76\u751F\u6210\u6807\u7B7E\u3002`,
+    data: {
+      totalPending: queue.queue.length,
+      batch: items,
+      needsTags: true
+    }
+  };
+}
+async function sourceTagStatus() {
+  const queue = await getTagQueue();
+  return {
+    success: true,
+    message: `\u5F85\u5904\u7406: ${queue.queue.length} \u7BC7 | \u5931\u8D25: ${queue.failed.length} \u7BC7 | \u7D2F\u8BA1\u5DF2\u5904\u7406: ${queue.history.totalProcessed} \u7BC7 | \u5E73\u5747\u6807\u7B7E\u6570: ${queue.history.avgTagsPerItem.toFixed(1)}`,
+    data: {
+      pending: queue.queue.length,
+      failed: queue.failed.length,
+      totalProcessed: queue.history.totalProcessed,
+      avgTagsPerItem: queue.history.avgTagsPerItem,
+      lastProcessed: queue.history.lastProcessed
+    }
+  };
+}
+var sourceTagApplySchema = z2.object({
+  file: z2.string().describe("\u7D20\u6750\u6587\u4EF6\u8DEF\u5F84"),
+  tags: z2.array(z2.string()).describe("Claude \u751F\u6210\u7684\u6807\u7B7E")
+});
+async function sourceTagApply(input) {
+  try {
+    const config = await getConfig();
+    const fullPath = input.file.startsWith("/") ? input.file : join4(config.workflowDir, input.file);
+    await updateSourceTags(fullPath, input.tags);
+    await markTagged(input.file, input.tags.length);
+    return {
+      success: true,
+      message: `\u6807\u7B7E\u5DF2\u5199\u5165: ${input.tags.join(", ")}`,
+      data: { file: input.file, tags: input.tags }
+    };
+  } catch (err) {
+    await markTagFailed(input.file);
+    return {
+      success: false,
+      message: `\u6807\u7B7E\u5199\u5165\u5931\u8D25: ${err instanceof Error ? err.message : "\u672A\u77E5\u9519\u8BEF"}`
+    };
+  }
+}
+
+// src/tools/draft.ts
+import { z as z3 } from "zod";
+
+// src/lib/drafts.ts
+import { readFile as readFile3, writeFile as writeFile5, mkdir as mkdir4, unlink } from "fs/promises";
+import { join as join5, basename } from "path";
+import matter2 from "gray-matter";
+import { glob as glob2 } from "glob";
+import { randomUUID } from "crypto";
+function getDraftDir(account, workflowDir) {
+  if (account.toLowerCase() === "auston") {
+    return join5(workflowDir, "drafts");
+  }
+  return join5(workflowDir, "accounts", account, "drafts");
+}
+function getPublishedDir(account, workflowDir) {
+  if (account.toLowerCase() === "auston") {
+    return join5(workflowDir, "published");
+  }
+  return join5(workflowDir, "accounts", account, "published");
+}
+function generateDraftFilename(title) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const slug = title.replace(/[^\u4e00-\u9fa5a-zA-Z0-9\s-]/g, "").replace(/\s+/g, "-").slice(0, 50);
+  return `${date}-${slug}.md`;
+}
+async function saveDraft(options) {
+  const config = await getConfig();
+  const dir = getDraftDir(options.account, config.workflowDir);
+  await mkdir4(dir, { recursive: true });
+  const id = randomUUID().slice(0, 8);
+  const filename = generateDraftFilename(options.title);
+  const filePath = join5(dir, filename);
+  const meta = {
+    id,
+    account: options.account,
+    platform: options.platform,
+    title: options.title,
+    status: options.status || "draft",
+    tags: options.tags || [],
+    wordCount: options.content.length,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const output = matter2.stringify(options.content, meta);
+  await writeFile5(filePath, output, "utf-8");
+  return { filePath, meta, content: options.content };
+}
+async function listDrafts(options) {
+  const config = await getConfig();
+  const drafts = [];
+  const dirs = [];
+  if (options?.account) {
+    dirs.push(getDraftDir(options.account, config.workflowDir));
+  } else {
+    dirs.push(join5(config.workflowDir, "drafts"));
+    const accountGlob = await glob2("accounts/*/drafts", {
+      cwd: config.workflowDir,
+      absolute: true
+    });
+    dirs.push(...accountGlob);
+  }
+  for (const dir of dirs) {
+    try {
+      const files = await glob2("*.md", { cwd: dir, absolute: true });
+      for (const file of files) {
+        try {
+          const raw = await readFile3(file, "utf-8");
+          const { data, content } = matter2(raw);
+          const meta = data;
+          if (options?.status && meta.status !== options.status) continue;
+          drafts.push({ filePath: file, meta, content: content.trim() });
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  drafts.sort(
+    (a, b) => new Date(b.meta.updatedAt).getTime() - new Date(a.meta.updatedAt).getTime()
+  );
+  return drafts;
+}
+async function updateDraft(options) {
+  const raw = await readFile3(options.file, "utf-8");
+  const { data, content } = matter2(raw);
+  const meta = data;
+  if (options.title) meta.title = options.title;
+  if (options.status) meta.status = options.status;
+  if (options.tags) meta.tags = options.tags;
+  const newContent = options.content ?? content.trim();
+  meta.wordCount = newContent.length;
+  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const output = matter2.stringify(newContent, meta);
+  await writeFile5(options.file, output, "utf-8");
+  return { filePath: options.file, meta, content: newContent };
+}
+async function deleteDraft(file) {
+  await unlink(file);
+}
+async function publishDraft(options) {
+  const raw = await readFile3(options.file, "utf-8");
+  const { data, content } = matter2(raw);
+  const meta = data;
+  meta.status = "published";
+  meta.publishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (options.platformUrl) meta.platformUrl = options.platformUrl;
+  meta.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const config = await getConfig();
+  const publishedDir = getPublishedDir(meta.account, config.workflowDir);
+  await mkdir4(publishedDir, { recursive: true });
+  const newPath = join5(publishedDir, basename(options.file));
+  const output = matter2.stringify(content.trim(), meta);
+  await writeFile5(newPath, output, "utf-8");
+  await unlink(options.file);
+  return { filePath: newPath, meta, content: content.trim() };
+}
+
+// src/tools/draft.ts
+var draftSaveSchema = z3.object({
+  account: z3.string().describe("\u8D26\u53F7\u540D\u79F0"),
+  platform: z3.string().describe("\u5E73\u53F0\u540D\u79F0\uFF0C\u5982 wechat"),
+  title: z3.string().describe("\u6587\u7AE0\u6807\u9898"),
+  content: z3.string().describe("\u6587\u7AE0\u6B63\u6587\uFF08Markdown\uFF09"),
+  tags: z3.array(z3.string()).optional().describe("\u6587\u7AE0\u6807\u7B7E"),
+  status: z3.enum(["draft", "review", "ready"]).optional().describe("\u521D\u59CB\u72B6\u6001\uFF0C\u9ED8\u8BA4 draft")
+});
+async function draftSave(input) {
+  const draft = await saveDraft({
+    account: input.account,
+    platform: input.platform,
+    title: input.title,
+    content: input.content,
+    tags: input.tags,
+    status: input.status
+  });
+  return {
+    success: true,
+    message: `\u8349\u7A3F\u5DF2\u4FDD\u5B58: ${draft.meta.title} (${draft.meta.wordCount} \u5B57)`,
+    data: {
+      file: draft.filePath,
+      id: draft.meta.id,
+      status: draft.meta.status
+    }
+  };
+}
+var draftListSchema = z3.object({
+  account: z3.string().optional().describe("\u6309\u8D26\u53F7\u7B5B\u9009"),
+  status: z3.enum(["draft", "review", "ready", "published", "archived"]).optional().describe("\u6309\u72B6\u6001\u7B5B\u9009")
+});
+async function draftList(input) {
+  const drafts = await listDrafts({
+    account: input.account,
+    status: input.status
+  });
+  return {
+    success: true,
+    message: `\u627E\u5230 ${drafts.length} \u7BC7\u8349\u7A3F`,
+    data: drafts.map((d) => ({
+      file: d.filePath,
+      id: d.meta.id,
+      account: d.meta.account,
+      platform: d.meta.platform,
+      title: d.meta.title,
+      status: d.meta.status,
+      wordCount: d.meta.wordCount,
+      updatedAt: d.meta.updatedAt
+    }))
+  };
+}
+var draftUpdateSchema = z3.object({
+  file: z3.string().describe("\u8349\u7A3F\u6587\u4EF6\u8DEF\u5F84"),
+  content: z3.string().optional().describe("\u66F4\u65B0\u7684\u6B63\u6587"),
+  title: z3.string().optional().describe("\u66F4\u65B0\u7684\u6807\u9898"),
+  status: z3.enum(["draft", "review", "ready"]).optional().describe("\u66F4\u65B0\u72B6\u6001"),
+  tags: z3.array(z3.string()).optional().describe("\u66F4\u65B0\u6807\u7B7E")
+});
+async function draftUpdate(input) {
+  const draft = await updateDraft({
+    file: input.file,
+    content: input.content,
+    title: input.title,
+    status: input.status,
+    tags: input.tags
+  });
+  return {
+    success: true,
+    message: `\u8349\u7A3F\u5DF2\u66F4\u65B0: ${draft.meta.title}`,
+    data: {
+      file: draft.filePath,
+      status: draft.meta.status,
+      wordCount: draft.meta.wordCount
+    }
+  };
+}
+var draftDeleteSchema = z3.object({
+  file: z3.string().describe("\u8349\u7A3F\u6587\u4EF6\u8DEF\u5F84")
+});
+async function draftDelete(input) {
+  await deleteDraft(input.file);
+  return {
+    success: true,
+    message: `\u8349\u7A3F\u5DF2\u5220\u9664: ${input.file}`
+  };
+}
+var draftPublishSchema = z3.object({
+  file: z3.string().describe("\u8349\u7A3F\u6587\u4EF6\u8DEF\u5F84"),
+  platformUrl: z3.string().optional().describe("\u5E73\u53F0\u53D1\u5E03\u94FE\u63A5")
+});
+async function draftPublish(input) {
+  const draft = await publishDraft({
+    file: input.file,
+    platformUrl: input.platformUrl
+  });
+  return {
+    success: true,
+    message: `\u5DF2\u53D1\u5E03: ${draft.meta.title} \u2192 ${draft.filePath}`,
+    data: {
+      file: draft.filePath,
+      publishedAt: draft.meta.publishedAt,
+      platformUrl: draft.meta.platformUrl
+    }
+  };
+}
+
+// src/tools/analytics.ts
+import { z as z4 } from "zod";
+var analyticsPushSchema = z4.object({
+  articleId: z4.string().describe("\u6587\u7AE0 ID"),
+  metrics: z4.object({
+    reads: z4.number().describe("\u9605\u8BFB\u6570"),
+    likes: z4.number().describe("\u70B9\u8D5E\u6570"),
+    shares: z4.number().describe("\u5206\u4EAB\u6570"),
+    comments: z4.number().describe("\u8BC4\u8BBA\u6570"),
+    followers: z4.number().optional().describe("\u65B0\u589E\u5173\u6CE8")
+  })
+});
+async function analyticsPush(input) {
+  const payload = {
+    articleId: input.articleId,
+    metrics: input.metrics,
+    recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const res = await pushSyncBatch({
+    sources: [],
+    drafts: [],
+    published: [],
+    analytics: [payload]
+  });
+  if (!res.ok) {
+    return {
+      success: false,
+      message: `\u6570\u636E\u63A8\u9001\u5931\u8D25: ${res.error}\uFF08\u6570\u636E\u5DF2\u7F13\u5B58\u5728\u672C\u5730\uFF0C\u4E0B\u6B21\u540C\u6B65\u65F6\u91CD\u8BD5\uFF09`
+    };
+  }
+  return {
+    success: true,
+    message: `\u6570\u636E\u5DF2\u63A8\u9001: \u9605\u8BFB ${input.metrics.reads} | \u70B9\u8D5E ${input.metrics.likes} | \u5206\u4EAB ${input.metrics.shares} | \u8BC4\u8BBA ${input.metrics.comments}`,
+    data: payload
+  };
+}
+var analyticsReportSchema = z4.object({
+  account: z4.string().optional().describe("\u6309\u8D26\u53F7\u7B5B\u9009"),
+  period: z4.enum(["7d", "30d", "90d", "all"]).optional().describe("\u65F6\u95F4\u8303\u56F4")
+});
+async function analyticsReport(input) {
+  return {
+    success: true,
+    message: "\u6570\u636E\u62A5\u544A\u529F\u80FD\u9700\u8981\u4E91\u7AEF Dashboard \u652F\u6301\uFF0C\u8BF7\u8BBF\u95EE https://app.claudeink.app \u67E5\u770B\u8BE6\u7EC6\u6570\u636E\u5206\u6790\u3002",
+    data: {
+      dashboardUrl: "https://app.claudeink.app/analytics",
+      account: input.account,
+      period: input.period || "30d"
+    }
+  };
+}
+
+// src/tools/account.ts
+import { z as z5 } from "zod";
+import { readFile as readFile4, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { join as join6 } from "path";
+import { glob as glob3 } from "glob";
+async function accountList() {
+  const config = await getConfig();
+  const yamlFiles = await glob3("accounts/*.yaml", {
+    cwd: config.workflowDir,
+    absolute: true
+  });
+  const accounts = [];
+  for (const file of yamlFiles) {
+    if (file.endsWith("_template.yaml")) continue;
+    try {
+      const content = await readFile4(file, "utf-8");
+      const name = extractYamlField(content, "name");
+      const platform = extractYamlField(content, "platform");
+      const desc = extractYamlField(content, "description");
+      accounts.push({ name, platform, description: desc, file });
+    } catch {
+      continue;
+    }
+  }
+  return {
+    success: true,
+    message: `\u5171 ${accounts.length} \u4E2A\u8D26\u53F7`,
+    data: accounts
+  };
+}
+var accountSwitchSchema = z5.object({
+  name: z5.string().describe("\u8981\u5207\u6362\u5230\u7684\u8D26\u53F7\u540D\u79F0")
+});
+async function accountSwitch(input) {
+  const config = await getConfig();
+  const yamlPath = join6(config.workflowDir, "accounts", `${input.name}.yaml`);
+  try {
+    const content = await readFile4(yamlPath, "utf-8");
+    const platform = extractYamlField(content, "platform");
+    let platformRules = "";
+    if (platform) {
+      try {
+        platformRules = await readFile4(
+          join6(config.workflowDir, "platforms", `${platform}.md`),
+          "utf-8"
+        );
+      } catch {
+        platformRules = "[\u5E73\u53F0\u89C4\u5219\u6587\u4EF6\u4E0D\u5B58\u5728]";
+      }
+    }
+    return {
+      success: true,
+      message: `\u5DF2\u5207\u6362\u5230\u8D26\u53F7: ${input.name} (${platform || "\u672A\u77E5\u5E73\u53F0"})\u3002\u8BF7\u6309\u987A\u5E8F\u52A0\u8F7D\uFF1A
+1. base-rules.md
+2. platforms/${platform}.md
+3. accounts/${input.name}.yaml`,
+      data: {
+        account: input.name,
+        platform,
+        configFile: yamlPath,
+        platformRulesLoaded: platformRules.length > 0
+      }
+    };
+  } catch {
+    return {
+      success: false,
+      message: `\u8D26\u53F7 ${input.name} \u4E0D\u5B58\u5728\u3002\u8BF7\u68C0\u67E5 accounts/ \u76EE\u5F55\u3002`
+    };
+  }
+}
+var accountCreateSchema = z5.object({
+  name: z5.string().describe("\u8D26\u53F7\u540D\u79F0\uFF08\u82F1\u6587\u5C0F\u5199\uFF0C\u7528\u4F5C\u6587\u4EF6\u540D\uFF09"),
+  platform: z5.string().describe("\u5E73\u53F0\u540D\u79F0\uFF0C\u5982 wechat, xiaohongshu"),
+  displayName: z5.string().optional().describe("\u663E\u793A\u540D\u79F0"),
+  domains: z5.array(z5.string()).describe("\u5185\u5BB9\u9886\u57DF"),
+  description: z5.string().optional().describe("\u8D26\u53F7\u5B9A\u4F4D\u63CF\u8FF0")
+});
+async function accountCreate(input) {
+  const config = await getConfig();
+  const yamlPath = join6(config.workflowDir, "accounts", `${input.name}.yaml`);
+  try {
+    await readFile4(yamlPath);
+    return { success: false, message: `\u8D26\u53F7 ${input.name} \u5DF2\u5B58\u5728` };
+  } catch {
+  }
+  let template = "";
+  try {
+    template = await readFile4(
+      join6(config.workflowDir, "accounts", "_template.yaml"),
+      "utf-8"
+    );
+  } catch {
+    template = defaultTemplate();
+  }
+  const yamlContent = template.replace(/name:\s*""/, `name: "${input.displayName || input.name}"`).replace(/platform:\s*""/, `platform: "${input.platform}"`).replace(/description:\s*""/, `description: "${input.description || ""}"`).replace(
+    /domains:\s*\[\]/,
+    `domains:
+${input.domains.map((d) => `  - "${d}"`).join("\n")}`
+  );
+  await writeFile6(yamlPath, yamlContent, "utf-8");
+  const accountDir = join6(config.workflowDir, "accounts", input.name);
+  await mkdir5(join6(accountDir, "drafts"), { recursive: true });
+  await mkdir5(join6(accountDir, "published"), { recursive: true });
+  await mkdir5(join6(accountDir, "assets"), { recursive: true });
+  return {
+    success: true,
+    message: `\u8D26\u53F7 ${input.name} \u5DF2\u521B\u5EFA
+\u914D\u7F6E: accounts/${input.name}.yaml
+\u76EE\u5F55: accounts/${input.name}/drafts/, published/, assets/`,
+    data: {
+      config: yamlPath,
+      directories: [
+        `accounts/${input.name}/drafts/`,
+        `accounts/${input.name}/published/`,
+        `accounts/${input.name}/assets/`
+      ]
+    }
+  };
+}
+function extractYamlField(yaml, field) {
+  const regex = new RegExp(`^${field}:\\s*["']?([^"'\\n]+)["']?`, "m");
+  const match = yaml.match(regex);
+  return match ? match[1].trim() : "";
+}
+function defaultTemplate() {
+  return `# ClaudeInk \u8D26\u53F7\u914D\u7F6E
+name: ""
+platform: ""
+description: ""
+
+domains: []
+
+audience:
+  age_range: ""
+  interests: []
+
+style:
+  tone: "\u5E73\u5B9E"
+  voice: "\u53E3\u8BED\u5316"
+  formality: "medium"
+  emotion: "\u9002\u5EA6"
+  humor: "\u5076\u5C14"
+  language: "zh-CN"
+
+persona: ""
+
+content_rules:
+  min_words: null
+  max_words: null
+  paragraph_style: null
+
+templates: []
+
+paths:
+  drafts: null
+  published: null
+  assets: null
+`;
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "ClaudeInk",
+  version: "0.1.0"
+});
+server.tool("auth.activate", "\u9A8C\u8BC1 license key \u5E76\u6FC0\u6D3B ClaudeInk", activateSchema.shape, async (input) => {
+  const result = await authActivate(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("auth.status", "\u67E5\u770B\u5F53\u524D\u6388\u6743\u72B6\u6001", {}, async () => {
+  const result = await authStatus();
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("config.sync", "\u62C9\u53D6\u4E91\u7AEF\u6700\u65B0\u5DE5\u4F5C\u6D41\u914D\u7F6E", {}, async () => {
+  const result = await configSync();
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("config.version", "\u67E5\u770B\u672C\u5730\u914D\u7F6E\u7248\u672C", {}, async () => {
+  const result = await configVersion();
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.add", "\u6DFB\u52A0\u7D20\u6750\u5230\u672C\u5730\u7D20\u6750\u5E93", sourceAddSchema.shape, async (input) => {
+  const result = await sourceAdd(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.search", "\u641C\u7D22\u672C\u5730\u7D20\u6750", sourceSearchSchema.shape, async (input) => {
+  const result = await sourceSearch(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.list", "\u5217\u51FA\u7D20\u6750\u76EE\u5F55", sourceListSchema.shape, async (input) => {
+  const result = await sourceList(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.crawl", "\u89E6\u53D1\u722C\u866B\u6293\u53D6", sourceCrawlSchema.shape, async (input) => {
+  const result = await sourceCrawl(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.schedule", "\u7BA1\u7406\u5B9A\u65F6\u722C\u866B\u4EFB\u52A1", sourceScheduleSchema.shape, async (input) => {
+  const result = await sourceSchedule(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.tag", "\u5904\u7406\u7D20\u6750\u6807\u7B7E\uFF08\u961F\u5217\u6216\u5355\u4E2A\uFF09", sourceTagSchema.shape, async (input) => {
+  const result = await sourceTag(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.tag_status", "\u67E5\u770B\u6807\u7B7E\u961F\u5217\u72B6\u6001", {}, async () => {
+  const result = await sourceTagStatus();
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("source.tag_apply", "\u5199\u5165 Claude \u751F\u6210\u7684\u6807\u7B7E\u5230\u7D20\u6750\u6587\u4EF6", sourceTagApplySchema.shape, async (input) => {
+  const result = await sourceTagApply(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("draft.save", "\u4FDD\u5B58\u8349\u7A3F", draftSaveSchema.shape, async (input) => {
+  const result = await draftSave(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("draft.list", "\u5217\u51FA\u8349\u7A3F", draftListSchema.shape, async (input) => {
+  const result = await draftList(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("draft.update", "\u66F4\u65B0\u8349\u7A3F", draftUpdateSchema.shape, async (input) => {
+  const result = await draftUpdate(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("draft.delete", "\u5220\u9664\u8349\u7A3F", draftDeleteSchema.shape, async (input) => {
+  const result = await draftDelete(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("draft.publish", "\u6807\u8BB0\u8349\u7A3F\u4E3A\u5DF2\u53D1\u5E03", draftPublishSchema.shape, async (input) => {
+  const result = await draftPublish(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("analytics.push", "\u63A8\u9001\u6587\u7AE0\u8868\u73B0\u6570\u636E", analyticsPushSchema.shape, async (input) => {
+  const result = await analyticsPush(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("analytics.report", "\u83B7\u53D6\u6570\u636E\u5206\u6790\u62A5\u544A", analyticsReportSchema.shape, async (input) => {
+  const result = await analyticsReport(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("account.list", "\u5217\u51FA\u6240\u6709\u8D26\u53F7", {}, async () => {
+  const result = await accountList();
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("account.switch", "\u5207\u6362\u5F53\u524D\u8D26\u53F7", accountSwitchSchema.shape, async (input) => {
+  const result = await accountSwitch(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.tool("account.create", "\u521B\u5EFA\u65B0\u8D26\u53F7", accountCreateSchema.shape, async (input) => {
+  const result = await accountCreate(input);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[ClaudeInk MCP] Server started on stdio");
+}
+main().catch((err) => {
+  console.error("[ClaudeInk MCP] Fatal error:", err);
+  process.exit(1);
+});