@leviyuan/lodestar 0.1.0 → 2.0.14

package/email-worker.ts

@@ -0,0 +1,534 @@
+/**
+ * Email worker — IMAP listener + SMTP sender + task queue.
+ *
+ * Watches a mailbox via IMAP, filters by whitelist, parses
+ * project + request from subject/body, creates a DeepSeek thread+turn
+ * via Runtime API, and replies with the result via SMTP.
+ *
+ * Feishu notifications are sent at three points:
+ *   📩 received  🚀 started  ✅ completed (or ⏰ timeout / ❌ error)
+ *
+ * DeepSeek TUI migration: spawn claude -p → Runtime API createThread + createTurn.
+ *
+ * Imported and started by daemon.ts.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+import { RuntimeApiClient } from './runtime-api'
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+export interface EmailConfig {
+  imap: { host: string; port?: number; user: string; pass: string }
+  smtp: { host: string; port?: number; user: string; pass: string }
+  projects: Record<string, ProjectConfig>
+  defaults?: {
+    timeout_minutes?: number
+    permission_mode?: string
+    max_budget_usd?: number
+  }
+}
+
+export interface ProjectConfig {
+  whitelist: string[]
+  allowed_intents?: string
+  system_prompt?: string
+  timeout_minutes?: number
+  permission_mode?: string
+  max_budget_usd?: number
+}
+
+interface EmailTask {
+  from: string
+  subject: string
+  project: string
+  request: string
+  messageId: string
+  inReplyTo?: string
+  receivedAt: Date
+}
+
+// ── State ───────────────────────────────────────────────────────────────────
+
+const STATE_DIR = join(homedir(), '.deepseek', 'lodestar')
+const PROJECTS_ROOT = process.env.FEISHU_PROJECTS_ROOT ?? homedir()
+const CONFIG_FILE = join(STATE_DIR, 'email-config.json')
+const API_URL = process.env.DEEPSEEK_API_URL ?? 'http://localhost:7878'
+const API_TOKEN = process.env.DEEPSEEK_API_TOKEN ?? ''
+
+let config: EmailConfig | null = null
+let imapClient: any = null
+let smtpTransport: any = null
+let logFn: (msg: string) => void = console.log
+let sendFeishuFn: ((chatId: string, text: string) => Promise<void>) | null = null
+let chatNameCacheRef: Map<string, string> | null = null
+let api: RuntimeApiClient
+
+// Task queue: project → pending tasks
+const taskQueues = new Map<string, EmailTask[]>()
+const activeJobs = new Map<string, boolean>()
+
+// Dedup: track processed message IDs to avoid re-processing after IMAP reconnect
+const processedMessageIds = new Set<string>()
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+/**
+ * Initialize the email worker. Called from daemon.ts boot().
+ *
+ * @param log        daemon's log function
+ * @param sendText   daemon's sendTextMessage function
+ * @param chatNames  daemon's chatNameCache (to find chat_id for a project)
+ */
+export async function startEmailWorker(
+  log: (msg: string) => void,
+  sendText: (chatId: string, text: string) => Promise<void>,
+  chatNames: Map<string, string>,
+): Promise<void> {
+  logFn = log
+  sendFeishuFn = sendText
+  chatNameCacheRef = chatNames
+
+  api = new RuntimeApiClient({ baseUrl: API_URL, authToken: API_TOKEN })
+
+  config = loadConfig()
+  if (!config) {
+    logFn('email-worker: no email-config.json found, email channel disabled')
+    return
+  }
+
+  logFn(`email-worker: projects: ${Object.keys(config.projects).join(', ')}`)
+  for (const [name, proj] of Object.entries(config.projects)) {
+    logFn(`email-worker:   ${name} whitelist: [${proj.whitelist.join(', ')}]`)
+  }
+
+  try {
+    await setupSMTP()
+    await setupIMAP()
+    logFn('email-worker: ready')
+  } catch (err) {
+    logFn(`email-worker: startup failed: ${err}`)
+  }
+}
+
+export function stopEmailWorker(): void {
+  try { imapClient?.close() } catch {}
+  try { imapClient?.logout() } catch {}
+  try { smtpTransport?.close() } catch {}
+  logFn('email-worker: stopped')
+}
+
+// ── Config ──────────────────────────────────────────────────────────────────
+
+function loadConfig(): EmailConfig | null {
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+// ── IMAP ────────────────────────────────────────────────────────────────────
+
+let ImapFlowClass: any = null
+
+async function createImapClient(): Promise<any> {
+  if (!ImapFlowClass) {
+    const mod = await import('imapflow')
+    ImapFlowClass = mod.ImapFlow
+  }
+  const imap = config!.imap
+  const client = new ImapFlowClass({
+    host: imap.host,
+    port: imap.port ?? 993,
+    secure: true,
+    auth: { user: imap.user, pass: imap.pass },
+    logger: false,
+  })
+  client.on('error', (err: any) => {
+    logFn(`email-worker: IMAP error: ${err}`)
+  })
+  return client
+}
+
+async function setupIMAP(): Promise<void> {
+  imapClient = await createImapClient()
+  await imapClient.connect()
+  logFn('email-worker: IMAP connected')
+
+  listenForMail().catch(err => logFn(`email-worker: listen loop crashed: ${err}`))
+}
+
+async function reconnectIMAP(): Promise<void> {
+  try { imapClient?.logout() } catch {}
+  imapClient = await createImapClient()
+  await imapClient.connect()
+  logFn('email-worker: IMAP reconnected')
+}
+
+async function listenForMail(): Promise<void> {
+  try {
+    const lock = await imapClient.getMailboxLock('INBOX')
+    try {
+      await processUnseen()
+    } finally {
+      lock.release()
+    }
+  } catch (err) {
+    logFn(`email-worker: initial processUnseen failed: ${err}`)
+  }
+
+  setInterval(async () => {
+    try {
+      const lock = await imapClient.getMailboxLock('INBOX')
+      try {
+        await processUnseen()
+      } finally {
+        lock.release()
+      }
+    } catch (err) {
+      logFn(`email-worker: poll error: ${err}`)
+      try {
+        await reconnectIMAP()
+      } catch (reconErr) {
+        logFn(`email-worker: reconnect failed: ${reconErr}`)
+      }
+    }
+  }, 30_000)
+
+  logFn('email-worker: polling every 30s for new mail')
+}
+
+async function processUnseen(): Promise<void> {
+  const messages = imapClient.fetch({ seen: false }, {
+    envelope: true,
+    source: true,
+    uid: true,
+  })
+
+  for await (const msg of messages) {
+    try {
+      await handleEmail(msg)
+      await imapClient.messageFlagsAdd({ uid: msg.uid }, ['\\Seen'], { uid: true })
+    } catch (err) {
+      logFn(`email-worker: handle email error: ${err}`)
+    }
+  }
+}
+
+// ── Email parsing ───────────────────────────────────────────────────────────
+
+async function handleEmail(msg: any): Promise<void> {
+  const envelope = msg.envelope
+  const from = envelope?.from?.[0]?.address?.toLowerCase() ?? ''
+  const subject = envelope?.subject ?? ''
+  const messageId = envelope?.messageId ?? ''
+  const inReplyTo = envelope?.inReplyTo ?? undefined
+
+  logFn(`email-worker: received from=${from} subject="${subject}" msgId=${messageId}`)
+
+  if (processedMessageIds.has(messageId)) {
+    logFn(`email-worker: skipping duplicate messageId=${messageId}`)
+    return
+  }
+  processedMessageIds.add(messageId)
+  if (processedMessageIds.size > 500) {
+    const arr = [...processedMessageIds]
+    for (let i = 0; i < 250; i++) processedMessageIds.delete(arr[i])
+  }
+
+  const projectMatch = subject.match(/^\[([^\]]+)\]\s*(.*)$/)
+  if (!projectMatch) {
+    logFn(`email-worker: no [project] in subject, ignoring`)
+    return
+  }
+
+  const project = projectMatch[1].trim()
+  const requestTitle = projectMatch[2].trim()
+
+  if (!config!.projects[project]) {
+    logFn(`email-worker: project "${project}" not in config, ignoring`)
+    return
+  }
+
+  const projConfig = config!.projects[project]
+  if (!projConfig.whitelist.some(w => w.toLowerCase() === from)) {
+    logFn(`email-worker: ${from} not in whitelist for project "${project}", ignoring`)
+    return
+  }
+
+  const workDir = join(PROJECTS_ROOT, project)
+  if (!existsSync(workDir)) {
+    logFn(`email-worker: directory ~/${project} does not exist`)
+    await sendReply(from, subject, messageId,
+      `项目目录 ~/${project} 不存在`)
+    return
+  }
+
+  const body = await extractPlainText(msg.source?.toString() ?? '')
+
+  const task: EmailTask = {
+    from,
+    subject,
+    project,
+    request: body || requestTitle,
+    messageId,
+    inReplyTo,
+    receivedAt: new Date(),
+  }
+
+  enqueue(task)
+}
+
+async function extractPlainText(raw: string): Promise<string> {
+  try {
+    const { simpleParser } = await import('mailparser')
+    const parsed = await simpleParser(raw)
+    let body = parsed.text ?? ''
+    if (!body && parsed.html) {
+      body = parsed.html.replace(/<[^>]+>/g, '').replace(/&nbsp;/g, ' ')
+    }
+    body = body.trim()
+    if (body.length > 10000) body = body.slice(0, 10000)
+    return body
+  } catch (err) {
+    logFn(`email-worker: mailparser failed: ${err}`)
+    return '(邮件正文解析失败，请使用纯文本格式发送)'
+  }
+}
+
+// ── Task queue & execution ──────────────────────────────────────────────────
+
+function mirrorQueueState(): void {
+  try {
+    const projects: Record<string, any> = {}
+    for (const [name, q] of taskQueues) {
+      const running = activeJobs.get(name) && q.length >= 0
+      const current = running ? (taskQueues.get(name)?.[0]?.subject ?? null) : null
+      projects[name] = { queued: q.length, running: current, total: 0 }
+    }
+    const path = join(STATE_DIR, 'email-queue.json')
+    writeFileSync(path, JSON.stringify({ projects }), 'utf-8')
+  } catch {}
+}
+
+function enqueue(task: EmailTask): void {
+  const q = taskQueues.get(task.project) ?? []
+  q.push(task)
+  taskQueues.set(task.project, q)
+  mirrorQueueState()
+  if (!activeJobs.get(task.project)) {
+    activeJobs.set(task.project, true)
+    processQueue(task.project)
+  }
+}
+
+async function processQueue(project: string): Promise<void> {
+  const q = taskQueues.get(project)
+
+  while (q?.length) {
+    const task = q.shift()!
+    mirrorQueueState()
+    await executeTask(task)
+  }
+
+  activeJobs.set(project, false)
+  mirrorQueueState()
+}
+
+async function executeTask(task: EmailTask): Promise<void> {
+  const { project, from, subject, request, messageId } = task
+
+  const projConfig = config!.projects[project]
+  const defaults = config!.defaults ?? {}
+  const timeoutMin = projConfig.timeout_minutes ?? defaults.timeout_minutes ?? 30
+
+  const systemPrompt = buildSystemPrompt(project, projConfig, from)
+
+  // Notify Feishu
+  await notifyFeishu(project,
+    `📩🚀 收到邮件任务，开始执行\n发件人: ${from}\n主题: ${subject}\n正文: ${request}`)
+  logFn(`email-worker: executing task for "${project}": ${subject}`)
+
+  try {
+    const result = await runDeepseek(project, systemPrompt, request, timeoutMin)
+
+    await sendReply(from, subject, messageId, result)
+
+    const preview = result.length > 200 ? result.slice(0, 200) + '...' : result
+    await notifyFeishu(project, `✅ 邮件任务完成\n主题: ${subject}\n结果预览: ${preview}`)
+    logFn(`email-worker: task completed for "${project}": ${subject}`)
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err)
+    await sendReply(from, subject, messageId,
+      `任务执行失败: ${errMsg}\n\n请联系管理员检查日志。`)
+    await notifyFeishu(project, `❌ 邮件任务失败\n主题: ${subject}\n错误: ${errMsg}`)
+    logFn(`email-worker: task failed for "${project}": ${errMsg}`)
+  }
+}
+
+function buildSystemPrompt(project: string, projConfig: ProjectConfig, sender: string): string {
+  const parts: string[] = []
+
+  if (projConfig.system_prompt) {
+    parts.push(projConfig.system_prompt)
+  } else {
+    parts.push(`你是 ${project} 项目的开发助手。`)
+  }
+
+  if (projConfig.allowed_intents) {
+    parts.push(`你只被允许进行以下类型的工作：${projConfig.allowed_intents}。`)
+    parts.push('如果需求超出范围，直接拒绝并说明原因。')
+  }
+
+  parts.push(`当前任务来自邮件用户 ${sender}。`)
+  parts.push('请完成任务后给出清晰的结果摘要。')
+  parts.push('完成后，在最后一次回复中请用 markdown 格式清晰总结你的工作。')
+
+  return parts.join('\n')
+}
+
+// ── DeepSeek execution (replaces spawn claude -p) ───────────────────────────
+
+async function runDeepseek(
+  project: string,
+  systemPrompt: string,
+  request: string,
+  timeoutMin: number,
+): Promise<string> {
+  const workDir = join(PROJECTS_ROOT, project)
+  const threadTitle = `email-${project}-${Date.now()}`
+
+  // Create a one-shot thread for this email task
+  const thread = await api.createThread({
+    title: threadTitle,
+    workspace: workDir,
+    mode: 'yolo',
+    auto_approve: true,
+    system_prompt: systemPrompt,
+  })
+
+  logFn(`email-worker: created thread ${thread.id} for ${project}`)
+
+  try {
+    // Inject the turn
+    const turnRes = await api.createTurn(thread.id, {
+      prompt: request,
+      auto_approve: true,
+      mode: 'yolo',
+    })
+
+    const turnId = turnRes.turn.id
+    logFn(`email-worker: turn ${turnId} started for ${project}`)
+
+    // Poll for completion via thread detail (turns embedded in thread response)
+    const deadline = Date.now() + timeoutMin * 60 * 1000
+
+    while (Date.now() < deadline) {
+      await new Promise(r => setTimeout(r, 2000))
+
+      try {
+        const detail = await api.getThread(thread.id)
+        const turn = detail.turns.find(t => t.id === turnId)
+        if (!turn) continue
+
+        if (turn.status === 'completed') {
+          const agentMessages = detail.items
+            .filter(item => item.kind === 'agent_message')
+            .map(item => item.detail || item.summary)
+          return agentMessages.join('\n').trim() || '(任务完成，无文本输出)'
+        }
+        if (turn.status === 'error') {
+          throw new Error('turn ended with error status')
+        }
+      } catch (err: any) {
+        if (err.message?.includes('not found')) continue
+        throw err
+      }
+    }
+
+    // Timeout — try to interrupt
+    try { await api.interruptTurn(thread.id, turnId) } catch {}
+    throw new Error(`超时 (${timeoutMin} 分钟)`)
+  } finally {
+    // Cleanup: archive the thread
+    try { await api.archiveThread(thread.id) } catch {}
+  }
+}
+
+// ── SMTP ────────────────────────────────────────────────────────────────────
+
+async function setupSMTP(): Promise<void> {
+  const nodemailer = await import('nodemailer')
+  const smtp = config!.smtp
+  smtpTransport = nodemailer.default.createTransport({
+    host: smtp.host,
+    port: smtp.port ?? 465,
+    secure: true,
+    auth: { user: smtp.user, pass: smtp.pass },
+  })
+
+  await smtpTransport.verify()
+  logFn('email-worker: SMTP connected')
+}
+
+async function sendReply(
+  to: string,
+  originalSubject: string,
+  inReplyTo: string,
+  body: string,
+): Promise<void> {
+  if (!smtpTransport || !config) return
+
+  const subject = originalSubject.startsWith('Re:')
+    ? originalSubject
+    : `Re: ${originalSubject}`
+
+  const attachments: { filename: string; path: string }[] = []
+  const cleanBody = body.replace(/\[ATTACH:([^\]]+)\]/g, (_match, filePath: string) => {
+    const p = filePath.trim()
+    if (existsSync(p)) {
+      attachments.push({ filename: p.split('/').pop() ?? 'attachment', path: p })
+      return `(附件: ${p.split('/').pop()})`
+    }
+    return `(附件未找到: ${p})`
+  })
+
+  try {
+    await smtpTransport.sendMail({
+      from: config.smtp.user,
+      to,
+      subject,
+      text: cleanBody,
+      inReplyTo,
+      references: inReplyTo,
+      ...(attachments.length ? { attachments } : {}),
+    })
+    logFn(`email-worker: replied to ${to}: ${subject} (${attachments.length} attachments)`)
+  } catch (err) {
+    logFn(`email-worker: SMTP send failed: ${err}`)
+  }
+}
+
+// ── Feishu notifications ────────────────────────────────────────────────────
+
+async function notifyFeishu(project: string, text: string): Promise<void> {
+  if (!sendFeishuFn || !chatNameCacheRef) return
+
+  let chatId: string | undefined
+  for (const [id, name] of chatNameCacheRef) {
+    if (name === project) {
+      chatId = id
+      break
+    }
+  }
+
+  if (chatId) {
+    await sendFeishuFn(chatId, text).catch(err =>
+      logFn(`email-worker: feishu notify failed: ${err}`))
+  } else {
+    logFn(`email-worker: no feishu group found for project "${project}", skipping notification`)
+  }
+}

package/env-bootstrap.ts

@@ -0,0 +1,7 @@
+/**
+ * Env bootstrap — populate process.env from ~/.deepseek/lodestar.toml
+ * before any other module reads it. Must be the FIRST import in daemon.ts.
+ */
+
+import { populateEnv } from './config'
+populateEnv()