@ian2018cs/agenthub 0.1.82 → 0.1.83

package/server/database/db.js

@@ -331,6 +331,28 @@ const runMigrations = () => {
       db.exec('ALTER TABLE agent_submissions ADD COLUMN update_notes TEXT');
     } catch (_) { /* 列已存在 */ }
 
+    // 定时任务表（Cron 工具服务端接管）
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS cron_tasks (
+        id             TEXT PRIMARY KEY,
+        cron_expr      TEXT NOT NULL,
+        prompt         TEXT NOT NULL,
+        recurring      INTEGER NOT NULL DEFAULT 1,
+        user_uuid      TEXT NOT NULL,
+        session_id     TEXT,
+        project_path   TEXT,
+        session_mode   TEXT NOT NULL DEFAULT 'new_session',
+        channel        TEXT NOT NULL DEFAULT '',
+        feishu_open_id TEXT,
+        chat_id        TEXT,
+        webhook_url    TEXT,
+        created_at     INTEGER NOT NULL,
+        last_fired_at  INTEGER,
+        is_paused      INTEGER NOT NULL DEFAULT 0
+      )
+    `);
+    db.exec('CREATE INDEX IF NOT EXISTS idx_cron_tasks_user ON cron_tasks(user_uuid)');
+
     // 聊天图片持久化关联表
     db.exec(`
       CREATE TABLE IF NOT EXISTS message_images (
@@ -1476,6 +1498,80 @@ const agentSubmissionDb = {
   }
 };
 
+// Cron tasks database operations
+const cronDb = {
+  insert: (task) => {
+    db.prepare(`
+      INSERT INTO cron_tasks (id, cron_expr, prompt, recurring, user_uuid, session_id,
+        project_path, session_mode, channel, feishu_open_id, chat_id, webhook_url, created_at, last_fired_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      task.id, task.cronExpr, task.prompt, task.recurring ? 1 : 0,
+      task.userUuid, task.sessionId || null, task.projectPath || null,
+      task.sessionMode || 'new_session', task.channel ?? '',
+      task.feishuOpenId || null, task.chatId || null, task.webhookUrl || null,
+      task.createdAt, task.lastFiredAt || null
+    );
+  },
+
+  delete: (id, userUuid) => {
+    const result = db.prepare('DELETE FROM cron_tasks WHERE id = ? AND user_uuid = ?').run(id, userUuid);
+    return result.changes > 0;
+  },
+
+  listByUser: (userUuid) => {
+    return db.prepare('SELECT * FROM cron_tasks WHERE user_uuid = ? ORDER BY created_at ASC').all(userUuid)
+      .map(row => ({
+        id: row.id, cronExpr: row.cron_expr, prompt: row.prompt,
+        recurring: row.recurring === 1, userUuid: row.user_uuid,
+        sessionId: row.session_id, projectPath: row.project_path,
+        sessionMode: row.session_mode, channel: row.channel,
+        feishuOpenId: row.feishu_open_id, chatId: row.chat_id,
+        webhookUrl: row.webhook_url, createdAt: row.created_at, lastFiredAt: row.last_fired_at,
+        isPaused: row.is_paused === 1,
+      }));
+  },
+
+  getAll: () => {
+    return db.prepare('SELECT * FROM cron_tasks ORDER BY created_at ASC').all()
+      .map(row => ({
+        id: row.id, cronExpr: row.cron_expr, prompt: row.prompt,
+        recurring: row.recurring === 1, userUuid: row.user_uuid,
+        sessionId: row.session_id, projectPath: row.project_path,
+        sessionMode: row.session_mode, channel: row.channel,
+        feishuOpenId: row.feishu_open_id, chatId: row.chat_id,
+        webhookUrl: row.webhook_url, createdAt: row.created_at, lastFiredAt: row.last_fired_at,
+        isPaused: row.is_paused === 1,
+      }));
+  },
+
+  updateLastFired: (id, ts) => {
+    db.prepare('UPDATE cron_tasks SET last_fired_at = ? WHERE id = ?').run(ts, id);
+  },
+
+  setPaused: (id, userUuid, isPaused) => {
+    const result = db.prepare('UPDATE cron_tasks SET is_paused = ? WHERE id = ? AND user_uuid = ?')
+      .run(isPaused ? 1 : 0, id, userUuid);
+    return result.changes > 0;
+  },
+
+  update: (id, userUuid, patch) => {
+    const result = db.prepare(`
+      UPDATE cron_tasks
+      SET cron_expr = ?, prompt = ?, recurring = ?, channel = ?,
+          webhook_url = ?, feishu_open_id = ?, chat_id = ?, project_path = ?
+      WHERE id = ? AND user_uuid = ?
+    `).run(
+      patch.cronExpr, patch.prompt, patch.recurring ? 1 : 0,
+      patch.channel ?? '', patch.webhookUrl || null,
+      patch.feishuOpenId || null, patch.chatId || null,
+      patch.projectPath || null,
+      id, userUuid
+    );
+    return result.changes > 0;
+  },
+};
+
 export {
   db,
   initializeDatabase,
@@ -1486,5 +1582,6 @@ export {
   settingsDb,
   feishuDb,
   imageDb,
-  agentSubmissionDb
+  agentSubmissionDb,
+  cronDb
 };

package/server/index.js

@@ -71,6 +71,7 @@ import builtinTools, {
     dequeueResult,
     hasResults,
     getAllPendingForUser,
+    cronScheduler,
 } from './services/builtin-tools/index.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
@@ -83,12 +84,15 @@ import skillsRoutes from './routes/skills.js';
 import mcpReposRoutes from './routes/mcp-repos.js';
 import settingsRoutes from './routes/settings.js';
 import agentsRoutes from './routes/agents.js';
-import { initializeDatabase, userDb, imageDb } from './database/db.js';
+import cronRoutes from './routes/cron.js';
+import { initializeDatabase, userDb, imageDb, feishuDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { getUserPaths, initCodexDirectories, initGeminiDirectories } from './services/user-directories.js';
 import { startUsageScanner } from './services/usage-scanner.js';
-import { startFeishuService, stopFeishuService } from './services/feishu/index.js';
+import { startFeishuService, getLarkClient } from './services/feishu/index.js';
 import { saveImage, getImagePath } from './services/image-storage.js';
+import { WebhookWriter } from './services/builtin-tools/WebhookWriter.js';
+import { SessionWriter } from './services/builtin-tools/SessionWriter.js';
 import { startImageCleanup } from './services/image-cleanup.js';
 
 // File system watcher for projects folder - per user
@@ -171,6 +175,102 @@ backgroundTaskPool.on('task-complete', (task) => {
     tryDeliverBgResult(task.userUuid, task.sessionId);
 });
 
+cronScheduler.on('cron-fire', async (task) => {
+    const { id, sessionMode, channel, userUuid, sessionId, projectPath, prompt, cronExpr } = task;
+    console.log(`[CronFire] task=${id} channel=${channel || 'none'} sessionMode=${sessionMode || 'new_session'}`);
+
+    // session_mode 决定传不传 sessionId
+    const execSessionId = sessionMode === 'resume_session' ? (sessionId || undefined) : undefined;
+
+    // resume_session 冲突检测：若目标 session 正在被用户使用
+    if (execSessionId && isClaudeSDKSessionActive(execSessionId)) {
+        if (!task.recurring) {
+            // 单次任务：原任务由 #onFire 自动删除，用 setTimeout(0) 确保 delete 先执行后再创建重试任务
+            const retryDate = new Date(Date.now() + 60_000);
+            const retryCron = `${retryDate.getMinutes()} ${retryDate.getHours()} ${retryDate.getDate()} ${retryDate.getMonth() + 1} *`;
+            const retryId = Date.now().toString(36).slice(-8);
+            setTimeout(() => {
+                try {
+                    cronScheduler.create({
+                        id: retryId,
+                        cronExpr: retryCron,
+                        prompt: task.prompt,
+                        recurring: false,
+                        userUuid: task.userUuid,
+                        sessionId: task.sessionId,
+                        projectPath: task.projectPath,
+                        sessionMode: task.sessionMode,
+                        channel: task.channel,
+                        feishuOpenId: task.feishuOpenId,
+                        chatId: task.chatId,
+                        webhookUrl: task.webhookUrl,
+                    });
+                    console.log(`[CronFire] Session busy, rescheduled one-shot task ${id} → ${retryId} (retry at ${retryCron})`);
+                } catch (err) {
+                    console.error(`[CronFire] Failed to reschedule one-shot task ${id}:`, err.message);
+                }
+            }, 0);
+        } else {
+            console.log(`[CronFire] Session ${execSessionId} busy, skipping recurring task ${id} (retry at next occurrence)`);
+        }
+        return;
+    }
+
+    switch (channel) {
+        case 'feishu': {
+            // 通过 userUuid 从绑定表实时查 feishu_open_id，不依赖 task 中的缓存值
+            const feishuOpenId = feishuDb.getBindingByUserUuid(userUuid)?.feishu_open_id;
+            if (!feishuOpenId) {
+                console.warn(`[CronFire] No feishu binding for user ${userUuid}, skipping task ${id}`);
+                break;
+            }
+            const state = feishuDb.getSessionState(feishuOpenId) || {};
+            const { FeishuWriter } = await import('./services/builtin-tools/FeishuWriter.js');
+            const writer = new FeishuWriter({
+                feishuOpenId,
+                chatId: state.chat_id || null,
+                larkClient: getLarkClient(),
+                cronId: id,
+            });
+            queryClaudeSDK(`[定时任务 ID: ${id}]\n\n${prompt}`, {
+                userUuid,
+                cwd: task.projectPath || state.cwd,
+                sessionId: execSessionId,
+                permissionMode: 'bypassPermissions',
+            }, writer).catch(err => console.error(`[CronFire] Feishu error for task ${id}:`, err.message));
+            break;
+        }
+        case 'webhook': {
+            const writer = new WebhookWriter({
+                webhookUrl: task.webhookUrl,
+                cronId: id,
+                cronExpr,
+                prompt,
+                userUuid,
+                cwd: projectPath,
+            });
+            queryClaudeSDK(prompt, {
+                userUuid,
+                cwd: projectPath,
+                sessionId: execSessionId,
+                permissionMode: 'bypassPermissions',
+            }, writer).catch(err => console.error(`[CronFire] Webhook error for task ${id}:`, err.message));
+            break;
+        }
+        default: {
+            // channel='' — 服务端执行，结果存入会话历史，不做外部投递
+            const writer = new SessionWriter({ cronId: id });
+            queryClaudeSDK(prompt, {
+                userUuid,
+                cwd: projectPath,
+                sessionId: execSessionId,
+                permissionMode: 'bypassPermissions',
+            }, writer).catch(err => console.error(`[CronFire] Session error for task ${id}:`, err.message));
+            break;
+        }
+    }
+});
+
 // Setup file system watcher for a specific user's Claude projects folder
 async function setupUserProjectsWatcher(userUuid, ws) {
     if (!userUuid) {
@@ -427,6 +527,9 @@ app.use('/api/settings', authenticateToken, settingsRoutes);
 // Agents API Routes (protected)
 app.use('/api/agents', authenticateToken, agentsRoutes);
 
+// Cron Tasks API Routes (protected)
+app.use('/api/cron-tasks', authenticateToken, cronRoutes);
+
 // Static files served after API routes
 // Add cache control: HTML files should not be cached, but assets can be cached
 app.use(express.static(path.join(__dirname, '../dist'), {
@@ -2598,6 +2701,9 @@ async function startServer() {
             // Start image cleanup service (30-day expiry)
             startImageCleanup();
 
+            // Load persisted cron tasks from DB and start scheduling
+            cronScheduler.loadFromDb();
+
             // Start Feishu integration service (if configured)
             if (process.env.FEISHU_APP_ID && process.env.FEISHU_APP_SECRET) {
                 startFeishuService().catch(err =>

package/server/routes/cron.js

@@ -0,0 +1,132 @@
+import express from 'express';
+import { randomUUID } from 'crypto';
+import cron from 'node-cron';
+import { cronScheduler } from '../services/builtin-tools/cron-scheduler.js';
+import { feishuDb } from '../database/db.js';
+
+const router = express.Router();
+
+function resolveChannelFields(channel, webhookUrl, userUuid) {
+  if (channel === 'feishu') {
+    const binding = feishuDb.getBindingByUserUuid(userUuid);
+    if (!binding) return { error: '未绑定飞书账号', status: 400 };
+    return { feishuOpenId: binding.feishu_open_id, chatId: null };
+  }
+  if (channel === 'webhook') {
+    if (!webhookUrl) return { error: 'Webhook 渠道需要提供 URL', status: 400 };
+    return { webhookUrl };
+  }
+  return {}; // 网页端
+}
+
+// GET /api/cron-tasks — 列出当前用户所有定时任务
+router.get('/', (req, res) => {
+  const userUuid = req.user.uuid;
+  const tasks = cronScheduler.list(userUuid);
+  res.json({ tasks });
+});
+
+// POST /api/cron-tasks — 创建定时任务
+router.post('/', (req, res) => {
+  const userUuid = req.user.uuid;
+  const { cronExpr, prompt, recurring = true, channel = '', webhookUrl, projectPath } = req.body;
+
+  if (!cronExpr || !prompt) {
+    return res.status(400).json({ error: '缺少 cronExpr 或 prompt' });
+  }
+  if (!cron.validate(cronExpr)) {
+    return res.status(400).json({ error: '无效的 cron 表达式' });
+  }
+
+  const channelFields = resolveChannelFields(channel, webhookUrl, userUuid);
+  if (channelFields.error) {
+    return res.status(channelFields.status).json({ error: channelFields.error });
+  }
+
+  try {
+    const task = cronScheduler.create({
+      id: randomUUID().replace(/-/g, '').slice(0, 8),
+      cronExpr,
+      prompt,
+      recurring,
+      userUuid,
+      sessionId: null,
+      projectPath: projectPath || null,
+      sessionMode: 'new_session',
+      channel,
+      feishuOpenId: channelFields.feishuOpenId || null,
+      chatId: channelFields.chatId || null,
+      webhookUrl: channelFields.webhookUrl || null,
+    });
+    res.json({ task });
+  } catch (e) {
+    res.status(400).json({ error: e.message });
+  }
+});
+
+// PUT /api/cron-tasks/:id — 编辑定时任务
+router.put('/:id', (req, res) => {
+  const userUuid = req.user.uuid;
+  const { id } = req.params;
+  const { cronExpr, prompt, recurring = true, channel = '', webhookUrl, projectPath } = req.body;
+
+  if (!cronExpr || !prompt) {
+    return res.status(400).json({ error: '缺少 cronExpr 或 prompt' });
+  }
+  if (!cron.validate(cronExpr)) {
+    return res.status(400).json({ error: '无效的 cron 表达式' });
+  }
+
+  // 验证任务存在且属于当前用户
+  const tasks = cronScheduler.list(userUuid);
+  if (!tasks.find(t => t.id === id)) {
+    return res.status(404).json({ error: '任务不存在或无权限' });
+  }
+
+  const channelFields = resolveChannelFields(channel, webhookUrl, userUuid);
+  if (channelFields.error) {
+    return res.status(channelFields.status).json({ error: channelFields.error });
+  }
+
+  const task = cronScheduler.update(id, userUuid, {
+    cronExpr, prompt, recurring, channel,
+    projectPath: projectPath || null,
+    feishuOpenId: channelFields.feishuOpenId || null,
+    chatId: channelFields.chatId || null,
+    webhookUrl: channelFields.webhookUrl || null,
+  });
+
+  if (!task) return res.status(500).json({ error: '更新失败' });
+  res.json({ task });
+});
+
+// DELETE /api/cron-tasks/:id — 删除定时任务
+router.delete('/:id', (req, res) => {
+  const userUuid = req.user.uuid;
+  const { id } = req.params;
+  const ok = cronScheduler.delete(id, userUuid);
+  if (!ok) {
+    return res.status(404).json({ error: '任务不存在或无权限' });
+  }
+  res.json({ success: true });
+});
+
+// PATCH /api/cron-tasks/:id/pause — 切换暂停/恢复状态
+router.patch('/:id/pause', (req, res) => {
+  const userUuid = req.user.uuid;
+  const { id } = req.params;
+  const tasks = cronScheduler.list(userUuid);
+  const task = tasks.find(t => t.id === id);
+  if (!task) {
+    return res.status(404).json({ error: '任务不存在或无权限' });
+  }
+  const ok = task.isPaused
+    ? cronScheduler.resume(id, userUuid)
+    : cronScheduler.pause(id, userUuid);
+  if (!ok) {
+    return res.status(500).json({ error: '操作失败' });
+  }
+  res.json({ success: true, isPaused: !task.isPaused });
+});
+
+export default router;

package/server/services/builtin-tools/FeishuWriter.js

@@ -0,0 +1,61 @@
+import { splitMessage } from '../feishu/card-builder.js';
+
+/**
+ * FeishuWriter — 用于 channel='feishu' 的服务端执行模式
+ * 实现与 WebhookWriter 相同的接口（.send / .setSessionId / .getSessionId），
+ * 捕获 Claude 的文本回复，在 claude-complete 时分块发送到飞书。
+ */
+export class FeishuWriter {
+  constructor({ feishuOpenId, chatId, larkClient, cronId }) {
+    this.larkClient = larkClient;
+    this.cronId = cronId;
+    // 优先用 chat_id（群聊/单聊会话 ID），回退 open_id（用户 ID）
+    this._target = chatId || feishuOpenId;
+    this.textBuffer = '';
+    this.sessionId = null;
+  }
+
+  send(data) {
+    try {
+      const obj = typeof data === 'string' ? JSON.parse(data) : data;
+      if (obj.type === 'claude-response') {
+        const d = obj.data;
+        if (d?.type === 'assistant' && Array.isArray(d.message?.content)) {
+          // 非流式：完整 assistant 消息
+          for (const block of d.message.content) {
+            if (block.type === 'text') this.textBuffer += block.text;
+          }
+        } else if (d?.type === 'content_block_delta' && d.delta?.text) {
+          // 流式：逐块 delta
+          this.textBuffer += d.delta.text;
+        }
+      } else if (obj.type === 'claude-complete') {
+        this._sendToFeishu();
+      } else if (obj.type === 'claude-error') {
+        console.error(`[CronFeishu] Task ${this.cronId} error:`, obj.error);
+      }
+    } catch (_) {
+      // 忽略 JSON 解析错误
+    }
+  }
+
+  setSessionId(id) { this.sessionId = id; }
+  getSessionId() { return this.sessionId; }
+
+  async _sendToFeishu() {
+    try {
+      const text = this.textBuffer.trim();
+      if (!text) {
+        console.log(`[CronFeishu] Task ${this.cronId} completed with empty response, skipping send`);
+        return;
+      }
+      const chunks = splitMessage(text, 4000);
+      for (const chunk of chunks) {
+        await this.larkClient.sendTextToTarget(this._target, chunk);
+      }
+      console.log(`[CronFeishu] Task ${this.cronId} sent ${chunks.length} chunk(s) to ${this._target}`);
+    } catch (err) {
+      console.error(`[CronFeishu] Send failed for task ${this.cronId}:`, err.message);
+    }
+  }
+}

package/server/services/builtin-tools/SessionWriter.js

@@ -0,0 +1,29 @@
+/**
+ * SessionWriter — 用于 channel='' 的服务端执行模式
+ *
+ * 接口对齐 WebhookWriter：.send(data) / .setSessionId(id) / .getSessionId()
+ *
+ * 目的：让 queryClaudeSDK 在服务端以新建或 resume 会话方式执行定时任务，
+ * Claude SDK 自动将对话存入会话历史，用户登录后可通过正常会话列表查看。
+ * 本 Writer 不向任何外部系统投递结果。
+ */
+export class SessionWriter {
+  constructor({ cronId }) {
+    this._cronId = cronId;
+    this._sessionId = null;
+  }
+
+  send(data) {
+    try {
+      const obj = typeof data === 'string' ? JSON.parse(data) : data;
+      if (obj.type === 'claude-complete') {
+        console.log(`[CronSession] Task ${this._cronId} completed, sessionId=${this._sessionId}`);
+      } else if (obj.type === 'claude-error') {
+        console.error(`[CronSession] Task ${this._cronId} error:`, obj.error);
+      }
+    } catch (_) {}
+  }
+
+  setSessionId(id) { this._sessionId = id; }
+  getSessionId() { return this._sessionId; }
+}

package/server/services/builtin-tools/WebhookWriter.js

@@ -0,0 +1,70 @@
+import { buildTextOrMarkdownMessage } from '../feishu/card-builder.js';
+
+/**
+ * WebhookWriter — 用于 delivery_mode='webhook' 的服务端执行模式
+ * 实现与 WebSocketWriter 相同的接口（.send / .setSessionId / .getSessionId），
+ * 捕获 Claude 的文本回复，在 claude-complete 时 POST 到 webhookUrl。
+ */
+export class WebhookWriter {
+  constructor({ webhookUrl, cronId, cronExpr, prompt, userUuid, cwd }) {
+    this.webhookUrl = webhookUrl;
+    this.meta = { cronId, cronExpr, prompt };
+    this.userUuid = userUuid;
+    this.cwd = cwd;
+    this.textBuffer = '';
+    this.sessionId = null;
+  }
+
+  send(data) {
+    try {
+      const obj = typeof data === 'string' ? JSON.parse(data) : data;
+      if (obj.type === 'claude-response') {
+        const d = obj.data;
+        if (d?.type === 'assistant' && Array.isArray(d.message?.content)) {
+          // 非流式：完整 assistant 消息
+          for (const block of d.message.content) {
+            if (block.type === 'text') this.textBuffer += block.text;
+          }
+        } else if (d?.type === 'content_block_delta' && d.delta?.text) {
+          // 流式：逐块 delta
+          this.textBuffer += d.delta.text;
+        }
+      } else if (obj.type === 'claude-complete') {
+        this._postWebhook();
+      }
+    } catch (_) {
+      // 忽略 JSON 解析错误
+    }
+  }
+
+  setSessionId(id) { this.sessionId = id; }
+  getSessionId() { return this.sessionId; }
+
+  async _postWebhook() {
+    try {
+      const feishu = buildTextOrMarkdownMessage(this.textBuffer);
+      const parsedContent = JSON.parse(feishu.content);
+      // 飞书 webhook: text 用 content 字段，interactive 用 card 字段
+      const feishuPayload = feishu.msgType === 'interactive'
+        ? { msg_type: feishu.msgType, card: parsedContent }
+        : { msg_type: feishu.msgType, content: parsedContent };
+      const body = {
+        cron_id: this.meta.cronId,
+        cron_expr: this.meta.cronExpr,
+        prompt: this.meta.prompt,
+        fired_at: Date.now(),
+        response: this.textBuffer,
+        ...feishuPayload,
+      };
+      console.log(`[CronWebhook] POST body:`, JSON.stringify(body));
+      await fetch(this.webhookUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      console.log(`[CronWebhook] POST succeeded for task ${this.meta.cronId}, response length=${this.textBuffer.length}`);
+    } catch (err) {
+      console.error(`[CronWebhook] POST failed for task ${this.meta.cronId}:`, err.message);
+    }
+  }
+}

package/server/services/builtin-tools/background-task.js

@@ -73,11 +73,7 @@ __bg_status__ bg_xxxxxxxxxxxx
 
     // 解析参数
     const rawArgs = hookInput.tool_input.command.replace(/^\s*__bg_exec__\s*/, '');
-    let jsonStr = rawArgs.trim();
-    if ((jsonStr.startsWith("'") && jsonStr.endsWith("'")) ||
-        (jsonStr.startsWith('"') && jsonStr.endsWith('"'))) {
-      jsonStr = jsonStr.slice(1, -1);
-    }
+    let jsonStr = rawArgs.trim().replace(/^[\u2018\u201C'"]|[\u2019\u201D'"]+$/g, '').trim();
 
     let params;
     try {