@claudeink/mcp-server 0.4.0 → 0.6.0

package/dist/index.js

@@ -4,8 +4,10 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
-// src/tools/auth.ts
+// src/tools/source.ts
 import { z } from "zod";
+import { mkdir as mkdir3, readFile as readFile4 } from "fs/promises";
+import { join as join4 } from "path";
 
 // src/lib/config.ts
 import { readFile, writeFile, mkdir, chmod, access } from "fs/promises";
@@ -21,18 +23,13 @@ var PATHS = {
   logs: join(CLAUDEINK_DIR, "logs")
 };
 var DEFAULT_CONFIG = {
-  apiBaseUrl: "https://api.claudeink.app",
+  apiBaseUrl: "https://app.claudeink.com",
   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: [],
@@ -42,9 +39,6 @@ var DEFAULT_TAG_QUEUE = {
     avgTagsPerItem: 0
   }
 };
-var DEFAULT_CRAWL_SCHEDULES = {
-  schedules: []
-};
 async function ensureDir() {
   await mkdir(CLAUDEINK_DIR, { recursive: true });
   await mkdir(PATHS.logs, { recursive: true });
@@ -76,214 +70,19 @@ 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 { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2, relative } from "path";
 import matter from "gray-matter";
 import { glob } from "glob";
 async function readSourceFile(filePath) {
@@ -299,7 +98,7 @@ async function readSourceFile(filePath) {
 }
 async function writeSourceFile(filePath, meta, content) {
   const output = matter.stringify(content, meta);
-  await writeFile3(filePath, output, "utf-8");
+  await writeFile2(filePath, output, "utf-8");
 }
 async function updateSourceTags(filePath, tags) {
   const source = await readSourceFile(filePath);
@@ -308,64 +107,6 @@ async function updateSourceTags(filePath, tags) {
   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;
@@ -410,13 +151,87 @@ async function markTagFailed(file) {
   await saveTagQueue(queue);
 }
 
+// src/lib/state.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { join as join3 } from "path";
+var DEFAULT_STATE = {
+  sources: {},
+  drafts: {},
+  published: {},
+  configs: {},
+  crawlerSources: {},
+  writingMasters: {},
+  lastSyncAt: ""
+};
+async function getStatePath() {
+  const config = await getConfig();
+  const dir = join3(config.workflowDir || process.cwd(), ".claudeink");
+  await mkdir2(dir, { recursive: true });
+  return join3(dir, "state.json");
+}
+async function readState() {
+  try {
+    const path = await getStatePath();
+    const content = await readFile3(path, "utf-8");
+    return { ...DEFAULT_STATE, ...JSON.parse(content) };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+async function writeState(state) {
+  const path = await getStatePath();
+  await writeFile3(path, JSON.stringify(state, null, 2), "utf-8");
+}
+async function updateSource(id, data) {
+  const state = await readState();
+  state.sources[id] = data;
+  await writeState(state);
+}
+async function updateSourceTags2(id, tags) {
+  const state = await readState();
+  if (state.sources[id]) {
+    state.sources[id].tags = tags;
+    state.sources[id].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  }
+  await writeState(state);
+}
+async function updateDraft(id, data) {
+  const state = await readState();
+  state.drafts[id] = data;
+  await writeState(state);
+}
+async function moveDraftToPublished(id, data) {
+  const state = await readState();
+  delete state.drafts[id];
+  state.published[id] = data;
+  await writeState(state);
+}
+async function updateCrawlerSource(id, data) {
+  const state = await readState();
+  state.crawlerSources[id] = data;
+  await writeState(state);
+}
+async function removeCrawlerSource(id) {
+  const state = await readState();
+  delete state.crawlerSources[id];
+  await writeState(state);
+}
+async function updateLastSyncAt() {
+  const state = await readState();
+  state.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeState(state);
+}
+async function replaceState(state) {
+  await writeState(state);
+}
+
 // 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")
+var sourceAddSchema = z.object({
+  title: z.string().describe("\u7D20\u6750\u6807\u9898"),
+  content: z.string().describe("\u7D20\u6750\u6B63\u6587"),
+  url: z.string().optional().describe("\u6765\u6E90 URL"),
+  tags: z.array(z.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: z.string().optional().describe("\u5B58\u653E\u5B50\u76EE\u5F55\uFF0C\u5982 articles/techcrunch")
 });
 async function sourceAdd(input) {
   const config = await getConfig();
@@ -429,7 +244,13 @@ async function sourceAdd(input) {
   const filePath = join4(dir, filename);
   const meta = {
     title: input.title,
-    source: input.url ? new URL(input.url).hostname : "manual",
+    source: input.url ? (() => {
+      try {
+        return new URL(input.url).hostname;
+      } catch {
+        return input.url;
+      }
+    })() : "manual",
     published: date,
     url: input.url
   };
@@ -438,6 +259,16 @@ async function sourceAdd(input) {
     meta.taggedAt = (/* @__PURE__ */ new Date()).toISOString();
     meta.taggedBy = "local-claude";
     await writeSourceFile(filePath, meta, input.content);
+    await updateSource(slug, {
+      title: input.title,
+      source: meta.source,
+      sourceIcon: "",
+      sourceUrl: input.url || "",
+      coverUrl: "",
+      tags: input.tags,
+      publishedAt: date,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     return {
       success: true,
       message: `\u7D20\u6750\u5DF2\u5165\u5E93: ${filename}\uFF08\u542B ${input.tags.length} \u4E2A\u6807\u7B7E\uFF09`,
@@ -447,6 +278,16 @@ async function sourceAdd(input) {
     await writeSourceFile(filePath, meta, input.content);
     const relativePath = `sources/${folder}/${filename}`;
     await addToTagQueue(relativePath, input.title, "manual");
+    await updateSource(slug, {
+      title: input.title,
+      source: meta.source,
+      sourceIcon: "",
+      sourceUrl: input.url || "",
+      coverUrl: "",
+      tags: [],
+      publishedAt: date,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
     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`,
@@ -454,67 +295,25 @@ async function sourceAdd(input) {
     };
   }
 }
-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")
+var sourceCrawlSchema = z.object({
+  sourceId: z.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) {
+  const config = await getConfig();
+  const configPath = join4(config.workflowDir || process.cwd(), "tools", "crawler", "config.json");
+  let crawlerConfig;
+  try {
+    crawlerConfig = JSON.parse(await readFile4(configPath, "utf-8"));
+  } catch {
+    crawlerConfig = { sources: [] };
+  }
+  if (crawlerConfig.sources.length === 0) {
     return {
       success: false,
-      message: "\u6682\u65E0\u914D\u7F6E\u722C\u866B\u6E90\u3002\u8BF7\u5148\u7528 source.schedule \u6DFB\u52A0\u3002"
+      message: "\u6682\u65E0\u914D\u7F6E\u722C\u866B\u6E90\u3002\u8BF7\u5148\u7528 source.subscribe \u6DFB\u52A0\u3002"
     };
   }
-  const targets = input.sourceId ? schedules.schedules.filter((s) => s.name === input.sourceId) : schedules.schedules.filter((s) => s.enabled);
+  const targets = input.sourceId ? crawlerConfig.sources.filter((s) => s.name === input.sourceId) : crawlerConfig.sources.filter((s) => s.enabled !== false);
   if (targets.length === 0) {
     return {
       success: false,
@@ -527,63 +326,9 @@ async function sourceCrawl(input) {
     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")
+var sourceTagSchema = z.object({
+  mode: z.enum(["queue", "single"]).describe("queue=\u5904\u7406\u6807\u7B7E\u961F\u5217, single=\u5355\u4E2A\u6587\u4EF6\u6253\u6807\u7B7E"),
+  file: z.string().optional().describe("single \u6A21\u5F0F\u9700\u8981\u6307\u5B9A\u6587\u4EF6\u8DEF\u5F84")
 });
 async function sourceTag(input) {
   if (input.mode === "single") {
@@ -651,23 +396,9 @@ async function sourceTag(input) {
     }
   };
 }
-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")
+var sourceTagApplySchema = z.object({
+  file: z.string().describe("\u7D20\u6750\u6587\u4EF6\u8DEF\u5F84"),
+  tags: z.array(z.string()).describe("Claude \u751F\u6210\u7684\u6807\u7B7E")
 });
 async function sourceTagApply(input) {
   try {
@@ -675,6 +406,7 @@ async function sourceTagApply(input) {
     const fullPath = input.file.startsWith("/") ? input.file : join4(config.workflowDir, input.file);
     await updateSourceTags(fullPath, input.tags);
     await markTagged(input.file, input.tags.length);
+    await updateSourceTags2(input.file, input.tags);
     return {
       success: true,
       message: `\u6807\u7B7E\u5DF2\u5199\u5165: ${input.tags.join(", ")}`,
@@ -689,26 +421,92 @@ async function sourceTagApply(input) {
   }
 }
 
+// src/tools/subscribe.ts
+import { z as z2 } from "zod";
+import { readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
+import { join as join5 } from "path";
+var sourceSubscribeSchema = z2.object({
+  action: z2.enum(["add", "remove", "list"]).describe("\u64CD\u4F5C\u7C7B\u578B"),
+  id: z2.string().optional().describe("\u8BA2\u9605\u6E90 ID"),
+  name: z2.string().optional().describe("\u8BA2\u9605\u6E90\u540D\u79F0"),
+  url: z2.string().optional().describe("RSS/\u535A\u5BA2 URL"),
+  type: z2.enum(["rss", "blog", "sitemap"]).optional().describe("\u6E90\u7C7B\u578B"),
+  icon: z2.string().optional().describe("\u6765\u6E90 icon URL")
+});
+async function sourceSubscribe(input) {
+  const config = await getConfig();
+  const configPath = join5(config.workflowDir || process.cwd(), "tools/crawler/config.json");
+  let crawlerConfig;
+  try {
+    crawlerConfig = JSON.parse(await readFile5(configPath, "utf-8"));
+  } catch {
+    crawlerConfig = { sources: [] };
+  }
+  if (input.action === "list") {
+    return {
+      success: true,
+      message: `\u5171 ${crawlerConfig.sources.length} \u4E2A\u8BA2\u9605\u6E90`,
+      data: crawlerConfig.sources
+    };
+  }
+  if (input.action === "add") {
+    if (!input.id || !input.name || !input.url) {
+      return { success: false, message: "\u6DFB\u52A0\u8BA2\u9605\u6E90\u9700\u8981 id, name, url \u53C2\u6570" };
+    }
+    if (crawlerConfig.sources.some((s) => s.id === input.id)) {
+      return { success: false, message: `\u8BA2\u9605\u6E90 ${input.id} \u5DF2\u5B58\u5728` };
+    }
+    const newSource = {
+      id: input.id,
+      name: input.name,
+      url: input.url,
+      type: input.type || "rss",
+      icon: input.icon || "",
+      enabled: true
+    };
+    crawlerConfig.sources.push(newSource);
+    await writeFile4(configPath, JSON.stringify(crawlerConfig, null, 2));
+    await updateCrawlerSource(input.id, {
+      name: input.name,
+      url: input.url,
+      type: input.type || "rss",
+      icon: input.icon || "",
+      enabled: true
+    });
+    return { success: true, message: `\u8BA2\u9605\u6E90 ${input.name} \u5DF2\u6DFB\u52A0` };
+  }
+  if (input.action === "remove") {
+    if (!input.id) {
+      return { success: false, message: "\u5220\u9664\u8BA2\u9605\u6E90\u9700\u8981 id \u53C2\u6570" };
+    }
+    crawlerConfig.sources = crawlerConfig.sources.filter((s) => s.id !== input.id);
+    await writeFile4(configPath, JSON.stringify(crawlerConfig, null, 2));
+    await removeCrawlerSource(input.id);
+    return { success: true, message: `\u8BA2\u9605\u6E90 ${input.id} \u5DF2\u5220\u9664` };
+  }
+  return { success: false, message: "\u672A\u77E5\u64CD\u4F5C" };
+}
+
 // 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 { readFile as readFile6, writeFile as writeFile5, mkdir as mkdir4, unlink } from "fs/promises";
+import { join as join6, 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 join6(workflowDir, "drafts");
   }
-  return join5(workflowDir, "accounts", account, "drafts");
+  return join6(workflowDir, "accounts", account, "drafts");
 }
 function getPublishedDir(account, workflowDir) {
   if (account.toLowerCase() === "auston") {
-    return join5(workflowDir, "published");
+    return join6(workflowDir, "published");
   }
-  return join5(workflowDir, "accounts", account, "published");
+  return join6(workflowDir, "accounts", account, "published");
 }
 function generateDraftFilename(title) {
   const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
@@ -721,7 +519,7 @@ async function saveDraft(options) {
   await mkdir4(dir, { recursive: true });
   const id = randomUUID().slice(0, 8);
   const filename = generateDraftFilename(options.title);
-  const filePath = join5(dir, filename);
+  const filePath = join6(dir, filename);
   const meta = {
     id,
     account: options.account,
@@ -737,62 +535,8 @@ async function saveDraft(options) {
   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 raw = await readFile6(options.file, "utf-8");
   const { data, content } = matter2(raw);
   const meta = data;
   meta.status = "published";
@@ -802,7 +546,7 @@ async function publishDraft(options) {
   const config = await getConfig();
   const publishedDir = getPublishedDir(meta.account, config.workflowDir);
   await mkdir4(publishedDir, { recursive: true });
-  const newPath = join5(publishedDir, basename(options.file));
+  const newPath = join6(publishedDir, basename(options.file));
   const output = matter2.stringify(content.trim(), meta);
   await writeFile5(newPath, output, "utf-8");
   await unlink(options.file);
@@ -827,6 +571,16 @@ async function draftSave(input) {
     tags: input.tags,
     status: input.status
   });
+  await updateDraft(draft.meta.id, {
+    title: draft.meta.title,
+    account: input.account,
+    platform: input.platform,
+    status: draft.meta.status,
+    wordCount: draft.meta.wordCount,
+    tags: input.tags || [],
+    createdAt: draft.meta.createdAt,
+    updatedAt: draft.meta.updatedAt
+  });
   return {
     success: true,
     message: `\u8349\u7A3F\u5DF2\u4FDD\u5B58: ${draft.meta.title} (${draft.meta.wordCount} \u5B57)`,
@@ -837,74 +591,22 @@ async function draftSave(input) {
     }
   };
 }
-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")
+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
   });
+  await moveDraftToPublished(draft.meta.id, {
+    title: draft.meta.title,
+    account: draft.meta.account,
+    platform: draft.meta.platform,
+    platformUrl: draft.meta.platformUrl || "",
+    publishedAt: draft.meta.publishedAt || (/* @__PURE__ */ new Date()).toISOString()
+  });
   return {
     success: true,
     message: `\u5DF2\u53D1\u5E03: ${draft.meta.title} \u2192 ${draft.filePath}`,
@@ -918,6 +620,52 @@ async function draftPublish(input) {
 
 // src/tools/analytics.ts
 import { z as z4 } from "zod";
+
+// 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 pushSyncBatch(payload) {
+  return request("/api/sync/batch", {
+    method: "POST",
+    body: payload
+  });
+}
+
+// src/tools/analytics.ts
 var analyticsPushSchema = z4.object({
   articleId: z4.string().describe("\u6587\u7AE0 ID"),
   metrics: z4.object({
@@ -938,6 +686,8 @@ async function analyticsPush(input) {
     sources: [],
     drafts: [],
     published: [],
+    configs: [],
+    crawlerSources: [],
     analytics: [payload]
   });
   if (!res.ok) {
@@ -959,183 +709,220 @@ var analyticsReportSchema = z4.object({
 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",
+    message: "\u6570\u636E\u62A5\u544A\u529F\u80FD\u9700\u8981\u4E91\u7AEF Dashboard \u652F\u6301\uFF0C\u8BF7\u8BBF\u95EE https://app.claudeink.com \u67E5\u770B\u8BE6\u7EC6\u6570\u636E\u5206\u6790\u3002",
     data: {
-      dashboardUrl: "https://app.claudeink.app/analytics",
+      dashboardUrl: "https://app.claudeink.com/analytics",
       account: input.account,
       period: input.period || "30d"
     }
   };
 }
 
-// src/tools/account.ts
+// src/tools/sync.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() {
+import { writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
+import { join as join7 } from "path";
+var syncPushSchema = z5.object({
+  workDir: z5.string().optional().describe("\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u4F7F\u7528\u914D\u7F6E\u4E2D\u7684 workflowDir\uFF09")
+});
+async function syncPush(input) {
+  const creds = await getCredentials();
+  if (!creds?.token) {
+    return { success: false, message: "\u672A\u6FC0\u6D3B\uFF0C\u8BF7\u5148\u4F7F\u7528 workflow.init \u6FC0\u6D3B License" };
+  }
   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;
+  const state = await readState();
+  const payload = {
+    sources: Object.entries(state.sources).map(([id, s]) => ({
+      id,
+      title: s.title,
+      source: s.source,
+      tags: s.tags,
+      sourceUrl: s.sourceUrl,
+      coverUrl: s.coverUrl,
+      sourceIcon: s.sourceIcon,
+      createdAt: s.publishedAt
+    })),
+    drafts: Object.entries(state.drafts).map(([id, d]) => ({
+      id,
+      account: d.account,
+      platform: d.platform,
+      title: d.title,
+      status: d.status,
+      wordCount: d.wordCount,
+      tags: d.tags,
+      createdAt: d.createdAt,
+      updatedAt: d.updatedAt
+    })),
+    published: Object.entries(state.published).map(([id, p]) => ({
+      id,
+      account: p.account,
+      platform: p.platform,
+      title: p.title,
+      platformUrl: p.platformUrl,
+      publishedAt: p.publishedAt
+    })),
+    configs: Object.entries(state.configs).map(([key, c]) => ({
+      type: c.type,
+      name: c.name,
+      displayName: c.displayName,
+      content: c.content,
+      metadata: c.metadata
+    })),
+    crawlerSources: Object.entries(state.crawlerSources).map(([id, cs]) => ({
+      id,
+      name: cs.name,
+      url: cs.url,
+      type: cs.type,
+      icon: cs.icon,
+      enabled: cs.enabled
+    })),
+    analytics: []
+  };
+  try {
+    const res = await fetch(`${config.apiBaseUrl}/api/sync/batch`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${creds.token}`
+      },
+      body: JSON.stringify(payload)
+    });
+    const result = await res.json();
+    if (res.ok) {
+      await updateLastSyncAt();
+      return {
+        success: true,
+        message: [
+          "\u2705 \u540C\u6B65\u5B8C\u6210",
+          `   \u7D20\u6750: ${payload.sources.length} \u7BC7`,
+          `   \u8349\u7A3F: ${payload.drafts.length} \u7BC7`,
+          `   \u5DF2\u53D1\u5E03: ${payload.published.length} \u7BC7`,
+          `   \u914D\u7F6E: ${payload.configs.length} \u4E2A`,
+          `   \u8BA2\u9605\u6E90: ${payload.crawlerSources.length} \u4E2A`,
+          `   \u4E91\u7AEF\u63A5\u53D7: ${result.accepted || 0} \u6761`
+        ].join("\n"),
+        data: { accepted: result.accepted || 0 }
+      };
+    } else {
+      return { success: false, message: `\u540C\u6B65\u5931\u8D25: HTTP ${res.status}` };
     }
+  } catch (err) {
+    return { success: false, message: `\u540C\u6B65\u7F51\u7EDC\u9519\u8BEF: ${err instanceof Error ? err.message : err}` };
   }
-  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")
+var syncPullSchema = z5.object({
+  workDir: z5.string().optional().describe("\u5DE5\u4F5C\u76EE\u5F55")
 });
-async function accountSwitch(input) {
+async function syncPull(input) {
+  const creds = await getCredentials();
+  if (!creds?.token) {
+    return { success: false, message: "\u672A\u6FC0\u6D3B\uFF0C\u8BF7\u5148\u4F7F\u7528 workflow.init \u6FC0\u6D3B License" };
+  }
   const config = await getConfig();
-  const yamlPath = join6(config.workflowDir, "accounts", `${input.name}.yaml`);
+  const workDir = input.workDir || config.workflowDir;
   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]";
+    const res = await fetch(`${config.apiBaseUrl}/api/sync/pull`, {
+      headers: { "Authorization": `Bearer ${creds.token}` }
+    });
+    if (!res.ok) {
+      if (res.status === 404) {
+        return { success: true, message: "\u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u672C\u5730\u9ED8\u8BA4" };
       }
+      return { success: false, message: `\u62C9\u53D6\u5931\u8D25: HTTP ${res.status}` };
     }
-    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
+    const cloudData = await res.json();
+    if (!cloudData.configs || cloudData.configs.length === 0) {
+      return { success: true, message: "\u4E91\u7AEF\u65E0\u914D\u7F6E\u6570\u636E" };
+    }
+    let updated = 0;
+    const state = await readState();
+    for (const cfgItem of cloudData.configs) {
+      const stateKey = `${cfgItem.type}:${cfgItem.name}`;
+      const localUpdatedAt = state.configs[stateKey]?.updatedAt || "";
+      if (!localUpdatedAt || cfgItem.updatedAt > localUpdatedAt) {
+        let filePath = "";
+        if (cfgItem.type === "base_rules") {
+          filePath = join7(workDir, "base-rules.md");
+        } else if (cfgItem.type === "platform") {
+          filePath = join7(workDir, "platforms", `${cfgItem.name}.md`);
+        } else if (cfgItem.type === "account") {
+          filePath = join7(workDir, "accounts", `${cfgItem.name}.yaml`);
+        }
+        if (filePath && cfgItem.content) {
+          await writeFile6(filePath, cfgItem.content, "utf-8");
+          state.configs[stateKey] = {
+            type: cfgItem.type,
+            name: cfgItem.name,
+            displayName: cfgItem.displayName,
+            content: cfgItem.content,
+            metadata: cfgItem.metadata || {},
+            updatedAt: cfgItem.updatedAt
+          };
+          updated++;
+        }
       }
-    };
-  } catch {
+    }
+    let crawlerCount = 0;
+    state.crawlerSources = {};
+    for (const cfg of cloudData.configs || []) {
+      if (cfg.type === "crawler" && cfg.content) {
+        try {
+          const sources = JSON.parse(cfg.content);
+          for (const s of sources) {
+            state.crawlerSources[s.id] = {
+              name: s.name,
+              url: s.url,
+              type: s.type || "rss",
+              icon: s.icon || "",
+              enabled: s.enabled !== false
+            };
+          }
+          const crawlerDir = join7(workDir, "tools", "crawler");
+          await mkdir5(crawlerDir, { recursive: true });
+          const crawlerConfigPath = join7(crawlerDir, "config.json");
+          await writeFile6(crawlerConfigPath, JSON.stringify({ sources }, null, 2), "utf-8");
+          crawlerCount = sources.length;
+        } catch (e) {
+          console.error("[sync.pull] Failed to parse crawler sources:", e);
+        }
+      }
+    }
+    if (cloudData.writingMasters && Object.keys(cloudData.writingMasters).length > 0) {
+      state.writingMasters = state.writingMasters || {};
+      for (const [accountName, master] of Object.entries(cloudData.writingMasters)) {
+        state.writingMasters[accountName] = {
+          id: master.id,
+          name: master.name,
+          stylePrompt: master.stylePrompt
+        };
+      }
+    }
+    await replaceState(state);
+    const masterCount = cloudData.writingMasters ? Object.keys(cloudData.writingMasters).length : 0;
     return {
-      success: false,
-      message: `\u8D26\u53F7 ${input.name} \u4E0D\u5B58\u5728\u3002\u8BF7\u68C0\u67E5 accounts/ \u76EE\u5F55\u3002`
+      success: true,
+      message: updated > 0 || masterCount > 0 || crawlerCount > 0 ? [
+        `\u2705 \u4ECE\u4E91\u7AEF\u540C\u6B65\u4E86 ${updated} \u4E2A\u914D\u7F6E\u6587\u4EF6`,
+        crawlerCount > 0 ? `   \u8BA2\u9605\u6E90: ${crawlerCount} \u4E2A` : "",
+        masterCount > 0 ? `   \u5199\u4F5C\u5927\u5E08: ${masterCount} \u4E2A` : ""
+      ].filter(Boolean).join("\n") : "\u672C\u5730\u914D\u7F6E\u5DF2\u662F\u6700\u65B0\uFF0C\u65E0\u9700\u66F4\u65B0",
+      data: { updated, crawlerSources: crawlerCount, writingMasters: masterCount }
     };
+  } catch (err) {
+    return { success: false, message: `\u62C9\u53D6\u9519\u8BEF: ${err instanceof Error ? err.message : err}` };
   }
 }
-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/tools/workflow.ts
 import { z as z6 } from "zod";
-import { cp, mkdir as mkdir6, access as access2, readFile as readFile5 } from "fs/promises";
-import { join as join7, dirname as dirname2 } from "path";
+import { cp, mkdir as mkdir6, access as access2, writeFile as writeFile7 } from "fs/promises";
+import { join as join8, dirname } from "path";
 import { fileURLToPath } from "url";
+var DEFAULT_API_BASE_URL = "https://app.claudeink.com";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = dirname2(__filename);
-var WORKFLOW_SRC = join7(__dirname, "..", "workflow");
+var __dirname = dirname(__filename);
+var WORKFLOW_SRC = join8(__dirname, "..", "workflow");
 var workflowInitSchema = z6.object({
   workDir: z6.string().describe("\u5DE5\u4F5C\u6D41\u521D\u59CB\u5316\u76EE\u6807\u76EE\u5F55\uFF08\u7EDD\u5BF9\u8DEF\u5F84\uFF09"),
   licenseKey: z6.string().optional().describe("License Key\uFF08\u53EF\u9009\uFF0C\u4F20\u5165\u5219\u81EA\u52A8\u6FC0\u6D3B\uFF09")
@@ -1146,8 +933,8 @@ async function workflowInit(input) {
   try {
     const items = ["CLAUDE.md", "base-rules.md", "platforms", "accounts", "tools"];
     for (const item of items) {
-      const src = join7(WORKFLOW_SRC, item);
-      const dest = join7(cwd, item);
+      const src = join8(WORKFLOW_SRC, item);
+      const dest = join8(cwd, item);
       try {
         await access2(dest);
         results.push(`\u23ED\uFE0F ${item} \u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7`);
@@ -1166,25 +953,38 @@ async function workflowInit(input) {
       ".claudeink"
     ];
     for (const dir of dirs) {
-      await mkdir6(join7(cwd, dir), { recursive: true });
+      await mkdir6(join8(cwd, dir), { recursive: true });
     }
-    results.push("\u2705 \u8FD0\u884C\u65F6\u76EE\u5F55\u5DF2\u521B\u5EFA\uFF08sources/, templates/, .claudeink/\uFF09");
+    results.push("\u2705 \u8FD0\u884C\u65F6\u76EE\u5F55\u5DF2\u521B\u5EFA");
+    const emptyState = {
+      sources: {},
+      drafts: {},
+      published: {},
+      configs: {},
+      crawlerSources: {},
+      writingMasters: {},
+      lastSyncAt: ""
+    };
+    await replaceState(emptyState);
+    results.push("\u2705 \u672C\u5730\u72B6\u6001\u8868\u5DF2\u521D\u59CB\u5316");
+    let activated = false;
     if (input.licenseKey) {
       try {
-        const res = await fetch("https://app.claudeink.com/api/auth/activate", {
+        const activateUrl = `${DEFAULT_API_BASE_URL}/api/auth/activate`;
+        const res = await fetch(activateUrl, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ key: input.licenseKey })
         });
         const data = await res.json();
         if (data.userId) {
-          const { writeFile: writeFile7 } = await import("fs/promises");
           await writeFile7(
-            join7(cwd, ".claudeink", "credentials.json"),
+            join8(cwd, ".claudeink", "credentials.json"),
             JSON.stringify(data, null, 2),
             { mode: 384 }
           );
-          results.push(`\u2705 License \u6FC0\u6D3B\u6210\u529F\uFF08\u5957\u9910: ${data.plan}\uFF0C\u5230\u671F: ${data.expiresAt}\uFF09`);
+          results.push(`\u2705 License \u6FC0\u6D3B\u6210\u529F\uFF08\u5957\u9910: ${data.plan}\uFF09`);
+          activated = true;
         } else {
           results.push(`\u26A0\uFE0F License \u6FC0\u6D3B\u5931\u8D25: ${JSON.stringify(data)}`);
         }
@@ -1192,6 +992,28 @@ async function workflowInit(input) {
         results.push(`\u26A0\uFE0F \u6FC0\u6D3B\u7F51\u7EDC\u9519\u8BEF: ${err instanceof Error ? err.message : err}`);
       }
     }
+    if (activated) {
+      try {
+        const pullResult = await syncPull({ workDir: cwd });
+        if (pullResult.success && pullResult.data && pullResult.data.updated > 0) {
+          results.push("\u2705 \u5DF2\u4ECE\u4E91\u7AEF\u540C\u6B65\u914D\u7F6E\uFF08\u8DE8\u8BBE\u5907\u6062\u590D\uFF09");
+        } else {
+          results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
+        }
+      } catch {
+        results.push("\u2139\uFE0F \u4E91\u7AEF\u65E0\u5DF2\u6709\u914D\u7F6E\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u6A21\u677F");
+      }
+    }
+    try {
+      await access2(join8(cwd, "tools", "crawler", "package.json"));
+      const { execSync } = await import("child_process");
+      execSync("npm install --silent", {
+        cwd: join8(cwd, "tools", "crawler"),
+        stdio: "pipe"
+      });
+      results.push("\u2705 \u722C\u866B\u4F9D\u8D56\u5DF2\u5B89\u88C5");
+    } catch {
+    }
     return {
       success: true,
       message: [
@@ -1199,14 +1021,6 @@ async function workflowInit(input) {
         "",
         ...results,
         "",
-        "\u{1F4C2} \u5DF2\u91CA\u653E\u6587\u4EF6\uFF1A",
-        "\u251C\u2500\u2500 CLAUDE.md          \uFF08\u7CFB\u7EDF\u7D22\u5F15\uFF0C\u8BF7\u5148\u8BFB\u53D6\uFF09",
-        "\u251C\u2500\u2500 base-rules.md      \uFF08\u901A\u7528\u5199\u4F5C\u5E95\u5EA7\uFF09",
-        "\u251C\u2500\u2500 platforms/          \uFF085 \u4E2A\u5E73\u53F0\u89C4\u5219\uFF09",
-        "\u251C\u2500\u2500 accounts/           \uFF08\u8D26\u53F7\u914D\u7F6E\u6A21\u677F\uFF09",
-        "\u251C\u2500\u2500 sources/            \uFF08\u5171\u4EAB\u7D20\u6750\u5E93\uFF09",
-        "\u2514\u2500\u2500 tools/              \uFF08\u722C\u866B\u7B49\u5DE5\u5177\uFF09",
-        "",
         "\u{1F3AF} \u4E0B\u4E00\u6B65\uFF1A",
         "1. \u8BFB\u53D6 CLAUDE.md \u4E86\u89E3\u4E09\u5C42\u914D\u7F6E\u67B6\u6784",
         "2. \u4F7F\u7528 /\u65B0\u5EFA\u8D26\u53F7 \u521B\u5EFA\u7B2C\u4E00\u4E2A\u81EA\u5A92\u4F53\u8D26\u53F7",
@@ -1220,323 +1034,48 @@ async function workflowInit(input) {
     };
   }
 }
-async function workflowStatus() {
-  const cwd = process.cwd();
-  const checks = [];
-  const requiredFiles = [
-    { path: "CLAUDE.md", label: "\u7CFB\u7EDF\u7D22\u5F15" },
-    { path: "base-rules.md", label: "\u901A\u7528\u5199\u4F5C\u5E95\u5EA7" },
-    { path: "platforms/wechat.md", label: "\u5FAE\u4FE1\u516C\u4F17\u53F7\u89C4\u5219" },
-    { path: "accounts/_template.yaml", label: "\u8D26\u53F7\u6A21\u677F" }
-  ];
-  let allOk = true;
-  for (const file of requiredFiles) {
-    try {
-      await access2(join7(cwd, file.path));
-      checks.push(`\u2705 ${file.label}\uFF08${file.path}\uFF09`);
-    } catch {
-      checks.push(`\u274C ${file.label}\uFF08${file.path}\uFF09\u2014 \u7F3A\u5931`);
-      allOk = false;
-    }
-  }
-  try {
-    const creds = await readFile5(join7(cwd, ".claudeink/credentials.json"), "utf-8");
-    const data = JSON.parse(creds);
-    if (data.userId) {
-      checks.push(`\u2705 License \u5DF2\u6FC0\u6D3B\uFF08\u5957\u9910: ${data.plan}\uFF09`);
-    } else {
-      checks.push("\u26A0\uFE0F \u51ED\u8BC1\u6587\u4EF6\u5B58\u5728\u4F46\u672A\u6FC0\u6D3B");
-    }
-  } catch {
-    checks.push("\u274C \u672A\u627E\u5230\u51ED\u8BC1\u6587\u4EF6\uFF08.claudeink/credentials.json\uFF09");
-    allOk = false;
-  }
-  try {
-    const { glob: glob5 } = await import("glob");
-    const yamlFiles = await glob5("accounts/*.yaml", { cwd, ignore: "accounts/_template.yaml" });
-    if (yamlFiles.length > 0) {
-      checks.push(`\u2705 ${yamlFiles.length} \u4E2A\u8D26\u53F7\u914D\u7F6E`);
-    } else {
-      checks.push("\u2139\uFE0F \u6682\u65E0\u8D26\u53F7\uFF0C\u4F7F\u7528 /\u65B0\u5EFA\u8D26\u53F7 \u521B\u5EFA");
-    }
-  } catch {
-    checks.push("\u2139\uFE0F \u6682\u65E0\u8D26\u53F7");
-  }
-  return {
-    success: true,
-    message: [
-      allOk ? "\u2705 \u5DE5\u4F5C\u6D41\u72B6\u6001\uFF1A\u5C31\u7EEA" : "\u26A0\uFE0F \u5DE5\u4F5C\u6D41\u72B6\u6001\uFF1A\u9700\u8981\u521D\u59CB\u5316",
-      "",
-      ...checks,
-      "",
-      allOk ? "" : "\u8BF7\u8C03\u7528 workflow.init \u5B8C\u6210\u521D\u59CB\u5316\u3002"
-    ].join("\n")
-  };
-}
-
-// src/tools/sync.ts
-import { z as z7 } from "zod";
-import { readFile as readFile6, stat as stat2 } from "fs/promises";
-import { join as join8, basename as basename2, extname as extname2 } from "path";
-import matter3 from "gray-matter";
-import { glob as glob4 } from "glob";
-var syncPushSchema = z7.object({
-  workDir: z7.string().optional().describe("\u5DE5\u4F5C\u76EE\u5F55\uFF08\u9ED8\u8BA4\u4F7F\u7528\u914D\u7F6E\u4E2D\u7684 workflowDir\uFF09")
-});
-async function syncPush(input) {
-  const config = await getConfig();
-  const creds = await getCredentials();
-  if (!creds?.token) {
-    return { success: false, message: "\u672A\u6FC0\u6D3B\uFF0C\u8BF7\u5148\u4F7F\u7528 auth.activate \u6FC0\u6D3B License" };
-  }
-  const workDir = input.workDir || config.workflowDir;
-  if (!workDir) {
-    return { success: false, message: "\u672A\u8BBE\u7F6E\u5DE5\u4F5C\u76EE\u5F55\uFF0C\u8BF7\u5728 config.json \u4E2D\u914D\u7F6E workflowDir" };
-  }
-  const sources = [];
-  const drafts = [];
-  const published = [];
-  try {
-    const sourceFiles = await glob4("sources/**/*.md", { cwd: workDir });
-    for (const file of sourceFiles) {
-      try {
-        const raw = await readFile6(join8(workDir, file), "utf-8");
-        const { data } = matter3(raw);
-        const id = basename2(file, extname2(file));
-        sources.push({
-          id,
-          title: data.title || id,
-          source: data.source || "unknown",
-          tags: Array.isArray(data.tags) ? data.tags : [],
-          sourceUrl: data.url || null,
-          createdAt: data.published || (/* @__PURE__ */ new Date()).toISOString()
-        });
-      } catch {
-      }
-    }
-  } catch {
-  }
-  const accounts = {};
-  try {
-    const yamlFiles = await glob4("accounts/*.yaml", { cwd: workDir, ignore: "accounts/_template.yaml" });
-    for (const file of yamlFiles) {
-      try {
-        const content = await readFile6(join8(workDir, file), "utf-8");
-        const nameMatch = content.match(/^name:\s*"?([^"\n]+)"?/m);
-        const idMatch = content.match(/^id:\s*"?([^"\n]+)"?/m);
-        const platformMatch = content.match(/^platform:\s*"?([^"\n]+)"?/m);
-        const draftsMatch = content.match(/drafts:\s*"?([^"\n]+)"?/m);
-        const publishedMatch = content.match(/published:\s*"?([^"\n]+)"?/m);
-        if (idMatch && nameMatch) {
-          const id = idMatch[1].trim();
-          const name = nameMatch[1].trim();
-          const platform = platformMatch?.[1]?.trim() || "unknown";
-          const dp = (draftsMatch?.[1] || `accounts/${id}/drafts/`).replace("{id}", id).trim();
-          const pp = (publishedMatch?.[1] || `accounts/${id}/published/`).replace("{id}", id).trim();
-          accounts[id] = { name, platform, draftsPath: dp, publishedPath: pp };
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  for (const [accId, acc] of Object.entries(accounts)) {
-    try {
-      const draftFiles = await glob4("**/*.md", { cwd: join8(workDir, acc.draftsPath) });
-      for (const file of draftFiles) {
-        try {
-          const fullPath = join8(workDir, acc.draftsPath, file);
-          const raw = await readFile6(fullPath, "utf-8");
-          const { data, content } = matter3(raw);
-          const fileStat = await stat2(fullPath);
-          const id = basename2(file, extname2(file));
-          drafts.push({
-            id,
-            account: acc.name,
-            platform: acc.platform,
-            title: data.title || id,
-            status: data.status || "draft",
-            wordCount: content.trim().length,
-            tags: Array.isArray(data.tags) ? data.tags : [],
-            createdAt: data.created || fileStat.birthtime.toISOString(),
-            updatedAt: fileStat.mtime.toISOString()
-          });
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  for (const [accId, acc] of Object.entries(accounts)) {
-    try {
-      const pubFiles = await glob4("**/*.md", { cwd: join8(workDir, acc.publishedPath) });
-      for (const file of pubFiles) {
-        try {
-          const raw = await readFile6(join8(workDir, acc.publishedPath, file), "utf-8");
-          const { data } = matter3(raw);
-          const id = basename2(file, extname2(file));
-          published.push({
-            id,
-            account: acc.name,
-            platform: acc.platform,
-            title: data.title || id,
-            platformUrl: data.url || data.platform_url || null,
-            publishedAt: data.published_at || data.publishedAt || (/* @__PURE__ */ new Date()).toISOString()
-          });
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  const configs = [];
-  try {
-    const baseRules = await readFile6(join8(workDir, "base-rules.md"), "utf-8");
-    configs.push({ type: "base_rules", name: "base", displayName: "\u901A\u7528\u5E95\u5EA7", content: baseRules });
-  } catch {
-  }
-  try {
-    const platformFiles = await glob4("platforms/*.md", { cwd: workDir });
-    for (const file of platformFiles) {
-      const content = await readFile6(join8(workDir, file), "utf-8");
-      const name = basename2(file, ".md");
-      const displayNames = {
-        wechat: "\u5FAE\u4FE1\u516C\u4F17\u53F7",
-        xiaohongshu: "\u5C0F\u7EA2\u4E66",
-        "x-twitter": "X (Twitter)",
-        toutiao: "\u5934\u6761\u53F7",
-        blog: "\u4E2A\u4EBA\u535A\u5BA2"
-      };
-      configs.push({ type: "platform", name, displayName: displayNames[name] || name, content });
-    }
-  } catch {
-  }
-  for (const [accId, acc] of Object.entries(accounts)) {
-    try {
-      const content = await readFile6(join8(workDir, `accounts/${accId}.yaml`), "utf-8");
-      configs.push({
-        type: "account",
-        name: accId,
-        displayName: acc.name,
-        content,
-        metadata: { platform: acc.platform }
-      });
-    } catch {
-    }
-  }
-  const payload = { sources, drafts, published, analytics: [], configs };
-  try {
-    const res = await fetch(`${config.apiBaseUrl}/api/sync/batch`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${creds.token}`
-      },
-      body: JSON.stringify(payload)
-    });
-    const result = await res.json();
-    if (res.ok) {
-      return {
-        success: true,
-        message: [
-          `\u2705 \u540C\u6B65\u5B8C\u6210`,
-          `   \u7D20\u6750: ${sources.length} \u7BC7`,
-          `   \u8349\u7A3F: ${drafts.length} \u7BC7`,
-          `   \u5DF2\u53D1\u5E03: ${published.length} \u7BC7`,
-          `   \u914D\u7F6E: ${configs.length} \u4E2A\uFF08\u901A\u7528\u5E95\u5EA7 + \u5E73\u53F0\u89C4\u5219 + \u8D26\u53F7\u914D\u7F6E\uFF09`,
-          `   \u4E91\u7AEF\u63A5\u53D7: ${result.accepted || 0} \u6761`
-        ].join("\n"),
-        data: {
-          sources: sources.length,
-          drafts: drafts.length,
-          published: published.length,
-          configs: configs.length,
-          accepted: result.accepted || 0
-        }
-      };
-    } else {
-      return {
-        success: false,
-        message: `\u540C\u6B65\u5931\u8D25: HTTP ${res.status} \u2014 ${JSON.stringify(result)}`
-      };
-    }
-  } catch (err) {
-    return {
-      success: false,
-      message: `\u540C\u6B65\u7F51\u7EDC\u9519\u8BEF: ${err instanceof Error ? err.message : err}`
-    };
-  }
-}
 
 // src/index.ts
 var server = new McpServer({
   name: "ClaudeInk",
-  version: "0.1.0"
+  version: "0.6.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();
+server.tool("workflow.init", "\u521D\u59CB\u5316\u5199\u4F5C\u5DE5\u4F5C\u6D41\uFF08\u91CA\u653E\u4E09\u5C42\u914D\u7F6E + \u6FC0\u6D3B License + \u81EA\u52A8\u540C\u6B65\u4E91\u7AEF\u914D\u7F6E\uFF09", workflowInitSchema.shape, async (input) => {
+  const result = await workflowInit(input);
   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();
+server.tool("sync.push", "\u5C06\u672C\u5730\u6570\u636E\u540C\u6B65\u5230 ClaudeInk \u4E91\u7AEF\uFF08\u8BFB\u53D6\u672C\u5730\u72B6\u6001\u8868\u76F4\u63A5\u63A8\u9001\uFF09", syncPushSchema.shape, async (input) => {
+  const result = await syncPush(input);
   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();
+server.tool("sync.pull", "\u4ECE\u4E91\u7AEF\u62C9\u53D6\u914D\u7F6E\u5230\u672C\u5730\uFF08\u65F6\u95F4\u6233\u6BD4\u8F83\uFF0C\u65B0\u7684\u8986\u76D6\u65E7\u7684\uFF09", syncPullSchema.shape, async (input) => {
+  const result = await syncPull(input);
   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) => {
+server.tool("source.tag", "\u83B7\u53D6\u5F85\u6807\u7B7E\u7D20\u6750\u5185\u5BB9\u4F9B AI \u5206\u6790", 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();
+server.tool("source.tag_apply", "\u5199\u5165 AI \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("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);
+server.tool("source.subscribe", "\u7BA1\u7406\u8BA2\u9605\u6E90\uFF08\u6DFB\u52A0/\u5220\u9664/\u5217\u51FA\u722C\u866B\u6E90\uFF09", sourceSubscribeSchema.shape, async (input) => {
+  const result = await sourceSubscribe(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) }] };
@@ -1549,34 +1088,10 @@ server.tool("analytics.report", "\u83B7\u53D6\u6570\u636E\u5206\u6790\u62A5\u544
   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) }] };
-});
-server.tool("sync.push", "\u5C06\u672C\u5730\u7D20\u6750\u3001\u8349\u7A3F\u3001\u5DF2\u53D1\u5E03\u6587\u7AE0\u7684\u5143\u6570\u636E\u540C\u6B65\u5230 ClaudeInk \u4E91\u7AEF\u63A7\u5236\u53F0", syncPushSchema.shape, async (input) => {
-  const result = await syncPush(input);
-  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-});
-server.tool("workflow.init", "\u521D\u59CB\u5316\u5199\u4F5C\u5DE5\u4F5C\u6D41\uFF08\u91CA\u653E\u4E09\u5C42\u914D\u7F6E + \u5E73\u53F0\u89C4\u5219 + \u8D26\u53F7\u6A21\u677F + \u722C\u866B\u5DE5\u5177\u5230\u5DE5\u4F5C\u76EE\u5F55\uFF09", workflowInitSchema.shape, async (input) => {
-  const result = await workflowInit(input);
-  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
-});
-server.tool("workflow.status", "\u68C0\u67E5\u5199\u4F5C\u5DE5\u4F5C\u6D41\u72B6\u6001\uFF08\u914D\u7F6E\u6587\u4EF6\u3001\u51ED\u8BC1\u3001\u8D26\u53F7\u662F\u5426\u5C31\u7EEA\uFF09", {}, async () => {
-  const result = await workflowStatus();
-  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");
+  console.error("[ClaudeInk MCP] Server started on stdio (12 tools)");
 }
 main().catch((err) => {
   console.error("[ClaudeInk MCP] Fatal error:", err);