@claudelaw/taichu 0.6.0

package/packages/server/src/routes/wechat.js

@@ -0,0 +1,115 @@
+/**
+ * WeChat MCP Tool Routes — 微信生态桥接
+ *
+ * 通过 MCP Tool 暴露微信 API，Agent 可操作公众号/小程序内容。
+ * 实际对接微信开放平台 API，需要用户自行申请 AppID/AppSecret。
+ *
+ * 环境变量：
+ *   TAICHU_WECHAT_APPID     — 微信公众号 AppID
+ *   TAICHU_WECHAT_SECRET    — 公众号 AppSecret
+ *   TAICHU_WECHAT_TOKEN     — 服务器配置 Token（消息推送验证）
+ */
+
+import { requireAuth } from '../middleware/auth.js';
+import { createLogger } from '../logger.js';
+
+const log = createLogger('wechat');
+
+let _accessToken = null;
+let _tokenExpiry = 0;
+
+async function getAccessToken() {
+  if (_accessToken && Date.now() < _tokenExpiry) return _accessToken;
+
+  const appId = process.env.TAICHU_WECHAT_APPID;
+  const secret = process.env.TAICHU_WECHAT_SECRET;
+  if (!appId || !secret) throw new Error('WeChat not configured (TAICHU_WECHAT_APPID/SECRET)');
+
+  const res = await fetch(`https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${appId}&secret=${secret}`);
+  const data = await res.json();
+  if (data.errcode) throw new Error(`WeChat token error: ${data.errmsg}`);
+
+  _accessToken = data.access_token;
+  _tokenExpiry = Date.now() + (data.expires_in - 300) * 1000;
+  return _accessToken;
+}
+
+/**
+ * Push article draft to WeChat Official Account.
+ */
+async function pushToDraft(title, content, thumbMediaId = '') {
+  const token = await getAccessToken();
+  const res = await fetch(`https://api.weixin.qq.com/cgi-bin/draft/add?access_token=${token}`, {
+    method: 'POST',
+    body: JSON.stringify({
+      articles: [{
+        title,
+        content,
+        thumb_media_id: thumbMediaId,
+        need_open_comment: 0,
+        show_cover_pic: 0
+      }]
+    })
+  });
+  return res.json();
+}
+
+/**
+ * Get WeChat user list (followers).
+ */
+async function getUserList() {
+  const token = await getAccessToken();
+  const res = await fetch(`https://api.weixin.qq.com/cgi-bin/user/get?access_token=${token}`);
+  return res.json();
+}
+
+export async function wechatRoutes(ctx) {
+  const { pathname } = ctx.url;
+  const method = ctx.req.method;
+
+  const authResult = await requireAuth(ctx);
+  if (!authResult.authenticated) {
+    ctx.res.writeHead(authResult.status, { 'Content-Type': 'application/json' });
+    ctx.res.end(JSON.stringify({ error: authResult.error, message: authResult.message }));
+    return;
+  }
+
+  try {
+    // GET /api/wechat/status
+    if (pathname === '/api/wechat/status' && method === 'GET') {
+      const configured = !!(process.env.TAICHU_WECHAT_APPID && process.env.TAICHU_WECHAT_SECRET);
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify({ configured, appId: process.env.TAICHU_WECHAT_APPID?.substring(0, 8) + '...' || '' }));
+      return;
+    }
+
+    // POST /api/wechat/push — sync article to WeChat draft
+    if (pathname === '/api/wechat/push' && method === 'POST') {
+      const { title, content, thumbMediaId } = ctx.body || {};
+      if (!title || !content) {
+        ctx.res.writeHead(400, { 'Content-Type': 'application/json' });
+        ctx.res.end(JSON.stringify({ error: 'title and content required' }));
+        return;
+      }
+      const result = await pushToDraft(title, content, thumbMediaId);
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify(result));
+      return;
+    }
+
+    // GET /api/wechat/followers
+    if (pathname === '/api/wechat/followers' && method === 'GET') {
+      const result = await getUserList();
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify(result));
+      return;
+    }
+  } catch (err) {
+    ctx.res.writeHead(500, { 'Content-Type': 'application/json' });
+    ctx.res.end(JSON.stringify({ error: err.message }));
+    return;
+  }
+
+  ctx.res.writeHead(404, { 'Content-Type': 'application/json' });
+  ctx.res.end(JSON.stringify({ error: 'NOT_FOUND' }));
+}

package/packages/server/src/routes/workflow.js

@@ -0,0 +1,157 @@
+/**
+ * Workflow Engine — 内容审核工作流
+ *
+ * 状态机驱动的审核流程。
+ * 内置流程：draft → review → approved → published
+ * 自定义流程通过 WorkflowTemplate 内容类型定义。
+ *
+ * API:
+ *   POST /api/workflow/request — 提交审核
+ *   POST /api/workflow/approve/:id — 通过审核
+ *   POST /api/workflow/reject/:id — 驳回
+ *   GET  /api/workflow/status/:id — 查看状态
+ */
+
+import { getStore } from '../context.js';
+import { requireAuth } from '../middleware/auth.js';
+import { record as auditRecord } from '../audit.js';
+import { notify } from '../notify.js';
+import { createLogger } from '../logger.js';
+
+const log = createLogger('workflow');
+
+const DEFAULT_STATES = ['draft', 'scheduled', 'pending_review', 'approved', 'published', 'rejected', 'archived'];
+const VALID_TRANSITIONS = {
+  'draft':          ['scheduled', 'pending_review', 'published', 'archived'],
+  'scheduled':      ['draft', 'published'],
+  'pending_review': ['approved', 'rejected'],
+  'approved':       ['published', 'rejected'],
+  'published':      ['archived'],
+  'rejected':       ['draft', 'pending_review'],
+  'archived':       ['draft']
+};
+
+/**
+ * Request a review.
+ */
+export async function requestReview(docId, ctx) {
+  const store = getStore();
+  const doc = await store.get(docId);
+  if (!doc) throw { status: 404, message: 'Document not found' };
+
+  const current = doc.data?.workflowState || doc.status;
+  if (!VALID_TRANSITIONS[current]?.includes('pending_review')) {
+    throw { status: 400, message: `Cannot review from "${current}" state` };
+  }
+
+  await store.update(docId, { data: { ...doc.data, workflowState: 'pending_review', reviewRequestedBy: ctx.actor?.id, reviewRequestedAt: new Date().toISOString() } });
+  auditRecord({ actorId: ctx.actor?.id, actorType: ctx.actor?.type || 'human', action: 'review_requested', resourceType: doc.type, resourceId: doc.id }).catch(() => {});
+  notify('review_requested', { doc, actor: ctx.actor?.username || 'User' }).catch(() => {});
+
+  return { success: true, state: 'pending_review' };
+}
+
+/**
+ * Approve a review.
+ */
+export async function approve(docId, ctx, comment = '') {
+  const store = getStore();
+  const doc = await store.get(docId);
+  if (!doc) throw { status: 404, message: 'Document not found' };
+
+  const current = doc.data?.workflowState || doc.status;
+  if (current !== 'pending_review' && current !== 'approved') {
+    throw { status: 400, message: `Cannot approve from "${current}" state` };
+  }
+
+  const newState = 'approved';
+  await store.update(docId, {
+    data: { ...doc.data, workflowState: newState, reviewApprovedBy: ctx.actor?.id, reviewApprovedAt: new Date().toISOString(), reviewComment: comment },
+    status: 'published'
+  });
+  auditRecord({ actorId: ctx.actor?.id, actorType: ctx.actor?.type || 'human', action: 'approved', resourceType: doc.type, resourceId: doc.id }).catch(() => {});
+  notify('content_published', { doc, actor: ctx.actor?.username || 'User' }).catch(() => {});
+
+  return { success: true, state: newState };
+}
+
+/**
+ * Reject a review.
+ */
+export async function reject(docId, ctx, reason = '') {
+  const store = getStore();
+  const doc = await store.get(docId);
+  if (!doc) throw { status: 404, message: 'Document not found' };
+
+  await store.update(docId, { data: { ...doc.data, workflowState: 'rejected', reviewRejectedBy: ctx.actor?.id, reviewRejectedAt: new Date().toISOString(), reviewRejectReason: reason } });
+  auditRecord({ actorId: ctx.actor?.id, actorType: ctx.actor?.type || 'human', action: 'rejected', resourceType: doc.type, resourceId: doc.id }).catch(() => {});
+
+  return { success: true, state: 'rejected' };
+}
+
+// ── Routes ─────────────────────────────────────────────────
+
+export async function workflowRoutes(ctx) {
+  const { pathname } = ctx.url;
+  const method = ctx.req.method;
+
+  const authResult = await requireAuth(ctx);
+  if (!authResult.authenticated) {
+    ctx.res.writeHead(authResult.status, { 'Content-Type': 'application/json' });
+    ctx.res.end(JSON.stringify({ error: authResult.error, message: authResult.message }));
+    return;
+  }
+  ctx.actor = authResult.actor;
+
+  try {
+    // POST /api/workflow/request/:docId
+    const reqMatch = pathname.match(/^\/api\/workflow\/request\/([\w-]+)$/);
+    if (reqMatch && method === 'POST') {
+      const result = await requestReview(reqMatch[1], ctx);
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify(result));
+      return;
+    }
+
+    // POST /api/workflow/approve/:docId
+    const approveMatch = pathname.match(/^\/api\/workflow\/approve\/([\w-]+)$/);
+    if (approveMatch && method === 'POST') {
+      const result = await approve(approveMatch[1], ctx, (ctx.body || {}).comment || '');
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify(result));
+      return;
+    }
+
+    // POST /api/workflow/reject/:docId
+    const rejectMatch = pathname.match(/^\/api\/workflow\/reject\/([\w-]+)$/);
+    if (rejectMatch && method === 'POST') {
+      const result = await reject(rejectMatch[1], ctx, (ctx.body || {}).reason || '');
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify(result));
+      return;
+    }
+
+    // GET /api/workflow/status/:docId
+    const statusMatch = pathname.match(/^\/api\/workflow\/status\/([\w-]+)$/);
+    if (statusMatch && method === 'GET') {
+      const store = getStore();
+      const doc = await store.get(statusMatch[1]);
+      if (!doc) { ctx.res.writeHead(404, { 'Content-Type': 'application/json' }); ctx.res.end(JSON.stringify({ error: 'NOT_FOUND' })); return; }
+      ctx.res.writeHead(200, { 'Content-Type': 'application/json' });
+      ctx.res.end(JSON.stringify({
+        state: doc.data?.workflowState || doc.status,
+        transitions: VALID_TRANSITIONS[doc.data?.workflowState || doc.status] || [],
+        reviewRequestedBy: doc.data?.reviewRequestedBy,
+        reviewRequestedAt: doc.data?.reviewRequestedAt
+      }));
+      return;
+    }
+  } catch (err) {
+    ctx.res.writeHead(err.status || 500, { 'Content-Type': 'application/json' });
+    ctx.res.end(JSON.stringify({ error: err.message || 'Internal error' }));
+    return;
+  }
+
+  ctx.res.writeHead(404, { 'Content-Type': 'application/json' });
+  ctx.res.end(JSON.stringify({ error: 'NOT_FOUND' }));
+}

package/packages/server/src/scheduler.js

@@ -0,0 +1,96 @@
+/**
+ * Scheduler — 定时发布调度器
+ *
+ * 轮询数据库中 status='scheduled' 且 published_at <= now 的文档，
+ * 自动将状态更新为 'published'。
+ *
+ * 配置：
+ *   TAICHU_SCHEDULE_INTERVAL_MS  — 轮询间隔，默认 30000 (30s)
+ *   TAICHU_SCHEDULE_BATCH_SIZE   — 单次最多处理条数，默认 50
+ */
+
+import { getStore } from './context.js';
+import { createLogger } from './logger.js';
+import { notify } from './notify.js';
+
+const log = createLogger('scheduler');
+
+let timer = null;
+
+/**
+ * Start the scheduled publishing loop.
+ * @param {object} [hooks] — hook system instance for firing afterUpdate
+ */
+export function startScheduler(hooks) {
+  const interval = parseInt(process.env.TAICHU_SCHEDULE_INTERVAL_MS) || 30000;
+  const batchSize = parseInt(process.env.TAICHU_SCHEDULE_BATCH_SIZE) || 50;
+
+  log.info(`Scheduler started — interval: ${interval}ms, batch: ${batchSize}`);
+
+  // Run immediately on start
+  tick(hooks, batchSize);
+
+  timer = setInterval(() => tick(hooks, batchSize), interval);
+
+  // Don't prevent process exit
+  if (timer.unref) timer.unref();
+}
+
+/**
+ * Stop the scheduler (for graceful shutdown).
+ */
+export function stopScheduler() {
+  if (timer) {
+    clearInterval(timer);
+    timer = null;
+    log.info('Scheduler stopped');
+  }
+}
+
+/**
+ * Single tick — find and publish due documents.
+ */
+async function tick(hooks, batchSize) {
+  try {
+    const store = getStore();
+    if (!store) return;
+
+    // Query documents with status='scheduled'
+    const scheduled = await store.list({ status: 'scheduled', limit: batchSize });
+    if (!scheduled.length) return;
+
+    const now = new Date();
+    const due = scheduled.filter(doc => {
+      const pubAt = doc.publishedAt || doc.data?.publishedAt;
+      if (!pubAt) return false; // no publish time set — skip
+      return new Date(pubAt) <= now;
+    });
+
+    if (!due.length) return;
+
+    log.info(`Publishing ${due.length} scheduled document(s)`);
+
+    for (const doc of due) {
+      try {
+        const updated = await store.update(doc.id, {
+          status: 'published',
+          publishedAt: doc.publishedAt || doc.data?.publishedAt || new Date().toISOString(),
+          data: { ...doc.data, publishedAt: doc.publishedAt || doc.data?.publishedAt || new Date().toISOString() }
+        });
+
+        // Fire afterUpdate hook (same as normal publish flow)
+        if (hooks && updated) {
+          await hooks.run('afterUpdate', updated, { actor: { id: 'scheduler', type: 'system' } }).catch(() => {});
+        }
+
+        notify('content_published', { doc: updated, actor: 'scheduler' }).catch(() => {});
+
+        log.info(`Published: ${doc.id} (${doc.type})`);
+      } catch (err) {
+        log.error(`Failed to publish ${doc.id}: ${err.message}`);
+      }
+    }
+  } catch (err) {
+    log.error(`Scheduler tick error: ${err.message}`);
+  }
+}

package/packages/server/src/search.js

@@ -0,0 +1,100 @@
+/**
+ * Search Service — 向量检索集成
+ *
+ * 在 Taichu 启动时初始化 TF-IDF 索引，自动索引已有内容，
+ * 并 hook 到内容生命周期保持索引同步。
+ */
+
+import { TFIDFIndex } from '../../core/src/vector-index.js';
+import { tryLoadJieba, setTokenizer } from '../../core/src/tokenizer.js';
+
+let index = null;
+
+/**
+ * Initialize the search index.
+ * @param {import('../context.js').Store} store
+ * @param {import('../context.js').HookSystem} hooks
+ */
+export async function initSearch(store, hooks) {
+  index = new TFIDFIndex();
+
+  // Try to load jieba for Chinese tokenization (optional)
+  const jieba = await tryLoadJieba();
+  if (jieba) {
+    setTokenizer(jieba);
+    console.log('  Search: jieba Chinese tokenizer loaded');
+  } else {
+    console.log('  Search: using n-gram tokenizer (install nodejieba for better Chinese search)');
+  }
+
+  // Index all existing documents
+  const allTypes = ['article', 'page', 'category', 'media', 'author'];
+  for (const type of allTypes) {
+    try {
+      const docs = await store.list({ type, limit: 1000 });
+      for (const doc of docs) {
+        indexDoc(doc);
+      }
+    } catch (e) {
+      // Skip types that don't exist yet
+    }
+  }
+
+  console.log(`  Search: indexed ${index.size} documents`);
+
+  // Hook: index new content
+  hooks.on('afterCreate', (doc) => {
+    indexDoc(doc);
+  });
+
+  // Hook: re-index updated content
+  hooks.on('afterUpdate', (doc) => {
+    index.remove(doc.id);
+    indexDoc(doc);
+  });
+
+  // Hook: remove deleted content
+  hooks.on('afterDelete', ({ id }) => {
+    index.remove(id);
+  });
+}
+
+function indexDoc(doc) {
+  if (!doc || !doc.data) return;
+
+  // Build searchable text from document data
+  const parts = [];
+  for (const [key, value] of Object.entries(doc.data)) {
+    if (typeof value === 'string') {
+      parts.push(value);
+    } else if (typeof value === 'object' && value !== null) {
+      // Flatten objects one level deep
+      for (const v of Object.values(value)) {
+        if (typeof v === 'string') parts.push(v);
+      }
+    }
+  }
+
+  const text = parts.join(' ');
+  if (text.trim()) {
+    index.add(doc.id, text);
+  }
+}
+
+/**
+ * Search for documents matching a query.
+ * @param {string} query
+ * @param {number} [topK=10]
+ * @returns {Array<{ docId: string, score: number }>}
+ */
+export function search(query, topK = 10) {
+  if (!index) return [];
+  return index.search(query, topK);
+}
+
+/**
+ * Get the search index for direct access.
+ */
+export function getIndex() {
+  return index;
+}