@hienlh/ppm 0.9.30 → 0.9.32

package/src/services/clawbot/clawbot-service.ts

@@ -0,0 +1,500 @@
+import { configService } from "../config.service.ts";
+import { chatService } from "../chat.service.ts";
+import {
+  isPairedChat,
+  getPairingByChatId,
+  createPairingRequest,
+  approvePairing,
+} from "../db.service.ts";
+import { ClawBotTelegram } from "./clawbot-telegram.ts";
+import { ClawBotSessionManager } from "./clawbot-session.ts";
+import { ClawBotMemory } from "./clawbot-memory.ts";
+import { streamToTelegram } from "./clawbot-streamer.ts";
+import { escapeHtml } from "./clawbot-formatter.ts";
+import type { TelegramUpdate, ClawBotCommand } from "../../types/clawbot.ts";
+import type { ClawBotConfig, TelegramConfig, PermissionMode } from "../../types/config.ts";
+import type { SendMessageOpts } from "../../types/chat.ts";
+
+const CONTEXT_WINDOW_THRESHOLD = 80;
+
+class ClawBotService {
+  private telegram: ClawBotTelegram | null = null;
+  private sessions = new ClawBotSessionManager();
+  private memory = new ClawBotMemory();
+  private running = false;
+
+  /** Debounce timers per chatId */
+  private debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
+  private debouncedTexts = new Map<string, string>();
+
+  /** Processing lock per chatId */
+  private processing = new Set<string>();
+
+  /** Message queue per chatId for concurrent messages */
+  private messageQueue = new Map<string, string[]>();
+
+  /** Sessions that already had their title set */
+  private titledSessions = new Set<string>();
+
+  // ── Lifecycle ─────────────────────────────────────────────────
+
+  async start(): Promise<void> {
+    const clawbotConfig = this.getConfig();
+    if (!clawbotConfig?.enabled) {
+      console.log("[clawbot] Disabled in config");
+      return;
+    }
+
+    const telegramConfig = configService.get("telegram") as TelegramConfig | undefined;
+    if (!telegramConfig?.bot_token) {
+      console.log("[clawbot] No bot token configured");
+      return;
+    }
+
+    try {
+      this.telegram = new ClawBotTelegram(telegramConfig.bot_token);
+      this.running = true;
+
+      // Run memory decay on startup
+      this.memory.runDecay();
+
+      // Start polling (non-blocking)
+      this.telegram.startPolling((update) => this.handleUpdate(update));
+
+      console.log("[clawbot] Started");
+    } catch (err) {
+      console.error("[clawbot] Start failed:", (err as Error).message);
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+    this.telegram?.stop();
+    this.telegram = null;
+
+    for (const timer of this.debounceTimers.values()) clearTimeout(timer);
+    this.debounceTimers.clear();
+    this.debouncedTexts.clear();
+    this.processing.clear();
+    this.messageQueue.clear();
+
+    console.log("[clawbot] Stopped");
+  }
+
+  get isRunning(): boolean {
+    return this.running;
+  }
+
+  /** Notify user on Telegram that their pairing was approved */
+  async notifyPairingApproved(chatId: string): Promise<void> {
+    await this.telegram?.sendMessage(
+      Number(chatId),
+      "✅ Pairing approved! You can now chat with ClawBot.\n\nSend /start to begin.",
+    );
+  }
+
+  // ── Update Routing ──────────────────────────────────────────────
+
+  private async handleUpdate(update: TelegramUpdate): Promise<void> {
+    if (!this.telegram) return;
+    const message = update.message;
+    if (!message?.chat?.id) return;
+
+    const chatId = String(message.chat.id);
+    const userId = message.from?.id ?? 0;
+    const displayName = message.from?.first_name ?? message.from?.username ?? "Unknown";
+
+    // Pairing-based access control
+    if (!isPairedChat(chatId)) {
+      const pairing = getPairingByChatId(chatId);
+      if (!pairing) {
+        // First-time user — generate pairing code
+        const code = this.generatePairingCode();
+        createPairingRequest(chatId, String(userId), displayName, code);
+        await this.telegram!.sendMessage(
+          Number(chatId),
+          `🔐 Pairing required.\n\nYour pairing code: <code>${code}</code>\n\nEnter this code in PPM Settings → ClawBot → Pair Device to approve access.`,
+        );
+        return;
+      }
+      if (pairing.status === "pending") {
+        await this.telegram!.sendMessage(
+          Number(chatId),
+          `⏳ Pairing pending approval.\n\nCode: <code>${pairing.pairing_code}</code>\nAsk the PPM owner to approve in Settings → ClawBot.`,
+        );
+        return;
+      }
+      if (pairing.status === "revoked") {
+        return; // Silently ignore
+      }
+    }
+
+    // Try parsing as command
+    const command = ClawBotTelegram.parseCommand(message);
+    if (command) {
+      await this.handleCommand(command);
+      return;
+    }
+
+    // Regular message
+    const text = message.text ?? message.caption ?? "";
+    if (!text.trim()) return;
+
+    await this.handleMessage(chatId, text);
+  }
+
+  // ── Command Handlers ────────────────────────────────────────────
+
+  private async handleCommand(cmd: ClawBotCommand): Promise<void> {
+    const chatId = String(cmd.chatId);
+    const tg = this.telegram!;
+
+    try {
+      switch (cmd.command) {
+        case "start": await this.cmdStart(chatId); break;
+        case "project": await this.cmdProject(chatId, cmd.args); break;
+        case "new": await this.cmdNew(chatId); break;
+        case "sessions": await this.cmdSessions(chatId); break;
+        case "resume": await this.cmdResume(chatId, cmd.args); break;
+        case "status": await this.cmdStatus(chatId); break;
+        case "stop": await this.cmdStop(chatId); break;
+        case "memory": await this.cmdMemory(chatId); break;
+        case "forget": await this.cmdForget(chatId, cmd.args); break;
+        case "remember": await this.cmdRemember(chatId, cmd.args); break;
+        case "help": await this.cmdHelp(chatId); break;
+        default: await tg.sendMessage(Number(chatId), `Unknown command: /${cmd.command}`);
+      }
+    } catch (err) {
+      await tg.sendMessage(
+        Number(chatId),
+        `❌ Command error: ${escapeHtml((err as Error).message)}`,
+      );
+    }
+  }
+
+  private async cmdStart(chatId: string): Promise<void> {
+    const projects = this.sessions.getProjectNames();
+    let text = "<b>🤖 ClawBot</b>\n\nI'm your PPM assistant on Telegram.\n\n";
+    if (projects.length) {
+      text += "<b>Available projects:</b>\n";
+      for (const name of projects) {
+        text += `• <code>${escapeHtml(name)}</code>\n`;
+      }
+      text += "\nSwitch project: /project &lt;name&gt;";
+    } else {
+      text += "No projects configured. Add projects in PPM settings.";
+    }
+    text += "\n\nSend /help for all commands.";
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  private async cmdProject(chatId: string, args: string): Promise<void> {
+    if (!args) {
+      const active = this.sessions.getActiveSession(chatId);
+      const current = active?.projectName ?? "(none)";
+      await this.telegram!.sendMessage(
+        Number(chatId),
+        `Current project: <b>${escapeHtml(current)}</b>\n\nUsage: /project &lt;name&gt;`,
+      );
+      return;
+    }
+
+    await this.saveSessionMemory(chatId);
+    const session = await this.sessions.switchProject(chatId, args);
+    await this.telegram!.sendMessage(
+      Number(chatId),
+      `Switched to <b>${escapeHtml(session.projectName)}</b> ✓`,
+    );
+  }
+
+  private async cmdNew(chatId: string): Promise<void> {
+    await this.saveSessionMemory(chatId);
+    const active = this.sessions.getActiveSession(chatId);
+    const projectName = active?.projectName;
+    await this.sessions.closeSession(chatId);
+    const session = await this.sessions.getOrCreateSession(chatId, projectName ?? undefined);
+    await this.telegram!.sendMessage(
+      Number(chatId),
+      `New session for <b>${escapeHtml(session.projectName)}</b> ✓`,
+    );
+  }
+
+  private async cmdSessions(chatId: string): Promise<void> {
+    const sessions = this.sessions.listRecentSessions(chatId, 10);
+    if (sessions.length === 0) {
+      await this.telegram!.sendMessage(Number(chatId), "No recent sessions.");
+      return;
+    }
+    let text = "<b>Recent Sessions</b>\n\n";
+    sessions.forEach((s, i) => {
+      const active = s.is_active ? " ⬤" : "";
+      const date = new Date(s.last_message_at * 1000).toLocaleDateString();
+      text += `${i + 1}. <code>${escapeHtml(s.project_name)}</code> — ${date}${active}\n`;
+    });
+    text += "\nResume: /resume &lt;number&gt;";
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  private async cmdResume(chatId: string, args: string): Promise<void> {
+    const index = parseInt(args, 10);
+    if (!index || index < 1) {
+      await this.telegram!.sendMessage(Number(chatId), "Usage: /resume &lt;number&gt;");
+      return;
+    }
+    await this.saveSessionMemory(chatId);
+    const session = await this.sessions.resumeSessionById(chatId, index);
+    if (!session) {
+      await this.telegram!.sendMessage(Number(chatId), "Session not found.");
+      return;
+    }
+    await this.telegram!.sendMessage(
+      Number(chatId),
+      `Resumed session for <b>${escapeHtml(session.projectName)}</b> ✓`,
+    );
+  }
+
+  private async cmdStatus(chatId: string): Promise<void> {
+    const active = this.sessions.getActiveSession(chatId);
+    if (!active) {
+      await this.telegram!.sendMessage(Number(chatId), "No active session. Send a message to start.");
+      return;
+    }
+    let text = "<b>Status</b>\n\n";
+    text += `Project: <code>${escapeHtml(active.projectName)}</code>\n`;
+    text += `Provider: <code>${escapeHtml(active.providerId)}</code>\n`;
+    text += `Session: <code>${active.sessionId.slice(0, 12)}…</code>\n`;
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  private async cmdStop(chatId: string): Promise<void> {
+    await this.saveSessionMemory(chatId);
+    await this.sessions.closeSession(chatId);
+    await this.telegram!.sendMessage(Number(chatId), "Session ended ✓");
+  }
+
+  private async cmdMemory(chatId: string): Promise<void> {
+    const active = this.sessions.getActiveSession(chatId);
+    const project = active?.projectName ?? "_global";
+    const memories = this.memory.getSummary(project);
+    if (memories.length === 0) {
+      await this.telegram!.sendMessage(Number(chatId), "No memories stored for this project.");
+      return;
+    }
+    let text = `<b>Memory — ${escapeHtml(project)}</b>\n\n`;
+    for (const mem of memories) {
+      text += `• [${mem.category}] ${escapeHtml(mem.content)}\n`;
+    }
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  private async cmdForget(chatId: string, args: string): Promise<void> {
+    if (!args) {
+      await this.telegram!.sendMessage(Number(chatId), "Usage: /forget &lt;topic&gt;");
+      return;
+    }
+    const active = this.sessions.getActiveSession(chatId);
+    const project = active?.projectName ?? "_global";
+    const count = this.memory.forget(project, args);
+    await this.telegram!.sendMessage(Number(chatId), `Forgot ${count} memor${count === 1 ? "y" : "ies"} ✓`);
+  }
+
+  private async cmdRemember(chatId: string, args: string): Promise<void> {
+    if (!args) {
+      await this.telegram!.sendMessage(Number(chatId), "Usage: /remember &lt;fact&gt;");
+      return;
+    }
+    const active = this.sessions.getActiveSession(chatId);
+    const project = active?.projectName ?? "_global";
+    this.memory.saveOne(project, args, "fact", active?.sessionId);
+    await this.telegram!.sendMessage(Number(chatId), "Remembered ✓");
+  }
+
+  private async cmdHelp(chatId: string): Promise<void> {
+    const text = `<b>ClawBot Commands</b>
+
+/start — Greeting + list projects
+/project &lt;name&gt; — Switch project
+/new — Fresh session (current project)
+/sessions — List recent sessions
+/resume &lt;n&gt; — Resume session #n
+/status — Current project/session info
+/stop — End current session
+/memory — Show project memories
+/forget &lt;topic&gt; — Remove matching memories
+/remember &lt;fact&gt; — Save a fact
+/help — This message`;
+    await this.telegram!.sendMessage(Number(chatId), text);
+  }
+
+  // ── Chat Message Pipeline ───────────────────────────────────────
+
+  private async handleMessage(chatId: string, text: string): Promise<void> {
+    const config = this.getConfig();
+    const debounceMs = config?.debounce_ms ?? 2000;
+
+    const existing = this.debouncedTexts.get(chatId) ?? "";
+    const merged = existing ? `${existing}\n${text}` : text;
+    this.debouncedTexts.set(chatId, merged.length > 10000 ? merged.slice(0, 10000) : merged);
+
+    const prevTimer = this.debounceTimers.get(chatId);
+    if (prevTimer) clearTimeout(prevTimer);
+
+    this.debounceTimers.set(
+      chatId,
+      setTimeout(() => this.processMessage(chatId), debounceMs),
+    );
+  }
+
+  private async processMessage(chatId: string): Promise<void> {
+    this.debounceTimers.delete(chatId);
+    const text = this.debouncedTexts.get(chatId) ?? "";
+    this.debouncedTexts.delete(chatId);
+    if (!text.trim()) return;
+
+    // Queue if already processing
+    if (this.processing.has(chatId)) {
+      const queue = this.messageQueue.get(chatId) ?? [];
+      queue.push(text);
+      this.messageQueue.set(chatId, queue);
+      return;
+    }
+    this.processing.add(chatId);
+
+    try {
+      const config = this.getConfig();
+
+      const session = await this.sessions.getOrCreateSession(chatId);
+
+      // Update title on first message only
+      if (!this.titledSessions.has(session.sessionId)) {
+        this.sessions.updateSessionTitle(session.sessionId, text);
+        this.titledSessions.add(session.sessionId);
+      }
+
+      // Recall memories (with cross-project detection)
+      const memories = this.memory.recallWithCrossProject(
+        session.projectName,
+        text,
+        text,
+      );
+
+      // Build system prompt with memory
+      let systemPrompt = config?.system_prompt ?? "";
+      const memorySection = this.memory.buildRecallPrompt(memories);
+      if (memorySection) {
+        systemPrompt += memorySection;
+      }
+
+      // Send message to AI (prepend system prompt + memory context)
+      const opts: SendMessageOpts = {
+        permissionMode: (config?.permission_mode ?? "bypassPermissions") as PermissionMode,
+      };
+
+      let fullMessage = text;
+      if (systemPrompt) {
+        fullMessage = `<system-context>\n${systemPrompt}\n</system-context>\n\n${text}`;
+      }
+
+      const events = chatService.sendMessage(
+        session.providerId,
+        session.sessionId,
+        fullMessage,
+        opts,
+      );
+
+      // Stream response to Telegram
+      const result = await streamToTelegram(
+        Number(chatId),
+        events,
+        this.telegram!,
+        {
+          showToolCalls: config?.show_tool_calls ?? true,
+          showThinking: config?.show_thinking ?? false,
+        },
+      );
+
+      // Check context window — auto-rotate if near limit
+      if (
+        result.contextWindowPct != null &&
+        result.contextWindowPct > CONTEXT_WINDOW_THRESHOLD
+      ) {
+        await this.rotateSession(chatId, session.projectName);
+      }
+    } catch (err) {
+      console.error(`[clawbot] processMessage error for ${chatId}:`, (err as Error).message);
+      await this.telegram?.sendMessage(
+        Number(chatId),
+        `❌ ${escapeHtml((err as Error).message)}`,
+      );
+    } finally {
+      this.processing.delete(chatId);
+
+      // Process queued messages
+      const queued = this.messageQueue.get(chatId);
+      if (queued && queued.length > 0) {
+        this.messageQueue.delete(chatId);
+        const merged = queued.join("\n\n");
+        this.handleMessage(chatId, merged);
+      }
+    }
+  }
+
+  // ── Memory Save / Session Rotate ────────────────────────────────
+
+  private async saveSessionMemory(chatId: string): Promise<void> {
+    const session = this.sessions.getActiveSession(chatId);
+    if (!session) return;
+
+    try {
+      const extractionPrompt = this.memory.buildExtractionPrompt();
+      const events = chatService.sendMessage(
+        session.providerId,
+        session.sessionId,
+        extractionPrompt,
+        { permissionMode: "bypassPermissions" },
+      );
+
+      let responseText = "";
+      for await (const event of events) {
+        if (event.type === "text") responseText += event.content;
+      }
+
+      const facts = this.memory.parseExtractionResponse(responseText);
+      if (facts.length > 0) {
+        const count = this.memory.save(session.projectName, facts, session.sessionId);
+        console.log(`[clawbot] Saved ${count} memories for ${session.projectName}`);
+      } else {
+        // Fallback: regex-based extraction
+        // Note: we don't have conversation history text here easily,
+        // so regex fallback only triggers when AI extraction fails
+        console.log("[clawbot] No memories extracted via AI");
+      }
+    } catch (err) {
+      console.warn("[clawbot] Memory save failed:", (err as Error).message);
+    }
+  }
+
+  private async rotateSession(chatId: string, projectName: string): Promise<void> {
+    await this.saveSessionMemory(chatId);
+    await this.sessions.closeSession(chatId);
+    await this.sessions.getOrCreateSession(chatId, projectName);
+    await this.telegram?.sendMessage(
+      Number(chatId),
+      "<i>Context window near limit — starting fresh session. Memories saved.</i>",
+    );
+  }
+
+  // ── Helpers ─────────────────────────────────────────────────────
+
+  private generatePairingCode(): string {
+    const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"; // no I,O,0,1 (ambiguous)
+    const bytes = crypto.getRandomValues(new Uint8Array(6));
+    return Array.from(bytes, (b) => chars[b % chars.length]).join("");
+  }
+
+  private getConfig(): ClawBotConfig | undefined {
+    return configService.get("clawbot") as ClawBotConfig | undefined;
+  }
+}
+
+export const clawbotService = new ClawBotService();

package/src/services/clawbot/clawbot-session.ts

@@ -0,0 +1,188 @@
+import { chatService } from "../chat.service.ts";
+import { configService } from "../config.service.ts";
+import {
+  getActiveClawBotSession,
+  createClawBotSession,
+  deactivateClawBotSession,
+  touchClawBotSession,
+  getRecentClawBotSessions,
+  setSessionTitle,
+} from "../db.service.ts";
+import type { ClawBotActiveSession, ClawBotSessionRow } from "../../types/clawbot.ts";
+import type { ClawBotConfig, ProjectConfig } from "../../types/config.ts";
+
+export class ClawBotSessionManager {
+  /** In-memory cache: telegramChatId → active session */
+  private activeSessions = new Map<string, ClawBotActiveSession>();
+
+  /**
+   * Get active session for chatId. If none exists, create one for the
+   * given project (or default project from config).
+   */
+  async getOrCreateSession(
+    chatId: string,
+    projectName?: string,
+  ): Promise<ClawBotActiveSession> {
+    const cached = this.activeSessions.get(chatId);
+    if (cached && (!projectName || cached.projectName === projectName)) {
+      touchClawBotSession(cached.sessionId);
+      return cached;
+    }
+
+    const resolvedProject = this.resolveProject(
+      projectName || this.getDefaultProject(),
+    );
+    if (!resolvedProject) {
+      throw new Error(`Project not found: "${projectName || "(default)"}"`);
+    }
+
+    const dbSession = getActiveClawBotSession(chatId, resolvedProject.name);
+    if (dbSession) {
+      return this.resumeFromDb(chatId, dbSession, resolvedProject);
+    }
+
+    return this.createNewSession(chatId, resolvedProject);
+  }
+
+  /** Switch to a different project. Deactivates current session. */
+  async switchProject(
+    chatId: string,
+    projectName: string,
+  ): Promise<ClawBotActiveSession> {
+    await this.closeSession(chatId);
+    return this.getOrCreateSession(chatId, projectName);
+  }
+
+  /** Close (deactivate) the current session for a chatId */
+  async closeSession(chatId: string): Promise<void> {
+    const active = this.activeSessions.get(chatId);
+    if (active) {
+      deactivateClawBotSession(active.sessionId);
+      this.activeSessions.delete(chatId);
+    }
+  }
+
+  /** Get active session from cache (no DB hit) */
+  getActiveSession(chatId: string): ClawBotActiveSession | null {
+    return this.activeSessions.get(chatId) ?? null;
+  }
+
+  /** List recent sessions for a chat (from DB) */
+  listRecentSessions(chatId: string, limit = 10): ClawBotSessionRow[] {
+    return getRecentClawBotSessions(chatId, limit);
+  }
+
+  /** Resume a specific session by 1-indexed position in history */
+  async resumeSessionById(
+    chatId: string,
+    sessionIndex: number,
+  ): Promise<ClawBotActiveSession | null> {
+    const sessions = getRecentClawBotSessions(chatId, 20);
+    const target = sessions[sessionIndex - 1];
+    if (!target) return null;
+
+    await this.closeSession(chatId);
+
+    const project = this.resolveProject(target.project_name);
+    if (!project) return null;
+
+    return this.resumeFromDb(chatId, target, project);
+  }
+
+  /**
+   * Resolve a project name against configured projects.
+   * Case-insensitive, supports prefix matching.
+   */
+  resolveProject(input: string): { name: string; path: string } | null {
+    const projects = configService.get("projects") as ProjectConfig[];
+    if (!projects?.length) return null;
+
+    const lower = input.toLowerCase();
+
+    const exact = projects.find((p) => p.name.toLowerCase() === lower);
+    if (exact) return { name: exact.name, path: exact.path };
+
+    const prefix = projects.filter((p) => p.name.toLowerCase().startsWith(lower));
+    if (prefix.length === 1) return { name: prefix[0]!.name, path: prefix[0]!.path };
+
+    return null;
+  }
+
+  /** Update session title (e.g. after first message) */
+  updateSessionTitle(sessionId: string, firstMessage: string): void {
+    const preview = firstMessage.slice(0, 60).replace(/\n/g, " ");
+    const title = `[Claw] ${preview}`;
+    setSessionTitle(sessionId, title);
+  }
+
+  /** Get list of available project names (for /start greeting) */
+  getProjectNames(): string[] {
+    const projects = configService.get("projects") as ProjectConfig[];
+    return projects?.map((p) => p.name) ?? [];
+  }
+
+  // ── Private ─────────────────────────────────────────────────────
+
+  private getDefaultProject(): string {
+    const clawbot = configService.get("clawbot") as ClawBotConfig | undefined;
+    return clawbot?.default_project || "";
+  }
+
+  private getDefaultProvider(): string {
+    const clawbot = configService.get("clawbot") as ClawBotConfig | undefined;
+    return clawbot?.default_provider || configService.get("ai").default_provider;
+  }
+
+  private async createNewSession(
+    chatId: string,
+    project: { name: string; path: string },
+  ): Promise<ClawBotActiveSession> {
+    const providerId = this.getDefaultProvider();
+
+    const session = await chatService.createSession(providerId, {
+      projectName: project.name,
+      projectPath: project.path,
+      title: `[Claw] New session`,
+    });
+
+    createClawBotSession(chatId, session.id, providerId, project.name, project.path);
+
+    const active: ClawBotActiveSession = {
+      telegramChatId: chatId,
+      sessionId: session.id,
+      providerId,
+      projectName: project.name,
+      projectPath: project.path,
+    };
+
+    this.activeSessions.set(chatId, active);
+    return active;
+  }
+
+  private async resumeFromDb(
+    chatId: string,
+    dbSession: ClawBotSessionRow,
+    project: { name: string; path: string },
+  ): Promise<ClawBotActiveSession> {
+    try {
+      await chatService.resumeSession(dbSession.provider_id, dbSession.session_id);
+    } catch {
+      console.warn(`[clawbot] Failed to resume session ${dbSession.session_id}, creating new`);
+      deactivateClawBotSession(dbSession.session_id);
+      return this.createNewSession(chatId, project);
+    }
+
+    touchClawBotSession(dbSession.session_id);
+
+    const active: ClawBotActiveSession = {
+      telegramChatId: chatId,
+      sessionId: dbSession.session_id,
+      providerId: dbSession.provider_id,
+      projectName: project.name,
+      projectPath: project.path,
+    };
+
+    this.activeSessions.set(chatId, active);
+    return active;
+  }
+}