@hienlh/ppm 0.9.53 → 0.9.55

package/src/services/database/postgres-adapter.ts

@@ -39,4 +39,12 @@ export const postgresAdapter: DatabaseAdapter = {
       opts.pkColumn, opts.pkValue, opts.column, opts.value,
     );
   },
+
+  async deleteRow(config: DbConnectionConfig, table: string, opts): Promise<void> {
+    if (!config.connectionString) throw new Error("Missing connectionString");
+    await postgresService.deleteRow(
+      config.connectionString, table, opts.schema ?? "public",
+      opts.pkColumn, opts.pkValue,
+    );
+  },
 };

package/src/services/database/sqlite-adapter.ts

@@ -51,4 +51,9 @@ export const sqliteAdapter: DatabaseAdapter = {
     if (!config.path) throw new Error("Missing path");
     sqliteService.updateCell(config.path, config.path, table, opts.pkValue as number, opts.column, opts.value, opts.pkColumn);
   },
+
+  async deleteRow(config: DbConnectionConfig, table: string, opts): Promise<void> {
+    if (!config.path) throw new Error("Missing path");
+    sqliteService.deleteRow(config.path, config.path, table, opts.pkValue, opts.pkColumn);
+  },
 };

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 = 13;
+const CURRENT_SCHEMA_VERSION = 14;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -387,6 +387,33 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 13;
     `);
   }
+
+  if (current < 14) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS bot_tasks (
+        id TEXT PRIMARY KEY,
+        chat_id TEXT NOT NULL,
+        project_name TEXT NOT NULL,
+        project_path TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'pending',
+        result_summary TEXT,
+        result_full TEXT,
+        session_id TEXT,
+        error TEXT,
+        reported INTEGER NOT NULL DEFAULT 0,
+        timeout_ms INTEGER DEFAULT 900000,
+        created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+        started_at INTEGER,
+        completed_at INTEGER
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_bot_tasks_status ON bot_tasks(status);
+      CREATE INDEX IF NOT EXISTS idx_bot_tasks_chat ON bot_tasks(chat_id, created_at DESC);
+
+      PRAGMA user_version = 14;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -1188,5 +1215,86 @@ export function isPairedChat(chatId: string): boolean {
   return row != null;
 }
 
+// ---------------------------------------------------------------------------
+// Bot Tasks helpers
+// ---------------------------------------------------------------------------
+
+import type { BotTask, BotTaskStatus } from "../types/ppmbot.ts";
+
+export function createBotTask(
+  id: string, chatId: string, projectName: string, projectPath: string,
+  prompt: string, timeoutMs = 900000,
+): void {
+  getDb().query(
+    `INSERT INTO bot_tasks (id, chat_id, project_name, project_path, prompt, timeout_ms)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  ).run(id, chatId, projectName, projectPath, prompt, timeoutMs);
+}
+
+export function updateBotTaskStatus(
+  id: string, status: BotTaskStatus,
+  updates?: { sessionId?: string; resultSummary?: string; resultFull?: string; error?: string },
+): void {
+  const sets = ["status = ?"];
+  const params: (string | number | null)[] = [status];
+
+  if (status === "running") {
+    sets.push("started_at = unixepoch()");
+  }
+  if (status === "completed" || status === "failed" || status === "timeout") {
+    sets.push("completed_at = unixepoch()");
+  }
+  if (updates?.sessionId != null) { sets.push("session_id = ?"); params.push(updates.sessionId); }
+  if (updates?.resultSummary != null) { sets.push("result_summary = ?"); params.push(updates.resultSummary); }
+  if (updates?.resultFull != null) { sets.push("result_full = ?"); params.push(updates.resultFull); }
+  if (updates?.error != null) { sets.push("error = ?"); params.push(updates.error); }
+
+  params.push(id);
+  getDb().query(`UPDATE bot_tasks SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+}
+
+export function markBotTaskReported(id: string): void {
+  getDb().query("UPDATE bot_tasks SET reported = 1 WHERE id = ?").run(id);
+}
+
+export function getBotTask(id: string): BotTask | null {
+  const row = getDb().query("SELECT * FROM bot_tasks WHERE id = ?").get(id) as Record<string, any> | null;
+  return row ? mapBotTaskRow(row) : null;
+}
+
+export function getRecentBotTasks(chatId: string, limit = 20): BotTask[] {
+  const rows = getDb().query(
+    "SELECT * FROM bot_tasks WHERE chat_id = ? ORDER BY created_at DESC LIMIT ?",
+  ).all(chatId, limit) as Record<string, any>[];
+  return rows.map(mapBotTaskRow);
+}
+
+export function getRunningBotTasks(): BotTask[] {
+  const rows = getDb().query(
+    "SELECT * FROM bot_tasks WHERE status IN ('pending', 'running') ORDER BY created_at ASC",
+  ).all() as Record<string, any>[];
+  return rows.map(mapBotTaskRow);
+}
+
+function mapBotTaskRow(row: Record<string, any>): BotTask {
+  return {
+    id: row.id,
+    chatId: row.chat_id,
+    projectName: row.project_name,
+    projectPath: row.project_path,
+    prompt: row.prompt,
+    status: row.status,
+    resultSummary: row.result_summary,
+    resultFull: row.result_full,
+    sessionId: row.session_id,
+    error: row.error,
+    reported: !!row.reported,
+    timeoutMs: row.timeout_ms,
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+  };
+}
+
 // Auto-close on process exit
 process.on("beforeExit", closeDb);

package/src/services/postgres.service.ts

@@ -161,6 +161,18 @@ class PostgresService {
     );
   }
 
+  /** Delete a row by primary key */
+  async deleteRow(
+    connectionString: string, table: string, schema = "public",
+    pkColumn: string, pkValue: unknown,
+  ): Promise<void> {
+    const sql = this.connect(connectionString);
+    await sql.unsafe(
+      `DELETE FROM "${schema}"."${table}" WHERE "${pkColumn}" = $1`,
+      [pkValue as never],
+    );
+  }
+
   /** Close all cached connections */
   async closeAll() {
     for (const key of this.cache.keys()) await this.disconnect(key);

package/src/services/ppmbot/ppmbot-delegation.ts

@@ -0,0 +1,112 @@
+import { chatService } from "../chat.service.ts";
+import { configService } from "../config.service.ts";
+import { getBotTask, updateBotTaskStatus } from "../db.service.ts";
+import { escapeHtml } from "./ppmbot-formatter.ts";
+import type { PPMBotTelegram } from "./ppmbot-telegram.ts";
+import type { ChatEvent } from "../../types/chat.ts";
+import type { PermissionMode } from "../../types/config.ts";
+
+/** Active background tasks: taskId -> AbortController */
+const activeTasks = new Map<string, AbortController>();
+
+export async function executeDelegation(
+  taskId: string,
+  telegram: PPMBotTelegram,
+  providerId: string,
+): Promise<void> {
+  const task = getBotTask(taskId);
+  if (!task || task.status !== "pending") return;
+
+  // Guard against double-execution
+  if (activeTasks.has(taskId)) return;
+
+  const abort = new AbortController();
+  activeTasks.set(taskId, abort);
+
+  updateBotTaskStatus(taskId, "running");
+
+  const timer = setTimeout(() => {
+    abort.abort();
+    activeTasks.delete(taskId);
+    updateBotTaskStatus(taskId, "timeout");
+    telegram.sendMessage(
+      Number(task.chatId),
+      `⏱ Task timed out: <i>${escapeHtml(task.prompt.slice(0, 80))}</i>`,
+    );
+  }, task.timeoutMs);
+
+  try {
+    const session = await chatService.createSession(providerId, {
+      projectPath: task.projectPath,
+      projectName: task.projectName,
+      title: `[PPMBot] ${task.prompt.slice(0, 50)}`,
+    });
+
+    const opts = { permissionMode: "bypassPermissions" as PermissionMode };
+    const events = chatService.sendMessage(providerId, session.id, task.prompt, opts);
+
+    let fullText = "";
+    let lastAssistantText = "";
+
+    for await (const event of events) {
+      if (abort.signal.aborted) break;
+
+      if (event.type === "text") {
+        lastAssistantText = event.content;
+        fullText += event.content;
+      }
+      if (event.type === "done" && event.resultSubtype === "success") {
+        // done event — session finished
+      }
+    }
+
+    clearTimeout(timer);
+    activeTasks.delete(taskId);
+
+    if (abort.signal.aborted) return;
+
+    const summary = lastAssistantText.slice(0, 500) || "Task completed (no text output)";
+
+    updateBotTaskStatus(taskId, "completed", {
+      sessionId: session.id,
+      resultSummary: summary,
+      resultFull: fullText.trim(),
+    });
+
+    await telegram.sendMessage(
+      Number(task.chatId),
+      `✅ <b>${escapeHtml(task.projectName)}</b> task done\n\n` +
+        `<i>${escapeHtml(task.prompt.slice(0, 80))}</i>\n\n` +
+        `${escapeHtml(summary.slice(0, 300))}` +
+        (summary.length > 300 ? "…" : ""),
+    );
+  } catch (err) {
+    clearTimeout(timer);
+    activeTasks.delete(taskId);
+
+    if (abort.signal.aborted) return;
+
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    updateBotTaskStatus(taskId, "failed", { error: errorMsg });
+
+    await telegram.sendMessage(
+      Number(task.chatId),
+      `❌ Task failed (<b>${escapeHtml(task.projectName)}</b>)\n\n` +
+        `<i>${escapeHtml(task.prompt.slice(0, 80))}</i>\n\n` +
+        `Error: ${escapeHtml(errorMsg.slice(0, 200))}`,
+    );
+  }
+}
+
+export function cancelDelegation(taskId: string): boolean {
+  const abort = activeTasks.get(taskId);
+  if (!abort) return false;
+  abort.abort();
+  activeTasks.delete(taskId);
+  updateBotTaskStatus(taskId, "failed", { error: "Cancelled by user" });
+  return true;
+}
+
+export function getActiveDelegationCount(): number {
+  return activeTasks.size;
+}