@hienlh/ppm 0.9.30 → 0.9.32

package/src/services/db.service.ts

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { mkdirSync, existsSync } from "node:fs";
 
 const PPM_DIR = process.env.PPM_HOME || resolve(homedir(), ".ppm");
-const CURRENT_SCHEMA_VERSION = 12;
+const CURRENT_SCHEMA_VERSION = 13;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -313,6 +313,80 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 12;
     `);
   }
+
+  if (current < 13) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS clawbot_sessions (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        telegram_chat_id TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        provider_id TEXT NOT NULL DEFAULT 'claude',
+        project_name TEXT NOT NULL,
+        project_path TEXT NOT NULL,
+        is_active INTEGER NOT NULL DEFAULT 1,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        last_message_at INTEGER NOT NULL DEFAULT (unixepoch())
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_chat
+        ON clawbot_sessions(telegram_chat_id, is_active);
+      CREATE INDEX IF NOT EXISTS idx_clawbot_sessions_session
+        ON clawbot_sessions(session_id);
+
+      CREATE TABLE IF NOT EXISTS clawbot_memories (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project TEXT NOT NULL,
+        content TEXT NOT NULL,
+        category TEXT NOT NULL DEFAULT 'fact',
+        importance REAL NOT NULL DEFAULT 1.0,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        session_id TEXT,
+        superseded_by INTEGER REFERENCES clawbot_memories(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_project
+        ON clawbot_memories(project, superseded_by);
+      CREATE INDEX IF NOT EXISTS idx_clawbot_memories_importance
+        ON clawbot_memories(importance DESC);
+
+      CREATE VIRTUAL TABLE IF NOT EXISTS clawbot_memories_fts USING fts5(
+        content,
+        content='clawbot_memories',
+        content_rowid='id'
+      );
+
+      -- FTS5 sync triggers
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ai AFTER INSERT ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_ad AFTER DELETE ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS clawbot_memories_au AFTER UPDATE ON clawbot_memories BEGIN
+        INSERT INTO clawbot_memories_fts(clawbot_memories_fts, rowid, content) VALUES('delete', old.id, old.content);
+        INSERT INTO clawbot_memories_fts(rowid, content) VALUES (new.id, new.content);
+      END;
+
+      CREATE TABLE IF NOT EXISTS clawbot_paired_chats (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        telegram_chat_id TEXT NOT NULL UNIQUE,
+        telegram_user_id TEXT,
+        display_name TEXT,
+        pairing_code TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        approved_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_clawbot_paired_status
+        ON clawbot_paired_chats(status);
+
+      PRAGMA user_version = 13;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -894,5 +968,209 @@ export function deleteExtensionStorage(extId: string): void {
   getDb().query("DELETE FROM extension_storage WHERE ext_id = ?").run(extId);
 }
 
+// ---------------------------------------------------------------------------
+// ClawBot session helpers
+// ---------------------------------------------------------------------------
+
+import type { ClawBotSessionRow, ClawBotMemoryRow, ClawBotPairedChat } from "../types/clawbot.ts";
+
+export function getActiveClawBotSession(
+  telegramChatId: string,
+  projectName: string,
+): ClawBotSessionRow | null {
+  return getDb().query(
+    `SELECT * FROM clawbot_sessions
+     WHERE telegram_chat_id = ? AND project_name = ? AND is_active = 1
+     ORDER BY last_message_at DESC LIMIT 1`,
+  ).get(telegramChatId, projectName) as ClawBotSessionRow | null;
+}
+
+export function createClawBotSession(
+  telegramChatId: string,
+  sessionId: string,
+  providerId: string,
+  projectName: string,
+  projectPath: string,
+): void {
+  getDb().query(
+    `INSERT INTO clawbot_sessions
+     (telegram_chat_id, session_id, provider_id, project_name, project_path)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(telegramChatId, sessionId, providerId, projectName, projectPath);
+}
+
+export function deactivateClawBotSession(sessionId: string): void {
+  getDb().query(
+    "UPDATE clawbot_sessions SET is_active = 0 WHERE session_id = ?",
+  ).run(sessionId);
+}
+
+export function touchClawBotSession(sessionId: string): void {
+  getDb().query(
+    "UPDATE clawbot_sessions SET last_message_at = unixepoch() WHERE session_id = ?",
+  ).run(sessionId);
+}
+
+export function getRecentClawBotSessions(
+  telegramChatId: string,
+  limit = 10,
+): ClawBotSessionRow[] {
+  return getDb().query(
+    `SELECT * FROM clawbot_sessions
+     WHERE telegram_chat_id = ?
+     ORDER BY last_message_at DESC LIMIT ?`,
+  ).all(telegramChatId, limit) as ClawBotSessionRow[];
+}
+
+// ---------------------------------------------------------------------------
+// ClawBot memory helpers
+// ---------------------------------------------------------------------------
+
+export function insertClawBotMemory(
+  project: string,
+  content: string,
+  category: string,
+  importance: number,
+  sessionId?: string,
+): number {
+  const result = getDb().query(
+    `INSERT INTO clawbot_memories (project, content, category, importance, session_id)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(project, content, category, importance, sessionId ?? null);
+  return Number(result.lastInsertRowid);
+}
+
+export function searchClawBotMemories(
+  project: string,
+  query: string,
+  limit = 20,
+): Array<ClawBotMemoryRow & { rank: number }> {
+  return getDb().query(
+    `SELECT m.*, fts.rank
+     FROM clawbot_memories m
+     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
+     WHERE clawbot_memories_fts MATCH ?
+       AND m.project IN (?, '_global')
+       AND m.superseded_by IS NULL
+     ORDER BY fts.rank
+     LIMIT ?`,
+  ).all(query, project, limit) as Array<ClawBotMemoryRow & { rank: number }>;
+}
+
+export function getClawBotMemories(
+  project: string,
+  limit = 20,
+): ClawBotMemoryRow[] {
+  return getDb().query(
+    `SELECT * FROM clawbot_memories
+     WHERE project IN (?, '_global')
+       AND superseded_by IS NULL
+     ORDER BY importance DESC, updated_at DESC
+     LIMIT ?`,
+  ).all(project, limit) as ClawBotMemoryRow[];
+}
+
+export function supersedeClawBotMemory(
+  oldId: number,
+  newId: number,
+): void {
+  getDb().query(
+    "UPDATE clawbot_memories SET superseded_by = ? WHERE id = ?",
+  ).run(newId, oldId);
+}
+
+export function deleteClawBotMemoriesByTopic(
+  project: string,
+  topic: string,
+): number {
+  const matches = getDb().query(
+    `SELECT m.id FROM clawbot_memories m
+     JOIN clawbot_memories_fts fts ON m.id = fts.rowid
+     WHERE clawbot_memories_fts MATCH ?
+       AND m.project IN (?, '_global')
+       AND m.superseded_by IS NULL`,
+  ).all(topic, project) as { id: number }[];
+
+  for (const row of matches) {
+    getDb().query("DELETE FROM clawbot_memories WHERE id = ?").run(row.id);
+  }
+  return matches.length;
+}
+
+export function decayClawBotMemories(): void {
+  getDb().query(
+    `UPDATE clawbot_memories
+     SET importance = importance * 0.95,
+         updated_at = unixepoch()
+     WHERE superseded_by IS NULL
+       AND category NOT IN ('preference', 'architecture')
+       AND updated_at < unixepoch() - 604800`,
+  ).run();
+  getDb().query(
+    `DELETE FROM clawbot_memories WHERE importance < 0.1 AND superseded_by IS NULL`,
+  ).run();
+}
+
+// ---------------------------------------------------------------------------
+// ClawBot pairing helpers
+// ---------------------------------------------------------------------------
+
+export function createPairingRequest(
+  chatId: string,
+  userId: string,
+  displayName: string,
+  code: string,
+): void {
+  getDb().query(
+    `INSERT INTO clawbot_paired_chats (telegram_chat_id, telegram_user_id, display_name, pairing_code, status)
+     VALUES (?, ?, ?, ?, 'pending')
+     ON CONFLICT(telegram_chat_id) DO UPDATE SET
+       telegram_user_id = excluded.telegram_user_id,
+       display_name = excluded.display_name,
+       pairing_code = excluded.pairing_code,
+       status = 'pending',
+       approved_at = NULL`,
+  ).run(chatId, userId, displayName, code);
+}
+
+export function approvePairing(chatId: string): void {
+  getDb().query(
+    `UPDATE clawbot_paired_chats
+     SET status = 'approved', pairing_code = NULL, approved_at = unixepoch()
+     WHERE telegram_chat_id = ? AND status = 'pending'`,
+  ).run(chatId);
+}
+
+export function revokePairing(chatId: string): void {
+  getDb().query(
+    "UPDATE clawbot_paired_chats SET status = 'revoked' WHERE telegram_chat_id = ?",
+  ).run(chatId);
+}
+
+export function getPairingByCode(code: string): ClawBotPairedChat | null {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE pairing_code = ? AND status = 'pending'",
+  ).get(code) as ClawBotPairedChat | null;
+}
+
+export function getPairingByChatId(chatId: string): ClawBotPairedChat | null {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE telegram_chat_id = ?",
+  ).get(chatId) as ClawBotPairedChat | null;
+}
+
+export function listPairedChats(): ClawBotPairedChat[] {
+  return getDb().query(
+    "SELECT * FROM clawbot_paired_chats WHERE status != 'revoked' ORDER BY created_at DESC",
+  ).all() as ClawBotPairedChat[];
+}
+
+export function isPairedChat(chatId: string): boolean {
+  const row = getDb().query(
+    "SELECT 1 FROM clawbot_paired_chats WHERE telegram_chat_id = ? AND status = 'approved'",
+  ).get(chatId);
+  return row != null;
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/services/supervisor.ts

@@ -9,6 +9,7 @@ import { resolve } from "node:path";
 import { homedir } from "node:os";
 import {
   readFileSync, writeFileSync, existsSync, mkdirSync, openSync, appendFileSync,
+  unlinkSync,
 } from "node:fs";
 import { isCompiledBinary } from "./autostart-generator.ts";
 
@@ -30,6 +31,7 @@ const PPM_DIR = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"));
 const STATUS_FILE = resolve(PPM_DIR, "status.json");
 const PID_FILE = resolve(PPM_DIR, "ppm.pid");
 const LOG_FILE = resolve(PPM_DIR, "ppm.log");
+const RESTARTING_FLAG = resolve(PPM_DIR, ".restarting");
 
 // ─── State ─────────────────────────────────────────────────────────────
 let serverChild: Subprocess | null = null;
@@ -417,6 +419,9 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     supervisorState = "upgrading";
     updateStatus({ state: "upgrading" });
 
+    // Set restarting flag so server child's stopTunnel() skips killing the tunnel
+    try { writeFileSync(RESTARTING_FLAG, ""); } catch {}
+
     // Kill server child to free the port; keep tunnel alive for domain continuity
     log("INFO", "Stopping server before spawning new supervisor (tunnel kept alive)");
     if (serverChild) { try { serverChild.kill(); } catch {} serverChild = null; }
@@ -456,6 +461,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     // Timeout — new supervisor didn't start, restore old supervisor
     log("ERROR", "Self-replace timeout: new supervisor did not start");
     try { child.kill(); } catch {}
+    try { unlinkSync(RESTARTING_FLAG); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     supervisorState = "running";
@@ -463,6 +469,7 @@ async function selfReplace(): Promise<{ success: boolean; error?: string }> {
     return { success: false, error: "New supervisor failed to start within 30s" };
   } catch (e) {
     log("ERROR", `Self-replace error: ${e}`);
+    try { unlinkSync(RESTARTING_FLAG); } catch {}
     shuttingDown = false;
     notifyStateChange("upgrading", "running", "upgrade_failed");
     supervisorState = "running";
@@ -631,6 +638,9 @@ export async function runSupervisor(opts: {
 }) {
   if (!existsSync(PPM_DIR)) mkdirSync(PPM_DIR, { recursive: true });
 
+  // Clean up restarting flag from previous upgrade/restart
+  try { unlinkSync(RESTARTING_FLAG); } catch {}
+
   // Save original argv for self-replace
   originalArgv = [...process.argv];
 

package/src/types/clawbot.ts

@@ -0,0 +1,103 @@
+/** Telegram update object (subset we care about) */
+export interface TelegramUpdate {
+  update_id: number;
+  message?: TelegramMessage;
+  edited_message?: TelegramMessage;
+}
+
+export interface TelegramMessage {
+  message_id: number;
+  from?: { id: number; first_name: string; username?: string };
+  chat: { id: number; type: "private" | "group" | "supergroup" };
+  date: number;
+  text?: string;
+  caption?: string;
+}
+
+/** Sent message result from Telegram API */
+export interface TelegramSentMessage {
+  message_id: number;
+  chat: { id: number };
+  date: number;
+}
+
+/** ClawBot session row from SQLite */
+export interface ClawBotSessionRow {
+  id: number;
+  telegram_chat_id: string;
+  session_id: string;
+  provider_id: string;
+  project_name: string;
+  project_path: string;
+  is_active: number;
+  created_at: number;
+  last_message_at: number;
+}
+
+/** ClawBot memory row from SQLite */
+export interface ClawBotMemoryRow {
+  id: number;
+  project: string;
+  content: string;
+  category: ClawBotMemoryCategory;
+  importance: number;
+  created_at: number;
+  updated_at: number;
+  session_id: string | null;
+  superseded_by: number | null;
+}
+
+export type ClawBotMemoryCategory =
+  | "fact"
+  | "decision"
+  | "preference"
+  | "architecture"
+  | "issue";
+
+/** Active session state tracked in memory (not DB) */
+export interface ClawBotActiveSession {
+  telegramChatId: string;
+  sessionId: string;
+  providerId: string;
+  projectName: string;
+  projectPath: string;
+  /** Telegram message ID being edited for streaming */
+  currentMessageId?: number;
+  /** Debounce timer for rapid messages */
+  debounceTimer?: ReturnType<typeof setTimeout>;
+  /** Accumulated debounced text */
+  debouncedText?: string;
+}
+
+/** Parsed command from Telegram message */
+export interface ClawBotCommand {
+  command: string;
+  args: string;
+  chatId: number;
+  messageId: number;
+  userId: number;
+  username?: string;
+}
+
+/** Memory recall result with relevance score */
+export interface MemoryRecallResult {
+  id: number;
+  content: string;
+  category: ClawBotMemoryCategory;
+  importance: number;
+  project: string;
+  /** FTS5 rank score (lower = more relevant) */
+  rank?: number;
+}
+
+/** Paired chat row from SQLite */
+export interface ClawBotPairedChat {
+  id: number;
+  telegram_chat_id: string;
+  telegram_user_id: string | null;
+  display_name: string | null;
+  pairing_code: string | null;
+  status: "pending" | "approved" | "revoked";
+  created_at: number;
+  approved_at: number | null;
+}

package/src/types/config.ts

@@ -9,6 +9,17 @@ export interface TelegramConfig {
   chat_id: string;
 }
 
+export interface ClawBotConfig {
+  enabled: boolean;
+  default_provider: string;
+  default_project: string;
+  system_prompt: string;
+  show_tool_calls: boolean;
+  show_thinking: boolean;
+  permission_mode: string;
+  debounce_ms: number;
+}
+
 export type ThemeConfig = "light" | "dark" | "system";
 
 export interface PpmConfig {
@@ -21,6 +32,7 @@ export interface PpmConfig {
   ai: AIConfig;
   push?: PushConfig;
   telegram?: TelegramConfig;
+  clawbot?: ClawBotConfig;
   cloud_url?: string;
 }
 
@@ -85,6 +97,16 @@ export const DEFAULT_CONFIG: PpmConfig = {
       },
     },
   },
+  clawbot: {
+    enabled: false,
+    default_provider: "claude",
+    default_project: "",
+    system_prompt: "",
+    show_tool_calls: true,
+    show_thinking: false,
+    permission_mode: "bypassPermissions",
+    debounce_ms: 2000,
+  },
 };
 
 const VALID_TYPES = ["agent-sdk", "cli", "mock"] as const;

package/src/web/components/chat/chat-history-bar.tsx

@@ -1,5 +1,5 @@
 import { useState, useEffect, useCallback, useRef } from "react";
-import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff, Trash2, Users } from "lucide-react";
+import { History, Settings2, Loader2, MessageSquare, RefreshCw, Search, Pencil, Check, X, BellOff, Bug, ClipboardCheck, Pin, PinOff, Trash2, Users, Bot } from "lucide-react";
 import { Activity } from "lucide-react";
 import { api, projectUrl } from "@/lib/api-client";
 import { useTabStore } from "@/stores/tab-store";
@@ -398,9 +398,14 @@ export function ChatHistoryBar({
                     <>
                       <button
                         onClick={() => openSession(session)}
-                        className="text-[11px] truncate flex-1 text-left"
+                        className="text-[11px] truncate flex-1 text-left flex items-center gap-1"
                       >
-                        {session.title || "Untitled"}
+                        {session.title?.startsWith("[Claw]") && (
+                          <Bot className="size-3 text-muted-foreground shrink-0" />
+                        )}
+                        {session.title?.startsWith("[Claw]")
+                          ? session.title.slice(7)
+                          : session.title || "Untitled"}
                       </button>
                       <button
                         onClick={(e) => togglePin(e, session)}