imtoagent 0.2.0

package/modules/core/error.ts

@@ -0,0 +1,124 @@
+// ================================================================
+// ErrorHandler — 错误处理策略
+// ================================================================
+// 统一管理后端调用错误，提供重试、降级、用户友好提示
+// ================================================================
+
+import type { ErrorAction, ErrorContext, ErrorHandler } from './types';
+
+// ================================================================
+// DefaultErrorHandler
+// ================================================================
+
+export class DefaultErrorHandler implements ErrorHandler {
+  /**
+   * 处理错误，返回处理动作
+   * 
+   * 策略：
+   * - 网络超时 → 自动重试 (最多 2 次)
+   * - 429 限流 → 等待后重试
+   * - 401 认证失败 → 直接返回用户提示
+   * - 5xx 服务端错误 → 重试
+   * - 其他 → 返回用户友好消息
+   */
+  async handle(chatId: string, error: Error, ctx: ErrorContext): Promise<ErrorAction> {
+    const errMsg = error.message || String(error);
+    const backend = ctx.backend;
+
+    console.error(`[Error] ${backend} 调用失败 (attempt ${ctx.attempt}): ${errMsg}`);
+
+    // 提取 HTTP 状态码
+    const statusCode = this.extractStatusCode(error);
+    const isTimeout = this.isTimeoutError(error);
+
+    // 重试策略
+    if (ctx.attempt < 2) {
+      // 网络超时、5xx → 重试
+      if (isTimeout || statusCode >= 500) {
+        console.log(`[Error] 将重试 ${backend} 调用 (${ctx.attempt + 1}/2)`);
+        return { type: 'retry', maxAttempts: 2 };
+      }
+
+      // 429 限流 → 重试
+      if (statusCode === 429) {
+        const retryAfter = this.extractRetryAfter(error);
+        if (retryAfter > 0) {
+          console.log(`[Error] 429 限流，等待 ${retryAfter}ms 后重试`);
+          await this.sleep(retryAfter);
+        }
+        return { type: 'retry', maxAttempts: 2 };
+      }
+    }
+
+    // 超过重试次数或不满足重试条件 → 返回用户提示
+    const userMessage = this.getUserMessage(error, backend, ctx.attempt);
+    return { type: 'reply', message: userMessage };
+  }
+
+  /** 从错误中提取 HTTP 状态码 */
+  private extractStatusCode(error: Error): number {
+    const msg = error.message || '';
+    const match = msg.match(/status[:\s]+(\d+)/i) || msg.match(/(\d{3})\s/);
+    if (match) return parseInt(match[1]);
+
+    // 尝试从 error 对象中获取
+    const anyErr = error as any;
+    if (anyErr?.status) return anyErr.status;
+    if (anyErr?.response?.status) return anyErr.response.status;
+    if (anyErr?.statusCode) return anyErr.statusCode;
+
+    return 0;
+  }
+
+  /** 判断是否为超时错误 */
+  private isTimeoutError(error: Error): boolean {
+    const msg = error.message.toLowerCase();
+    return msg.includes('timeout') || msg.includes('timed out') || msg.includes('etimedout')
+      || msg.includes('econnreset') || msg.includes('econnrefused')
+      || msg.includes('socket hang up') || msg.includes('network error');
+  }
+
+  /** 提取 Retry-After 毫秒数 */
+  private extractRetryAfter(error: Error): number {
+    const msg = error.message;
+    const match = msg.match(/retry[-_\s]?after[:\s]*(\d+)/i);
+    if (match) return parseInt(match[1]) * 1000;
+
+    const anyErr = error as any;
+    if (anyErr?.response?.headers?.['retry-after']) {
+      return parseInt(anyErr.response.headers['retry-after']) * 1000;
+    }
+
+    // 默认等待 2 秒
+    return 2000;
+  }
+
+  /** 生成用户友好的错误消息 */
+  private getUserMessage(error: Error, backend: string, attempt: number): string {
+    const statusCode = this.extractStatusCode(error);
+
+    if (statusCode === 401 || statusCode === 403) {
+      return `⚠️ ${backend} 后端认证失败，请联系管理员检查配置。`;
+    }
+
+    if (statusCode === 429) {
+      return `⚠️ 当前请求过于频繁，请稍后再试。`;
+    }
+
+    if (statusCode >= 500) {
+      return `⚠️ ${backend} 服务端暂时不可用，请稍后重试。`;
+    }
+
+    if (this.isTimeoutError(error)) {
+      return `⚠️ 请求超时，后端可能正在处理复杂任务。请稍后再试。`;
+    }
+
+    // 通用错误
+    const shortMsg = error.message.slice(0, 100);
+    return `⚠️ 处理消息时遇到错误：${shortMsg}`;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}

package/modules/core/index.ts

@@ -0,0 +1,39 @@
+// ================================================================
+// IMtoAgent SDK Core — 入口
+// ================================================================
+// SDK 核心模块统一导出
+// ================================================================
+
+// 类型
+export type {
+  CallStats,
+  Session,
+  AgentInput,
+  AgentOutput,
+  AgentAdapter,
+  MessageContext,
+  SessionManager,
+  ErrorHandler,
+  ConfigManager,
+  StatsTracker,
+  RuntimeConfig,
+  ErrorAction,
+  ErrorContext,
+  BotConfig,
+  ProviderConfig,
+} from './types';
+
+// Session 管理
+export { FileSessionManager } from './session';
+
+// 错误处理
+export { DefaultErrorHandler } from './error';
+
+// 统计追踪
+export { DefaultStatsTracker } from './stats';
+
+// 配置管理
+export { FileConfigManager } from './config';
+
+// 运行时
+export { AgentRuntime } from './runtime';

package/modules/core/runtime.ts

@@ -0,0 +1,282 @@
+// ================================================================
+// AgentRuntime — 消息处理中枢
+// ================================================================
+// 协调 Session / Stats / Error / Config，调用 Agent 适配器处理消息
+// 
+// processMessage 流程：
+//   1. 获取 session（通过 sessionManager.getOrCreate）
+//   2. 检查 startFresh → 清除旧 backendSessionId
+//   3. statsTracker.resetForCall()
+//   4. ctx.sendProgress("💭 思考中...")
+//   5. adapter.handleMessage(input) ← Agent 适配器
+//   6. 成功 → statsTracker.accumulate() + ctx.reply() 或 ctx.sendBlocks()
+//   7. 失败 → errorHandler.handle() → 可能 retry/fallback/reply
+//   8. sessionManager.persist()
+// ================================================================
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type {
+  AgentAdapter,
+  AgentInput,
+  AgentOutput,
+  MessageContext,
+  RuntimeConfig,
+  Session,
+  ErrorAction,
+  ErrorContext,
+} from './types';
+import { parseToBlocks } from '../capabilities';
+import { DEFAULT_TERMINAL_CAPS } from '../prompt-builder';
+
+// ================================================================
+// Agent 自主重启 — 文件信号（固定路径，不依赖 dataDir 参数）
+// ================================================================
+const RESTART_SIGNAL_PATH = path.join(process.env.HOME!, '.imtoagent', '.restart_requested');
+const RESTART_COOLDOWN_MS = 5 * 60 * 1000; // 5 分钟
+let lastRestartTime = 0;
+
+interface RestartSignal {
+  reason: string;
+  timestamp: number;
+  botName?: string;
+}
+
+/**
+ * 检测重启信号文件是否存在且包含有效内容。
+ */
+function checkRestartSignal(): { triggered: boolean; reason: string } {
+  try {
+    if (!fs.existsSync(RESTART_SIGNAL_PATH)) return { triggered: false, reason: '' };
+    const raw = fs.readFileSync(RESTART_SIGNAL_PATH, 'utf-8').trim();
+    let signal: RestartSignal;
+    try {
+      signal = JSON.parse(raw);
+    } catch {
+      // 兼容纯文本格式
+      signal = { reason: raw, timestamp: Date.now() };
+    }
+    return { triggered: true, reason: signal.reason || '未知原因' };
+  } catch {
+    return { triggered: false, reason: '' };
+  }
+}
+
+/**
+ * 消费重启信号：读取后删除文件，确保每次信号只触发一次重启。
+ */
+function consumeRestartSignal(): { triggered: boolean; reason: string } {
+  const result = checkRestartSignal();
+  if (result.triggered) {
+    try { fs.unlinkSync(RESTART_SIGNAL_PATH); } catch {}
+  }
+  return result;
+}
+
+// ================================================================
+// AgentRuntime
+// ================================================================
+
+export class AgentRuntime {
+  private adapters = new Map<string, AgentAdapter>();
+  private config: RuntimeConfig;
+
+  constructor(config: RuntimeConfig) {
+    this.config = config;
+  }
+
+  /**
+   * 注册 Agent 适配器
+   * @param backend 后端标识 ('claude' | 'codex' | 'opencode' 等)
+   * @param adapter Agent 适配器实例
+   */
+  registerAdapter(backend: string, adapter: AgentAdapter): void {
+    this.adapters.set(backend, adapter);
+    console.log(`[Runtime] 注册适配器: ${backend} → ${adapter.name}`);
+  }
+
+  /**
+   * 获取已注册的适配器
+   */
+  getAdapter(backend: string): AgentAdapter | undefined {
+    return this.adapters.get(backend);
+  }
+
+  /**
+   * 处理用户消息
+   * 
+   * @param ctx 消息处理上下文
+   * @param adapter Agent 适配器
+   * @param botName Bot 名称（用于 session 隔离）
+   * @returns 如果 Agent 请求重启，返回 { restart: true, reason }；否则返回 { restart: false }
+   */
+  async processMessage(
+    ctx: MessageContext,
+    adapter: AgentAdapter,
+    botName: string
+  ): Promise<{ restart: boolean; reason?: string }> {
+    const startTime = Date.now();
+    let attempt = 0;
+    const maxRetries = 2;
+
+    while (attempt <= maxRetries) {
+      attempt++;
+
+      try {
+        // 1. 获取 session
+        const session = await this.config.sessionManager.getOrCreate(
+          botName,
+          ctx.chatId,
+          ctx.userId
+        );
+
+        // 2. 检查 startFresh → 清除旧 backendSessionId
+        if (session.startFresh) {
+          session.backendSessionId = undefined;
+          session.metadata = {};
+          session.startFresh = false;
+          session.running = false;
+          console.log(`[Runtime] startFresh: 清除 ${ctx.chatId} 旧会话`);
+        }
+
+        // 3. 重置统计
+        this.config.statsTracker.resetForCall(session);
+
+        // 4. 发送进度提示
+        await ctx.sendProgress('💭 思考中...');
+
+        session.running = true;
+
+        // 5. 调用 Agent 适配器
+        const input: AgentInput = {
+          chatId: ctx.chatId,
+          text: ctx.text,
+          attachments: ctx.attachments,
+          session,
+          workingDir: ctx.workingDir,
+          systemPrompt: ctx.systemPrompt,
+          model: ctx.model,
+        };
+
+        const output = await adapter.handleMessage(input);
+
+        // 6. 处理成功结果
+        session.running = false;
+
+        if (output.error) {
+          throw new Error(output.error);
+        }
+
+        // 累加统计
+        if (output.usage) {
+          const duration = Date.now() - startTime;
+          this.config.statsTracker.accumulate(session, {
+            inputTokens: output.usage.inputTokens,
+            outputTokens: output.usage.outputTokens,
+            costUSD: output.usage.costUSD,
+            durationMs: output.usage.durationMs || duration,
+            numTurns: output.usage.numTurns,
+          });
+        }
+
+        // 发送回复 — 优先用 sendBlocks（parseToBlocks → 富文本渲染）
+        if (output.text) {
+          if (ctx.sendBlocks) {
+            const caps = ctx.imCaps || DEFAULT_TERMINAL_CAPS;
+            const blocks = parseToBlocks(output.text, caps);
+            if (blocks.length === 1 && blocks[0].type === 'text') {
+              await ctx.reply(output.text);
+            } else {
+              await ctx.sendBlocks(blocks);
+            }
+          } else {
+            await ctx.reply(output.text);
+          }
+        }
+
+        // 持久化 session
+        this.config.sessionManager.persist(botName, session);
+
+        // 检查 Agent 自主重启信号（在 reply 之后检测，确保消息已发送）
+        const signal = consumeRestartSignal();
+        if (signal.triggered) {
+          const now = Date.now();
+          if (now - lastRestartTime < RESTART_COOLDOWN_MS) {
+            const remaining = Math.ceil((RESTART_COOLDOWN_MS - (now - lastRestartTime)) / 1000);
+            console.log(`[Runtime] ⏳ Agent 请求重启被忽略（冷却中，${remaining}s 后重试）: ${signal.reason}`);
+          } else {
+            lastRestartTime = now;
+            console.log(`[Runtime] 🔄 Agent 请求重启: ${signal.reason}`);
+            return { restart: true, reason: signal.reason };
+          }
+        }
+
+        return { restart: false };
+
+      } catch (error: any) {
+        console.error(`[Runtime] 处理消息失败 (attempt ${attempt}): ${error.message}`);
+
+        // 7. 错误处理
+        const errorCtx: ErrorContext = {
+          chatId: ctx.chatId,
+          backend: adapter.name,
+          attempt,
+        };
+
+        const action = await this.config.errorHandler.handle(ctx.chatId, error, errorCtx);
+
+        if (action.type === 'retry') {
+          console.log(`[Runtime] 重试 ${adapter.name} 调用`);
+          continue;
+        }
+
+        if (action.type === 'fallback') {
+          console.log(`[Runtime] 降级到 ${action.adapter}`);
+          // Phase 2 实现 fallback 逻辑
+          const fallbackAdapter = this.adapters.get(action.adapter);
+          if (fallbackAdapter) {
+            return this.processMessage(ctx, fallbackAdapter, botName);
+          }
+        }
+
+        if (action.type === 'reply') {
+          await ctx.reply(action.message);
+        }
+
+        // 持久化 session（即使失败也要保存统计）
+        try {
+          const session = await this.config.sessionManager.getOrCreate(
+            botName,
+            ctx.chatId,
+            ctx.userId
+          );
+          session.running = false;
+          this.config.sessionManager.persist(botName, session);
+        } catch {}
+
+        return { restart: false }; // 不再重试
+      }
+    }
+  }
+
+  /**
+   * 取消正在进行的会话
+   */
+  async cancelSession(adapterName: string, sessionId: string): Promise<void> {
+    const adapter = this.adapters.get(adapterName);
+    if (adapter?.cancel) {
+      await adapter.cancel(sessionId);
+    }
+  }
+
+  /**
+   * 健康检查
+   */
+  async healthCheck(backend: string): Promise<boolean> {
+    const adapter = this.adapters.get(backend);
+    if (adapter?.healthCheck) {
+      return adapter.healthCheck();
+    }
+    return true; // 默认认为健康
+  }
+}

package/modules/core/session.ts

@@ -0,0 +1,256 @@
+// ================================================================
+// SessionManager — 会话生命周期管理
+// ================================================================
+// 从 index.ts 和 anthropic-proxy.ts 迁移 session 逻辑
+// 路径: ~/Desktop/imtoagent/sessions/{botName}/{chatId}.memory.json
+// ================================================================
+
+const fs = require('fs');
+const path = require('path');
+
+import type { Session, SessionManager, CallStats } from './types';
+import { getSessionsDir } from '../utils/paths';
+
+const SESSIONS_BASE = getSessionsDir();
+
+/** 默认统计值 */
+const EMPTY_STATS: CallStats = {
+  calls: 0,
+  totalTurns: 0,
+  totalInputTokens: 0,
+  totalOutputTokens: 0,
+  totalCostUSD: 0,
+  totalDurationMs: 0,
+};
+
+// ================================================================
+// 旧格式兼容
+// ================================================================
+
+/** 旧版 SessionData 格式（modules/types.ts 中的定义） */
+interface LegacySessionData {
+  chatId?: string;
+  userId: string;
+  sdkSessionId?: string;
+  codexThreadId?: string;
+  ocSessionId?: string;
+  cwd?: string;
+  permissionMode?: string;
+  codexMode?: string;
+  startFresh?: boolean;
+  stats: CallStats;
+  recentMessages: string[];
+  lastUsed: number;
+  activeModel?: string;
+  modelAliases?: Record<string, string>;
+}
+
+/**
+ * 从旧版 .memory.json 迁移为新版 Session 格式
+ * 保持向后兼容，不影响现有会话文件
+ */
+function migrateFromLegacy(data: LegacySessionData, chatId: string): Session {
+  const metadata: Record<string, any> = {};
+
+  // 迁移旧版特有 ID 到 metadata
+  if (data.sdkSessionId) metadata.sdkSessionId = data.sdkSessionId;
+  if (data.codexThreadId) metadata.codexThreadId = data.codexThreadId;
+  if (data.ocSessionId) metadata.ocSessionId = data.ocSessionId;
+
+  // 通用 backendSessionId 优先使用旧版中的值
+  const backendSessionId = data.sdkSessionId || data.codexThreadId || data.ocSessionId;
+
+  return {
+    chatId: data.chatId || chatId,
+    userId: data.userId,
+    cwd: data.cwd,
+    startFresh: data.startFresh || false,
+    backendSessionId,
+    metadata,
+    stats: data.stats || { ...EMPTY_STATS },
+    lastUsed: data.lastUsed || Date.now(),
+    running: false,
+    permissionMode: data.permissionMode,
+    codexMode: data.codexMode,
+    recentMessages: data.recentMessages || [],
+  };
+}
+
+// ================================================================
+// FileSessionManager
+// ================================================================
+
+export class FileSessionManager implements SessionManager {
+  /** 内存缓存: botName -> chatId -> Session */
+  private cache = new Map<string, Map<string, Session>>();
+
+  /** 获取 Session 文件路径 */
+  private sessionPath(botName: string, chatId: string): string {
+    const sessionsBase = getSessionsDir();
+    const botDir = path.join(sessionsBase, botName);
+    return path.join(botDir, `${chatId}.memory.json`);
+  }
+
+  /** 确保目录存在 */
+  private ensureDir(botName: string): void {
+    const sessionsBase = getSessionsDir();
+    const botDir = path.join(sessionsBase, botName);
+    if (!fs.existsSync(botDir)) {
+      fs.mkdirSync(botDir, { recursive: true });
+    }
+  }
+
+  async getOrCreate(botName: string, chatId: string, userId: string): Promise<Session> {
+    // 先查缓存
+    const botCache = this.cache.get(botName);
+    if (botCache) {
+      const cached = botCache.get(chatId);
+      if (cached) {
+        cached.lastUsed = Date.now();
+        return cached;
+      }
+    }
+
+    // 从文件加载
+    const filePath = this.sessionPath(botName, chatId);
+    this.ensureDir(botName);
+
+    let session: Session;
+
+    if (fs.existsSync(filePath)) {
+      try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(raw);
+
+        // 检测是否为旧格式（有 sdkSessionId/codexThreadId/ocSessionId 顶层字段）
+        if ('sdkSessionId' in data || 'codexThreadId' in data || 'ocSessionId' in data) {
+          session = migrateFromLegacy(data as LegacySessionData, chatId);
+        } else if ('metadata' in data && 'stats' in data && 'chatId' in data) {
+          // 新格式
+          session = {
+            ...data,
+            startFresh: data.startFresh || false,
+            running: data.running || false,
+            recentMessages: data.recentMessages || [],
+            stats: data.stats || { ...EMPTY_STATS },
+          };
+        } else {
+          // 未知格式，新建
+          session = this.createNewSession(chatId, userId);
+        }
+      } catch (e: any) {
+        console.error(`[Session] 加载 ${chatId} 失败: ${e.message}，创建新会话`);
+        session = this.createNewSession(chatId, userId);
+      }
+    } else {
+      session = this.createNewSession(chatId, userId);
+    }
+
+    // 缓存
+    if (!this.cache.has(botName)) {
+      this.cache.set(botName, new Map());
+    }
+    this.cache.get(botName)!.set(chatId, session);
+
+    return session;
+  }
+
+  private createNewSession(chatId: string, userId: string): Session {
+    return {
+      chatId,
+      userId,
+      cwd: undefined,
+      startFresh: false,
+      backendSessionId: undefined,
+      metadata: {},
+      stats: { ...EMPTY_STATS },
+      lastUsed: Date.now(),
+      running: false,
+      recentMessages: [],
+    };
+  }
+
+  persist(botName: string, session: Session): void {
+    this.ensureDir(botName);
+
+    // 写入时保持旧格式兼容：将 metadata 中的旧 ID 也写入顶层
+    const output: Record<string, any> = {
+      chatId: session.chatId,
+      userId: session.userId,
+      cwd: session.cwd,
+      startFresh: session.startFresh,
+      stats: session.stats,
+      lastUsed: session.lastUsed,
+      recentMessages: session.recentMessages || [],
+      running: session.running,
+    };
+
+    // 通用 backendSessionId
+    if (session.backendSessionId) {
+      output.backendSessionId = session.backendSessionId;
+    }
+
+    // 向后兼容：将 metadata 中的旧 ID 也写入顶层
+    if (session.metadata) {
+      if (session.metadata.sdkSessionId) output.sdkSessionId = session.metadata.sdkSessionId;
+      if (session.metadata.codexThreadId) output.codexThreadId = session.metadata.codexThreadId;
+      if (session.metadata.ocSessionId) output.ocSessionId = session.metadata.ocSessionId;
+      // permissionMode / codexMode 也放在顶层
+      if (session.permissionMode) output.permissionMode = session.permissionMode;
+      if (session.codexMode) output.codexMode = session.codexMode;
+    }
+
+    // metadata 完整保存
+    output.metadata = session.metadata;
+
+    const filePath = this.sessionPath(botName, session.chatId);
+    try {
+      fs.writeFileSync(filePath, JSON.stringify(output, null, 2));
+    } catch (e: any) {
+      console.error(`[Session] 持久化 ${session.chatId} 失败: ${e.message}`);
+    }
+  }
+
+  delete(botName: string, chatId: string): void {
+    // 清除缓存
+    const botCache = this.cache.get(botName);
+    if (botCache) {
+      botCache.delete(chatId);
+    }
+
+    // 删除文件
+    const filePath = this.sessionPath(botName, chatId);
+    try {
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (e: any) {
+      console.error(`[Session] 删除 ${chatId} 失败: ${e.message}`);
+    }
+  }
+
+  cleanupIdle(botName: string, timeoutMs: number): void {
+    const botCache = this.cache.get(botName);
+    if (!botCache) return;
+
+    const now = Date.now();
+    const toRemove: string[] = [];
+
+    for (const [chatId, session] of botCache) {
+      if (now - session.lastUsed > timeoutMs && !session.running) {
+        toRemove.push(chatId);
+      }
+    }
+
+    for (const chatId of toRemove) {
+      botCache.delete(chatId);
+      console.log(`[Session] 清理空闲会话: ${chatId}`);
+    }
+  }
+
+  listActive(botName: string): Session[] {
+    const botCache = this.cache.get(botName);
+    if (!botCache) return [];
+    return Array.from(botCache.values());
+  }
+}