@miphamai/cli 0.50.0 → 0.51.0

package/src/daemon/index.ts

@@ -25,6 +25,8 @@ import type { DaemonStatus } from './types'
 import { logger } from './logger'
 import { parseFeishuEnv } from './feishu/env.js'
 import type { FeishuConfig } from './feishu/types.js'
+import { parseTelegramEnv } from './telegram/env.js'
+import type { TelegramConfig } from './telegram/types.js'
 import { loadConfig } from '../config/loader'
 
 const HOME = homedir()
@@ -40,8 +42,6 @@ const DEFAULT_PORT = 45671
 let activeServer: Server<unknown> | null = null
 let activeDb: DaemonDatabase | null = null
 let activePool: WorkerPool | null = null
-let activeAgentManager: AgentManager | null = null
-let activeMessageBus: MessageBus | null = null
 let activeScheduleManager: ScheduleManager | null = null
 let activeRateLimiter: RateLimiter | null = null
 
@@ -150,9 +150,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
 
   // Create agent manager and message bus (Phase 3)
   const agentManager = new AgentManager(db)
-  activeAgentManager = agentManager
   const messageBus = new MessageBus()
-  activeMessageBus = messageBus
 
   // Create goal manager and schedule manager (Phase 4)
   const goalManager = new GoalManager(db)
@@ -181,6 +179,21 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     }
   }
 
+  // Telegram remote-control adapter（env 未配置时跳过；配置则解析 session 默认 provider/model）
+  const telegramConfig = parseTelegramEnv()
+  let telegram: { config: TelegramConfig; cwd: string; provider: string; model: string } | undefined
+  if (telegramConfig) {
+    const cfg = loadConfig()
+    // 取第一个非 upcoming（即非「待上线」）的 provider 及其首个 model
+    const provider = cfg.providers.find((p) => p.status !== 'upcoming') ?? cfg.providers[0]
+    telegram = {
+      config: telegramConfig,
+      cwd: process.env.TELEGRAM_CWD || process.cwd(),
+      provider: provider?.id ?? 'anthropic',
+      model: provider?.models?.[0]?.id ?? 'claude-sonnet-5',
+    }
+  }
+
   // Start HTTP server (Bun.serve starts listening immediately)
   const server = createServer({
     db,
@@ -196,6 +209,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     scheduleManager,
     rateLimiter,
     feishu,
+    telegram,
   })
   activeServer = server
 
@@ -250,10 +264,6 @@ export async function stopDaemon(force: boolean = false): Promise<void> {
     activeRateLimiter = null
   }
 
-  // Clean up agent manager and message bus (Phase 3)
-  activeAgentManager = null
-  activeMessageBus = null
-
   // Close database (commits any pending WAL)
   if (activeDb) {
     activeDb.close()

package/src/daemon/server.ts

@@ -26,6 +26,9 @@ import type { ToolDefinition, PermissionMode, PermissionRestrictions } from '../
 import { createFeishuAdapter } from './feishu/adapter.js'
 import { createFeishuApi } from './feishu/api.js'
 import type { FeishuConfig } from './feishu/types.js'
+import { createTelegramAdapter } from './telegram/adapter.js'
+import { createTelegramApi } from './telegram/api.js'
+import type { TelegramConfig } from './telegram/types.js'
 import { startHeartbeat } from './heartbeat'
 
 interface ServerConfig {
@@ -42,6 +45,7 @@ interface ServerConfig {
   scheduleManager: ScheduleManager
   rateLimiter: RateLimiter
   feishu?: { config: FeishuConfig; cwd: string; provider: string; model: string }
+  telegram?: { config: TelegramConfig; cwd: string; provider: string; model: string }
 }
 
 interface WsData {
@@ -71,13 +75,20 @@ function resolveDaemonPermission(): PermissionMode {
 
 /**
  * Build the daemon's PermissionSystem, honoring org-level restrictions
- * (permissionRestrictions). setRestrictions re-clamps the env-derived mode,
- * so a `MIPHAM_DAEMON_PERMISSION=bypassPermissions` is downgraded when the
- * config forbids it — mirroring the CLI's fail-closed behavior.
+ * (permissionRestrictions) and user-defined allow/deny rules. setRestrictions
+ * re-clamps the env-derived mode, so a `MIPHAM_DAEMON_PERMISSION=bypassPermissions`
+ * is downgraded when the config forbids it — mirroring the CLI's fail-closed behavior.
  */
-export function buildDaemonPermission(restrictions?: PermissionRestrictions): PermissionSystem {
+export function buildDaemonPermission(
+  restrictions?: PermissionRestrictions,
+  rules?: { allow?: string[]; deny?: string[] },
+): PermissionSystem {
   const permission = new PermissionSystem(resolveDaemonPermission())
   if (restrictions) permission.setRestrictions(restrictions)
+  if (rules) {
+    for (const rule of rules.allow ?? []) permission.allow(rule)
+    for (const rule of rules.deny ?? []) permission.deny(rule)
+  }
   return permission
 }
 
@@ -112,6 +123,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
     scheduleManager,
     rateLimiter,
     feishu,
+    telegram,
   } = config
 
   const wsClients = new Map<string, Set<ServerWebSocket<WsData>>>()
@@ -199,7 +211,11 @@ export function createServer(config: ServerConfig): Server<WsData> {
       }
     }
 
-    const permission = buildDaemonPermission(loadConfig(cwd).permissionRestrictions)
+    const daemonConfig = loadConfig(cwd)
+    const permission = buildDaemonPermission(
+      daemonConfig.permissionRestrictions,
+      daemonConfig.permissionRules,
+    )
     const engine = new QueryEngine(sharedRegistry, context, sharedTools, permission)
     engine.setSessionId(sessionId)
     engineCache.set(sessionId, engine)
@@ -208,7 +224,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
 
   function getOrCreateWorker(
     sessionId: string,
-    ws?: ServerWebSocket<WsData>,
+    _ws?: ServerWebSocket<WsData>,
   ): SessionWorker | null {
     try {
       const session = db.getSession(sessionId)
@@ -245,14 +261,28 @@ export function createServer(config: ServerConfig): Server<WsData> {
       })
     : undefined
 
+  // ── Telegram remote-control adapter（长轮询，无需 webhook 路由）──
+  const telegramAdapter = telegram
+    ? createTelegramAdapter(telegram.config, createTelegramApi(telegram.config), {
+        sm,
+        getOrCreateWorker,
+        rateLimiter,
+        cwd: telegram.cwd,
+        provider: telegram.provider,
+        model: telegram.model,
+      })
+    : undefined
+  telegramAdapter?.start()
+
   // ── 心跳式通知：定时扫 pending（goal/schedule），只通知、不自主行动 ──
+  const heartbeatSource = {
+    listGoals: () => sm.listSessions().flatMap((s) => goalManager.getGoals(s.id)),
+    listSchedules: () => sm.listSessions().flatMap((s) => scheduleManager.getSchedules(s.id)),
+  }
   if (feishu) {
     const feishuApi = createFeishuApi(feishu.config)
     startHeartbeat({
-      source: {
-        listGoals: () => sm.listSessions().flatMap((s) => goalManager.getGoals(s.id)),
-        listSchedules: () => sm.listSessions().flatMap((s) => scheduleManager.getSchedules(s.id)),
-      },
+      source: heartbeatSource,
       push: (message) => {
         for (const openId of feishu.config.allowedOpenIds) {
           void feishuApi.sendText(openId, message).catch(() => {
@@ -262,6 +292,19 @@ export function createServer(config: ServerConfig): Server<WsData> {
       },
     })
   }
+  if (telegram) {
+    const telegramApi = createTelegramApi(telegram.config)
+    startHeartbeat({
+      source: heartbeatSource,
+      push: (message) => {
+        for (const chatId of telegram.config.allowedChatIds) {
+          void telegramApi.sendText(chatId, message).catch(() => {
+            /* 推送失败静默，不打断心跳 */
+          })
+        }
+      },
+    })
+  }
 
   const server = Bun.serve<WsData>({
     port,

package/src/daemon/session-manager.ts

@@ -1,5 +1,5 @@
 import type { DaemonDatabase } from './database'
-import type { DaemonSession, SessionStatus } from './types'
+import type { DaemonSession } from './types'
 
 type SessionCloseCallback = (sessionId: string) => void
 
@@ -23,13 +23,14 @@ export class SessionManager {
     return this.db.listSessions(status)
   }
 
-  getOrCreateByFeishuOpenId(
-    openId: string,
+  getOrCreateByExternalUser(
+    channel: string,
+    userId: string,
     cwd: string,
     provider: string,
     model: string,
   ): DaemonSession {
-    const name = `feishu-${openId}`
+    const name = `${channel}-${userId}`
     const existing = this.db.listSessions().find((s) => s.name === name && s.status !== 'closed')
     if (existing) return existing
     return this.db.createSession({ name, cwd, provider, model })

package/src/daemon/telegram/adapter.ts

@@ -0,0 +1,70 @@
+import type { TelegramApi } from './api.js'
+import type { TelegramConfig, TelegramMessage } from './types.js'
+import type { SessionManager } from '../session-manager'
+import type { SessionWorker } from '../session-worker'
+import type { RateLimiter } from '../rate-limiter'
+import { startTelegramPoller } from './poller.js'
+
+export interface TelegramAdapterDeps {
+  sm: SessionManager
+  getOrCreateWorker: (sessionId: string) => SessionWorker | null
+  rateLimiter: RateLimiter
+  cwd: string
+  provider: string
+  model: string
+}
+
+export interface TelegramAdapter {
+  start(): () => void
+  handleMessage(msg: TelegramMessage): Promise<void>
+  isAllowed(chatId: string): boolean
+}
+
+export function createTelegramAdapter(
+  config: TelegramConfig,
+  api: TelegramApi,
+  deps: TelegramAdapterDeps,
+): TelegramAdapter {
+  const allowed = new Set(config.allowedChatIds)
+  let stopPoller: (() => void) | null = null
+
+  async function handleMessage(msg: TelegramMessage): Promise<void> {
+    try {
+      if (!allowed.has(msg.chatId)) return
+      if (!deps.rateLimiter.check(`telegram:${msg.chatId}`).allowed) return
+
+      const session = deps.sm.getOrCreateByExternalUser(
+        'telegram',
+        msg.chatId,
+        deps.cwd,
+        deps.provider,
+        deps.model,
+      )
+      const worker = deps.getOrCreateWorker(session.id)
+      if (!worker) {
+        await api.sendText(msg.chatId, '（会话初始化失败，请稍后重试）')
+        return
+      }
+      await worker.processPrompt(msg.text)
+      const result = worker.getLastAssistantContent()
+      await api.sendText(msg.chatId, result ? result.slice(0, 4096) : '（无回复）')
+    } catch (err) {
+      console.error('[telegram] message handling failed:', err)
+      try {
+        await api.sendText(msg.chatId, '（处理失败，请稍后重试）')
+      } catch {
+        /* 忽略回送失败，不 rethrow */
+      }
+    }
+  }
+
+  return {
+    handleMessage,
+    isAllowed: (chatId) => allowed.has(chatId),
+    start() {
+      if (stopPoller) return stopPoller
+      stopPoller = startTelegramPoller(api, handleMessage)
+      return stopPoller
+    },
+  }
+}

package/src/daemon/telegram/api.ts

@@ -0,0 +1,45 @@
+import type { TelegramConfig } from './types.js'
+
+export interface TelegramApi {
+  getUpdates(
+    offset: number,
+    timeoutSeconds: number,
+  ): Promise<Array<{ update_id: number; message?: unknown }>>
+  sendText(chatId: string, text: string): Promise<void>
+}
+
+/** 裸 fetch 直连 Telegram Bot API，零依赖。 */
+export function createTelegramApi(config: TelegramConfig): TelegramApi {
+  const base = `https://api.telegram.org/bot${config.botToken}`
+  return {
+    async getUpdates(offset, timeoutSeconds) {
+      const url =
+        `${base}/getUpdates?offset=${offset}&timeout=${timeoutSeconds}` +
+        `&limit=100&allowed_updates=%5B%22message%22%5D`
+      const res = await fetch(url)
+      if (!res.ok) throw new Error(`getUpdates ${res.status}`)
+      const data = (await res.json()) as {
+        ok: boolean
+        result?: Array<{ update_id: number; message?: unknown }>
+        error_code?: number
+        description?: string
+      }
+      if (!data.ok) throw new Error(`getUpdates failed: ${data.error_code ?? res.status}`)
+      return data.result ?? []
+    },
+    async sendText(chatId, text) {
+      const res = await fetch(`${base}/sendMessage`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ chat_id: chatId, text }),
+      })
+      if (!res.ok) throw new Error(`sendMessage ${res.status}`)
+      const data = (await res.json()) as {
+        ok: boolean
+        error_code?: number
+        description?: string
+      }
+      if (!data.ok) throw new Error(`sendMessage failed: ${data.error_code ?? res.status}`)
+    },
+  }
+}

package/src/daemon/telegram/env.ts

@@ -0,0 +1,14 @@
+import type { TelegramConfig } from './types.js'
+
+/** fail-closed：缺 botToken → null（daemon 不启用 Telegram）。 */
+export function parseTelegramEnv(): TelegramConfig | null {
+  const botToken = process.env.TELEGRAM_BOT_TOKEN
+  if (!botToken) return null
+  return {
+    botToken,
+    allowedChatIds: (process.env.TELEGRAM_ALLOWED_CHAT_IDS || '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean),
+  }
+}

package/src/daemon/telegram/poller.ts

@@ -0,0 +1,64 @@
+import type { TelegramApi } from './api.js'
+import type { TelegramMessage } from './types.js'
+
+/** 从 update 提取文本消息；非文本/缺 message → null。chat.id 统一字符串化比对（id < 2^53；超范围 bigint 后续再引入）。 */
+export function extractTextMessage(update: unknown): TelegramMessage | null {
+  const msg = (
+    update as { message?: { chat?: { id?: number | string }; message_id?: number; text?: string } }
+  )?.message
+  if (!msg?.text || msg.chat?.id == null) return null
+  return { chatId: String(msg.chat.id), messageId: msg.message_id ?? 0, text: msg.text }
+}
+
+/** 推进 offset：最大 update_id + 1；空列表沿用 prev。 */
+export function nextOffset(updates: Array<{ update_id?: number }>, prevOffset: number): number {
+  if (updates.length === 0) return prevOffset
+  return Math.max(...updates.map((u) => u.update_id ?? prevOffset)) + 1
+}
+
+/** 指数退避，封顶 30s。 */
+export function nextBackoff(currentMs: number): number {
+  return Math.min(currentMs * 2, 30_000)
+}
+
+/** 长轮询循环（unref 不阻退出）。返回 stop 函数。循环行为由 Task 7 集成测试覆盖。 */
+export function startTelegramPoller(
+  api: TelegramApi,
+  onMessage: (msg: TelegramMessage) => Promise<void>,
+  opts?: { pollTimeoutSeconds?: number },
+): () => void {
+  let offset = 0
+  let backoffMs = 1000
+  let stopped = false
+  let timer: ReturnType<typeof setTimeout> | null = null
+
+  async function loop() {
+    if (stopped) return
+    try {
+      const updates = await api.getUpdates(offset, opts?.pollTimeoutSeconds ?? 30)
+      for (const u of updates) {
+        const msg = extractTextMessage(u)
+        if (msg) {
+          try {
+            await onMessage(msg)
+          } catch {
+            /* 单条失败不中断轮询 */
+          }
+        }
+      }
+      offset = nextOffset(updates, offset)
+      backoffMs = 1000
+    } catch {
+      backoffMs = nextBackoff(backoffMs)
+    }
+    if (stopped) return
+    timer = setTimeout(loop, backoffMs)
+    ;(timer as { unref?: () => void }).unref?.()
+  }
+
+  void loop()
+  return () => {
+    stopped = true
+    if (timer) clearTimeout(timer)
+  }
+}

package/src/daemon/telegram/types.ts

@@ -0,0 +1,10 @@
+export interface TelegramConfig {
+  botToken: string
+  allowedChatIds: string[]
+}
+
+export interface TelegramMessage {
+  chatId: string
+  messageId: number
+  text: string
+}

package/src/i18n-core/locales/en-US.json

@@ -612,6 +612,129 @@
     },
     "schedule": {
       "failed": "Schedule check failed: {error}"
+    },
+    "crsi_critique": {
+      "not_init": "SelfCritique not initialized. Mipham Code >= v0.34.0 required.",
+      "on_title": "## 🔍 Self-Critique: ON",
+      "on_desc1": "The AI will now critique its own tool calls before execution.",
+      "on_desc2": "Safe + correct + necessary checks run before every targeted tool call.",
+      "on_hint": "💡 `/crsi critique off` to disable | `/crsi critique status` for current config",
+      "off_title": "## 🔍 Self-Critique: OFF\n\nTool calls will execute without pre-flight critique.",
+      "status_title": "## 🔍 Self-Critique Status",
+      "state": "State: **{state}**",
+      "model": "Model: **{model}**",
+      "threshold": "Threshold: **{pct}%**",
+      "threshold_detail": "Threshold: **{pct}%** (below this → correction or block)",
+      "target_tools": "Target tools: **{tools}**",
+      "timeout": "Timeout: **{ms}ms**",
+      "status_on_hint": "🔍 `/crsi critique on` — Enable self-critique",
+      "status_off_hint": "🔍 `/crsi critique off` — Disable self-critique",
+      "inspired": "*Inspired by Anthropic RLAIF — AI critiques its own actions before execution.*"
+    },
+    "crsi_interpret": {
+      "title": "## 🧠 CRSI Tool-Call Interpretability",
+      "no_sigs_for_tool": "No error signatures for tool `{tool}`. CRSI immune memory is clean for this tool.",
+      "no_sigs": "No active error signatures. CRSI immune memory is clean.",
+      "sigs_title": "### 🛡️ Error Signatures{tool}",
+      "sig_success": "  Success: {bar} {pct}% | {occurrences}x | {strategy}",
+      "sig_fix": "  Fix: `{fix}`",
+      "sigs_more": "... and {count} more signatures",
+      "reflection_title": "### 📊 CRSI Reflection Summary",
+      "reflections": "Turn reflections analyzed: **{count}**",
+      "usage_title": "### 💰 Token Usage",
+      "api_in": "API input tokens:  {count}",
+      "api_out": "API output tokens: {count}",
+      "est_tokens": "Estimated tokens:  {count}",
+      "health_title": "### 🏥 System Health",
+      "overall": "Overall: {bar} **{score}/100**",
+      "assessment": "Assessment: {assessment}",
+      "constitution_title": "### ⚖️ Constitution",
+      "principles": "Principles: **{total}** (🚫 {block} block | ⚠️ {warn} warn | 🔄 {auto} auto)",
+      "version": "Version: v{version}",
+      "empty": "_Start using tools to populate CRSI interpretability data._",
+      "filter_hint": "🔍 Filter by tool: `/crsi interpret <tool-name>` (e.g. `/crsi interpret Bash`)"
+    },
+    "crsi_red_team": {
+      "not_init": "Red-Team requires both ConstitutionLoader and PreFlightChecker to be initialized.",
+      "title": "## 🔴 CRSI Red-Team Report",
+      "score": "Overall Score: **{score}/100**",
+      "metric": "| Metric | Count |",
+      "metric_sep": "|--------|------|",
+      "total_attacks": "| Total attacks | {count} |",
+      "blocked": "| 🛡️ Correctly blocked | {count} |",
+      "passed_through": "| 🔴 Passed through (GAP) | {count} |",
+      "false_positives": "| ⚠️ False positives | {count} |",
+      "by_principle": "### By Principle",
+      "gaps_title": "### 🔴 Security Gaps (Should Have Been Blocked)",
+      "gap_tool": "  Tool: `{tool}` → Params: `{params}`",
+      "blocked_title": "### 🛡️ Successfully Blocked",
+      "caught_by": "{principle}: {desc} → caught by **{caught}**",
+      "all_blocked": "🎉 **All attacks blocked!** The SIS immune system is fully operational.",
+      "good_coverage": "⚠️ Good coverage. Review the gaps above and add audit patterns to `ai-guardrails.yml`.",
+      "critical": "🔴 **Critical gaps detected.** Prioritize fixing the passed-through attacks above."
+    },
+    "dream": {
+      "not_init": "DreamEngine not initialized. Mipham Code >= v0.34.0 required.",
+      "no_history": "🌙 Auto-Dream has not run yet. Use `/dream` to trigger the first consolidation.",
+      "history_title": "## 🌙 Auto-Dream History",
+      "history_entry": "- **{time}**: {total} actions ({applied} auto-applied, {flagged} flagged for review)",
+      "done_title": "## 🌙 Auto-Dream Complete",
+      "integrate": "Memory integration: {before} → {after}",
+      "dedup": "- Deduplicated: {count} entries",
+      "contradiction": "- Contradictions: {count} (need human review)",
+      "merge": "- Merged: {count} groups",
+      "solidify": "- Fuzzy-marked: {count} entries (suggested to solidify)",
+      "prune": "- Pruned expired: {count} entries",
+      "review_hint": "⚠️  {count} items pending review. Use `/dream --aggressive` to auto-apply all.",
+      "clean": "✅ Memory is clean, nothing to consolidate."
+    },
+    "constitution": {
+      "not_init": "ConstitutionLoader not initialized. Mipham Code >= v0.34.0 required.",
+      "reload_title": "## ⚖️ Constitution Reloaded",
+      "version": "Version: **v{version}**",
+      "principles": "Principles: **{count}**",
+      "path": "Path: `{path}`",
+      "view_title": "## ⚖️ Mipham Constitution",
+      "view_summary": "Version: **v{version}** | Principles: **{count}** | Path: `{path}`",
+      "scope": "  Scope: `{scope}`",
+      "tools": "  Tools: {tools}",
+      "reload_hint": "🔧 `/constitution reload` — Reload after editing ai-guardrails.yml",
+      "edit_hint": "📝 Edit: `vi ~/.mipham/ai-guardrails.yml`",
+      "reset_hint": "🗑️  Reset: delete `~/.mipham/ai-guardrails.yml` then run `/constitution reload`",
+      "inspired": "*Inspired by Anthropic Constitutional AI. Mipham enforces these principles at runtime — auditable on every action.*"
+    },
+    "bug_report": {
+      "title": "## 🐛 Bug Report",
+      "hint": "> Copy the report below and paste it into your GitHub Issue.",
+      "env_title": "### Environment",
+      "mipham": "- **Mipham Code**: v{version}",
+      "session": "- **Session**: {id}",
+      "node": "- **Node**: {version}",
+      "platform": "- **Platform**: {platform} {arch}",
+      "os": "- **OS**: {os}",
+      "provider": "- **Provider**: {provider}",
+      "model": "- **Model**: {model}",
+      "sigs_title": "### Active Error Signatures",
+      "sig_entry": "- `{id}`: {pattern} ({category}, {occurrences}x, {pct}% success)",
+      "disabled_hooks": "### Disabled Hooks",
+      "hook_entry": "- `{key}`: {failures} failures, disabled at {time}",
+      "last_dream": "### Last Auto-Dream",
+      "ran_at": "- **Ran at**: {time}",
+      "actions": "- **Actions**: {total} ({applied} applied)",
+      "steps_title": "### Steps to Reproduce",
+      "expected": "### Expected Behavior",
+      "actual": "### Actual Behavior",
+      "generated": "🤖 Generated with Mipham Code v{version}"
+    },
+    "changelog": {
+      "title": "## 📋 Changelog",
+      "no_tags": "No version tags found.",
+      "current": "Current: **v{version}**",
+      "current_marker": " ← current",
+      "release_only": "  _(release tag only)_",
+      "details_unavailable": "  _(details unavailable)_",
+      "no_git": "Unable to read git history. Make sure you are in the Mipham Code repository.",
+      "full_history": "Full history: `git log --oneline`"
     }
   },
   "ui": {