@hienlh/ppm 0.9.52 → 0.9.54

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

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { chatService } from "../chat.service.ts";
@@ -8,107 +8,102 @@ import {
   createPPMBotSession,
   deactivatePPMBotSession,
   touchPPMBotSession,
-  getRecentPPMBotSessions,
   getDistinctPPMBotProjectNames,
-  setSessionTitle,
 } from "../db.service.ts";
 import type { PPMBotActiveSession, PPMBotSessionRow } from "../../types/ppmbot.ts";
 import type { PPMBotConfig, ProjectConfig } from "../../types/config.ts";
 
-export class PPMBotSessionManager {
-  /** In-memory cache: telegramChatId → active session */
-  private activeSessions = new Map<string, PPMBotActiveSession>();
+export const DEFAULT_COORDINATOR_IDENTITY = `# PPMBot — AI Project Coordinator
 
-  /**
-   * 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<PPMBotActiveSession> {
-    const cached = this.activeSessions.get(chatId);
-    if (cached && (!projectName || cached.projectName === projectName)) {
-      touchPPMBotSession(cached.sessionId);
-      return cached;
-    }
+You are PPMBot, a personal AI project coordinator and team leader. You communicate with users via Telegram.
 
-    const input = projectName || this.getDefaultProject();
-    const resolvedProject = input
-      ? this.resolveProject(input)
-      : this.getFallbackProject();
-    if (!resolvedProject) {
-      throw new Error(`Project not found: "${projectName || "(default)"}"`);
-    }
+## Role
+- Answer direct questions immediately (coding, general knowledge, quick advice)
+- Delegate project-specific tasks to subagents using \`ppm bot delegate\`
+- Track delegated task status and report results proactively
+- Remember user preferences across conversations
+- Act as a team leader coordinating work across multiple projects
 
-    const dbSession = getActivePPMBotSession(chatId, resolvedProject.name);
-    if (dbSession) {
-      return this.resumeFromDb(chatId, dbSession, resolvedProject);
-    }
+## Decision Framework
+1. Can I answer this directly without project context? → Answer now
+2. Does this reference a specific project or need file access? → Delegate
+3. Is this about PPM config or bot management? → Handle directly
+4. Ambiguous project? → Ask user to clarify
 
-    return this.createNewSession(chatId, resolvedProject);
-  }
+## Coordination Tools (via Bash)
 
-  /** Switch to a different project. Deactivates current session. */
-  async switchProject(
-    chatId: string,
-    projectName: string,
-  ): Promise<PPMBotActiveSession> {
-    await this.closeSession(chatId);
-    return this.getOrCreateSession(chatId, projectName);
-  }
+### Delegate a task to a project
+ppm bot delegate --chat <chatId> --project <name> --prompt "<enriched task description>"
+Returns task ID. Tell user you're working on it.
 
-  /** Close (deactivate) the current session for a chatId */
-  async closeSession(chatId: string): Promise<void> {
-    const active = this.activeSessions.get(chatId);
-    if (active) {
-      deactivatePPMBotSession(active.sessionId);
-      this.activeSessions.delete(chatId);
-    }
-  }
+### Check task status
+ppm bot task-status <task-id>
 
-  /** Get active session from cache (no DB hit) */
-  getActiveSession(chatId: string): PPMBotActiveSession | null {
-    return this.activeSessions.get(chatId) ?? null;
-  }
+### Get task result
+ppm bot task-result <task-id>
 
-  /** List recent sessions for a chat (from DB) */
-  listRecentSessions(chatId: string, limit = 10): PPMBotSessionRow[] {
-    return getRecentPPMBotSessions(chatId, limit);
-  }
+### List recent tasks
+ppm bot tasks
 
-  /** Resume a specific session by 1-indexed position in history */
-  async resumeSessionById(
-    chatId: string,
-    sessionIndex: number,
-  ): Promise<PPMBotActiveSession | null> {
-    const sessions = getRecentPPMBotSessions(chatId, 20);
-    const target = sessions[sessionIndex - 1];
-    if (!target) return null;
+## Response Style
+- Keep responses concise (Telegram context — mobile-friendly)
+- Use short paragraphs, no walls of text
+- When delegating: acknowledge immediately, notify on completion
+- Support Vietnamese and English naturally
 
-    await this.closeSession(chatId);
+## Important
+- When delegating, write an enriched prompt with full context — not just the raw user message
+- Include relevant details: what the user wants, which files/features, acceptance criteria
+- Each delegation creates a fresh AI session in the target project workspace
+`;
 
-    const project = this.resolveProject(target.project_name);
-    if (!project) return null;
+/** Ensure ~/.ppm/bot/ workspace exists with coordinator.md */
+export function ensureCoordinatorWorkspace(): void {
+  const botDir = join(homedir(), ".ppm", "bot");
+  const coordinatorMd = join(botDir, "coordinator.md");
+  const settingsDir = join(botDir, ".claude");
+  const settingsFile = join(settingsDir, "settings.local.json");
 
-    return this.resumeFromDb(chatId, target, project);
+  mkdirSync(botDir, { recursive: true });
+  mkdirSync(settingsDir, { recursive: true });
+
+  if (!existsSync(coordinatorMd)) {
+    writeFileSync(coordinatorMd, DEFAULT_COORDINATOR_IDENTITY);
+  }
+  if (!existsSync(settingsFile)) {
+    writeFileSync(settingsFile, JSON.stringify({
+      permissions: { allow: ["Bash", "Read", "Write", "Edit", "Glob", "Grep"] },
+    }, null, 2));
   }
+}
+
+export class PPMBotSessionManager {
+  /** In-memory cache: telegramChatId → coordinator session */
+  private coordinatorSessions = new Map<string, PPMBotActiveSession>();
 
-  /** Resume a session by session ID prefix match */
-  async resumeSessionByIdPrefix(
-    chatId: string,
-    prefix: string,
-  ): Promise<PPMBotActiveSession | null> {
-    const sessions = getRecentPPMBotSessions(chatId, 20);
-    const target = sessions.find((s) => s.session_id.startsWith(prefix));
-    if (!target) return null;
+  /** Get or create coordinator session for chatId (always ~/.ppm/bot/) */
+  async getCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const cached = this.coordinatorSessions.get(chatId);
+    if (cached) {
+      touchPPMBotSession(cached.sessionId);
+      return cached;
+    }
 
-    await this.closeSession(chatId);
+    // Check DB for existing coordinator session
+    const dbSession = getActivePPMBotSession(chatId, "bot");
+    if (dbSession) {
+      return this.resumeFromDb(chatId, dbSession);
+    }
 
-    const project = this.resolveProject(target.project_name);
-    if (!project) return null;
+    return this.createCoordinatorSession(chatId);
+  }
 
-    return this.resumeFromDb(chatId, target, project);
+  /** Rotate coordinator session (context window near limit) */
+  async rotateCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const old = this.coordinatorSessions.get(chatId);
+    if (old) deactivatePPMBotSession(old.sessionId);
+    this.coordinatorSessions.delete(chatId);
+    return this.createCoordinatorSession(chatId);
   }
 
   /**
@@ -120,7 +115,6 @@ export class PPMBotSessionManager {
     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 };
 
@@ -130,13 +124,6 @@ export class PPMBotSessionManager {
     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 = `[PPM] ${preview}`;
-    setSessionTitle(sessionId, title);
-  }
-
   /** Get list of available project names (config + sessions history) */
   getProjectNames(): string[] {
     const configured = (configService.get("projects") as ProjectConfig[])?.map((p) => p.name) ?? [];
@@ -147,13 +134,7 @@ export class PPMBotSessionManager {
 
   // ── Private ─────────────────────────────────────────────────────
 
-  private getDefaultProject(): string {
-    const cfg = configService.get("clawbot") as PPMBotConfig | undefined;
-    return cfg?.default_project || "";
-  }
-
-  /** Fallback project when nothing is configured: ~/.ppm/bot/ */
-  private getFallbackProject(): { name: string; path: string } {
+  private getCoordinatorProject(): { name: string; path: string } {
     const botDir = join(homedir(), ".ppm", "bot");
     if (!existsSync(botDir)) mkdirSync(botDir, { recursive: true });
     return { name: "bot", path: botDir };
@@ -164,16 +145,14 @@ export class PPMBotSessionManager {
     return cfg?.default_provider || configService.get("ai").default_provider;
   }
 
-  private async createNewSession(
-    chatId: string,
-    project: { name: string; path: string },
-  ): Promise<PPMBotActiveSession> {
+  private async createCoordinatorSession(chatId: string): Promise<PPMBotActiveSession> {
+    const project = this.getCoordinatorProject();
     const providerId = this.getDefaultProvider();
 
     const session = await chatService.createSession(providerId, {
       projectName: project.name,
       projectPath: project.path,
-      title: `[PPM] New session`,
+      title: `[PPM] Coordinator`,
     });
 
     createPPMBotSession(chatId, session.id, providerId, project.name, project.path);
@@ -186,21 +165,19 @@ export class PPMBotSessionManager {
       projectPath: project.path,
     };
 
-    this.activeSessions.set(chatId, active);
+    this.coordinatorSessions.set(chatId, active);
     return active;
   }
 
-  private async resumeFromDb(
-    chatId: string,
-    dbSession: PPMBotSessionRow,
-    project: { name: string; path: string },
-  ): Promise<PPMBotActiveSession> {
+  private async resumeFromDb(chatId: string, dbSession: PPMBotSessionRow): Promise<PPMBotActiveSession> {
+    const project = this.getCoordinatorProject();
+
     try {
       await chatService.resumeSession(dbSession.provider_id, dbSession.session_id);
     } catch {
       console.warn(`[ppmbot] Failed to resume session ${dbSession.session_id}, creating new`);
       deactivatePPMBotSession(dbSession.session_id);
-      return this.createNewSession(chatId, project);
+      return this.createCoordinatorSession(chatId);
     }
 
     touchPPMBotSession(dbSession.session_id);
@@ -213,7 +190,7 @@ export class PPMBotSessionManager {
       projectPath: project.path,
     };
 
-    this.activeSessions.set(chatId, active);
+    this.coordinatorSessions.set(chatId, active);
     return active;
   }
 }

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

@@ -10,10 +10,9 @@ const POLL_TIMEOUT = 25;
 const MIN_EDIT_INTERVAL = 1000;
 const BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]{30,50}$/;
 
-/** Known PPMBot slash commands */
+/** Known PPMBot slash commands (coordinator: 3 public + 1 hidden) */
 const COMMANDS = new Set([
-  "start", "project", "new", "sessions", "resume",
-  "status", "stop", "memory", "forget", "remember", "restart", "version", "help",
+  "start", "status", "help", "restart",
 ]);
 
 export type UpdateHandler = (update: TelegramUpdate) => Promise<void>;
@@ -42,19 +41,9 @@ export class PPMBotTelegram {
     try {
       await this.callApi("setMyCommands", {
         commands: [
-          { command: "start", description: "Greeting + list projects" },
-          { command: "project", description: "Switch/list projects" },
-          { command: "new", description: "Fresh session (current project)" },
-          { command: "sessions", description: "List recent sessions" },
-          { command: "resume", description: "Resume a previous session" },
-          { command: "status", description: "Current project/session info" },
-          { command: "stop", description: "End current session" },
-          { command: "memory", description: "Show project memories" },
-          { command: "forget", description: "Remove matching memories" },
-          { command: "remember", description: "Save a fact" },
-          { command: "restart", description: "Restart PPM server" },
-          { command: "version", description: "Show PPM version" },
-          { command: "help", description: "Show all commands" },
+          { command: "start", description: "Welcome + list projects" },
+          { command: "status", description: "Running tasks + delegations" },
+          { command: "help", description: "Show commands" },
         ],
       });
       console.log("[ppmbot] Commands registered");

package/src/services/sqlite.service.ts

@@ -137,6 +137,16 @@ class SqliteService {
     db.run(`UPDATE "${table}" SET "${column}" = ? WHERE "${pkColumn}" = ?`, [value as never, rowid]);
   }
 
+  /** Delete a row by primary key */
+  deleteRow(
+    projectPath: string, dbPath: string, table: string,
+    pkValue: unknown, pkColumn = "rowid",
+  ): void {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    db.run(`DELETE FROM "${table}" WHERE "${pkColumn}" = ?`, [pkValue as never]);
+  }
+
   /** Close all cached databases (for shutdown) */
   closeAll() {
     for (const absPath of this.cache.keys()) this.close(absPath);

package/src/services/supervisor-state.ts

@@ -0,0 +1,100 @@
+/**
+ * Supervisor state machine — state transitions, IPC command file, signal handling.
+ * Extracted from supervisor.ts to keep the orchestrator lean.
+ */
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import {
+  readFileSync, writeFileSync, existsSync, unlinkSync, renameSync, openSync, closeSync,
+} from "node:fs";
+import { constants } from "node:fs";
+
+const PPM_DIR = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"));
+export const CMD_FILE = resolve(PPM_DIR, ".supervisor-cmd");
+export const STATUS_FILE = resolve(PPM_DIR, "status.json");
+export const PID_FILE = resolve(PPM_DIR, "ppm.pid");
+export const LOCK_FILE = resolve(PPM_DIR, ".start-lock");
+
+// ─── State ─────────────────────────────────────────────────────────────
+export type SupervisorState = "running" | "paused" | "stopped" | "upgrading";
+
+let _state: SupervisorState = "running";
+let _resumeResolve: (() => void) | null = null;
+
+export function getState(): SupervisorState { return _state; }
+
+export function setState(s: SupervisorState) { _state = s; }
+
+export function waitForResume(): Promise<void> {
+  return new Promise((res) => { _resumeResolve = res; });
+}
+
+export function triggerResume(): void {
+  if (_resumeResolve) {
+    _resumeResolve();
+    _resumeResolve = null;
+  }
+}
+
+// ─── Status file helpers ───────────────────────────────────────────────
+export function readStatus(): Record<string, unknown> {
+  try {
+    if (existsSync(STATUS_FILE)) return JSON.parse(readFileSync(STATUS_FILE, "utf-8"));
+  } catch {}
+  return {};
+}
+
+export function updateStatus(patch: Record<string, unknown>) {
+  try {
+    const data = { ...readStatus(), ...patch };
+    writeFileSync(STATUS_FILE, JSON.stringify(data));
+  } catch {}
+}
+
+// ─── Command file protocol ─────────────────────────────────────────────
+export type CmdAction = "soft_stop" | "resume";
+
+/** Atomically claim + read command file (rename to .claimed, read, delete) */
+export function readAndDeleteCmd(): { action: CmdAction } | null {
+  const claimed = CMD_FILE + ".claimed";
+  try {
+    renameSync(CMD_FILE, claimed); // atomic claim — second caller gets ENOENT
+    const cmd = JSON.parse(readFileSync(claimed, "utf-8"));
+    unlinkSync(claimed);
+    return cmd;
+  } catch {
+    // No command file or already claimed by another handler
+    try { unlinkSync(claimed); } catch {}
+    return null;
+  }
+}
+
+export function writeCmd(action: CmdAction) {
+  writeFileSync(CMD_FILE, JSON.stringify({ action }));
+}
+
+// ─── Lockfile ──────────────────────────────────────────────────────────
+export function acquireLock(): boolean {
+  try {
+    // Try exclusive create — fails if file already exists (atomic)
+    const fd = openSync(LOCK_FILE, "wx");
+    writeFileSync(fd, String(process.pid));
+    closeSync(fd);
+    return true;
+  } catch {
+    // File exists — check if holding process is alive
+    try {
+      const pid = parseInt(readFileSync(LOCK_FILE, "utf-8").trim(), 10);
+      if (!isNaN(pid)) {
+        try { process.kill(pid, 0); return false; } catch {} // stale lock
+      }
+      // Stale lock — overwrite
+      writeFileSync(LOCK_FILE, String(process.pid));
+      return true;
+    } catch { return false; }
+  }
+}
+
+export function releaseLock() {
+  try { unlinkSync(LOCK_FILE); } catch {}
+}

package/src/services/supervisor-stopped-page.ts

@@ -0,0 +1,73 @@
+/**
+ * Minimal HTTP server that serves a "stopped" page when the PPM server child is down.
+ * Binds to the same port so the tunnel URL still works.
+ */
+import { appendFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+
+const LOG_FILE = resolve(process.env.PPM_HOME || resolve(homedir(), ".ppm"), "ppm.log");
+
+function log(level: string, msg: string) {
+  const ts = new Date().toISOString();
+  try { appendFileSync(LOG_FILE, `[${ts}] [${level}] [stopped-page] ${msg}\n`); } catch {}
+}
+
+const STOPPED_HTML = `<!DOCTYPE html>
+<html><head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width,initial-scale=1">
+  <title>PPM - Stopped</title>
+  <style>
+    body { font-family: system-ui; display: flex; justify-content: center;
+           align-items: center; min-height: 100vh; margin: 0;
+           background: #1a1a2e; color: #e0e0e0; }
+    .card { text-align: center; padding: 2rem; }
+    h1 { font-size: 1.5rem; margin-bottom: 0.5rem; }
+    p { color: #888; font-size: 0.9rem; }
+    .dot { display: inline-block; width: 10px; height: 10px;
+           border-radius: 50%; background: #f59e0b; margin-right: 8px; }
+  </style>
+</head><body>
+  <div class="card">
+    <h1><span class="dot"></span>PPM Server Stopped</h1>
+    <p>The server is stopped but the supervisor is still running.</p>
+    <p>Use <code>ppm start</code> or Cloud dashboard to restart.</p>
+  </div>
+</body></html>`;
+
+let stoppedServer: ReturnType<typeof Bun.serve> | null = null;
+
+export function startStoppedPage(port: number, host: string) {
+  if (stoppedServer) return;
+
+  try {
+    stoppedServer = Bun.serve({
+      port,
+      hostname: host,
+      fetch(req) {
+        const url = new URL(req.url);
+        if (url.pathname === "/api/health") {
+          return new Response(JSON.stringify({ status: "stopped" }), {
+            status: 503,
+            headers: { "Content-Type": "application/json" },
+          });
+        }
+        return new Response(STOPPED_HTML, {
+          headers: { "Content-Type": "text/html" },
+        });
+      },
+    });
+    log("INFO", `Stopped page serving on port ${port}`);
+  } catch (e) {
+    log("WARN", `Failed to start stopped page: ${e}`);
+  }
+}
+
+export function stopStoppedPage() {
+  if (stoppedServer) {
+    stoppedServer.stop();
+    stoppedServer = null;
+    log("INFO", "Stopped page server shut down");
+  }
+}