@hienlh/ppm 0.9.0-beta.3 → 0.9.0-beta.4

package/src/providers/cli-provider-base.ts

@@ -0,0 +1,238 @@
+import type {
+  AIProvider,
+  Session,
+  SessionConfig,
+  SessionInfo,
+  ChatEvent,
+  SendMessageOpts,
+} from "./provider.interface.ts";
+import { spawn, type ChildProcess } from "node:child_process";
+import { parseNdjsonLines } from "../utils/ndjson-line-parser.ts";
+import { configService } from "../services/config.service.ts";
+
+/**
+ * Abstract base class for CLI-spawning AI providers.
+ * Handles process lifecycle, NDJSON streaming, abort, and cleanup.
+ * Subclasses only implement event mapping + arg building.
+ */
+export abstract class CliProvider implements AIProvider {
+  abstract readonly id: string;
+  abstract readonly name: string;
+  abstract readonly cliCommand: string;
+
+  /** Build CLI args for a given message/session */
+  abstract buildArgs(params: {
+    sessionId?: string;
+    message: string;
+    model?: string;
+    permissionMode?: string;
+    isResume: boolean;
+  }): string[];
+
+  /** Map a raw JSON object from CLI stdout → ChatEvent[] */
+  abstract mapEvent(raw: unknown, sessionId: string): ChatEvent[];
+
+  /** Extract session ID from CLI init event (provider-specific) */
+  abstract extractSessionId(raw: unknown): string | null;
+
+  /** Check if CLI binary exists on this machine */
+  abstract isAvailable(): Promise<boolean>;
+
+  // --- Shared state ---
+  protected sessions = new Map<string, Session>();
+  protected activeProcesses = new Map<string, ChildProcess>();
+  private messageCount = new Map<string, number>();
+
+  // --- Session lifecycle ---
+
+  async createSession(config: SessionConfig): Promise<Session> {
+    const id = crypto.randomUUID();
+    const session: Session = {
+      id,
+      providerId: this.id,
+      title: config.title ?? "New Chat",
+      projectName: config.projectName,
+      projectPath: config.projectPath,
+      createdAt: new Date().toISOString(),
+    };
+    this.sessions.set(id, session);
+    this.messageCount.set(id, 0);
+    return session;
+  }
+
+  async resumeSession(sessionId: string): Promise<Session> {
+    const existing = this.sessions.get(sessionId);
+    if (existing) return existing;
+    const session: Session = {
+      id: sessionId,
+      providerId: this.id,
+      title: "Resumed Chat",
+      createdAt: new Date().toISOString(),
+    };
+    this.sessions.set(sessionId, session);
+    this.messageCount.set(sessionId, 1);
+    return session;
+  }
+
+  async listSessions(): Promise<SessionInfo[]> {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      providerId: s.providerId,
+      title: s.title,
+      projectName: s.projectName,
+      createdAt: s.createdAt,
+    }));
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    this.sessions.delete(sessionId);
+    this.messageCount.delete(sessionId);
+  }
+
+  // --- Streaming ---
+
+  async *sendMessage(
+    sessionId: string,
+    message: string,
+    opts?: SendMessageOpts,
+  ): AsyncIterable<ChatEvent> {
+    if (!this.sessions.has(sessionId)) {
+      await this.resumeSession(sessionId);
+    }
+    const meta = this.sessions.get(sessionId)!;
+
+    if (meta.title === "New Chat") {
+      meta.title = message.slice(0, 50) + (message.length > 50 ? "..." : "");
+    }
+
+    const count = this.messageCount.get(sessionId) ?? 0;
+    const isResume = count > 0;
+    this.messageCount.set(sessionId, count + 1);
+
+    const config = this.getProviderConfig();
+    const args = this.buildArgs({
+      sessionId: isResume ? sessionId : undefined,
+      message,
+      model: config?.model,
+      permissionMode: opts?.permissionMode || config?.permission_mode,
+      isResume,
+    });
+
+    const cwd = meta.projectPath || process.cwd();
+    let capturedSessionId = isResume ? sessionId : null;
+
+    const proc = this.spawnProcess(args, cwd);
+    const processKey = sessionId;
+    this.activeProcesses.set(processKey, proc);
+
+    try {
+      for await (const raw of parseNdjsonLines(proc.stdout!)) {
+        if (!capturedSessionId) {
+          const extracted = this.extractSessionId(raw);
+          if (extracted) {
+            capturedSessionId = extracted;
+            if (capturedSessionId !== processKey) {
+              this.activeProcesses.delete(processKey);
+              this.activeProcesses.set(capturedSessionId, proc);
+              // Migrate session metadata to the real CLI-assigned ID
+              // so listSessions/getMessages use the correct key
+              const meta = this.sessions.get(processKey);
+              if (meta) {
+                this.sessions.delete(processKey);
+                meta.id = capturedSessionId;
+                this.sessions.set(capturedSessionId, meta);
+              }
+              const cnt = this.messageCount.get(processKey) ?? 0;
+              this.messageCount.delete(processKey);
+              this.messageCount.set(capturedSessionId, cnt);
+              // Notify frontend about the session ID change
+              yield { type: "session_migrated", oldSessionId: processKey, newSessionId: capturedSessionId } as ChatEvent;
+            }
+          }
+        }
+
+        const events = this.mapEvent(raw, capturedSessionId || sessionId);
+        for (const event of events) {
+          yield event;
+        }
+      }
+
+      const exitCode = await waitForExit(proc);
+      yield {
+        type: "done",
+        sessionId: capturedSessionId || sessionId,
+        resultSubtype: exitCode === 0 ? "success" : "error_during_execution",
+      };
+    } catch (err) {
+      yield {
+        type: "error",
+        message: err instanceof Error ? err.message : String(err),
+      };
+      yield {
+        type: "done",
+        sessionId: capturedSessionId || sessionId,
+        resultSubtype: "error_during_execution",
+      };
+    } finally {
+      this.activeProcesses.delete(capturedSessionId || processKey);
+    }
+  }
+
+  // --- Abort ---
+
+  abortQuery(sessionId: string): void {
+    const proc = this.activeProcesses.get(sessionId);
+    if (!proc) return;
+    console.log(`[${this.id}] Aborting session: ${sessionId}`);
+    proc.kill("SIGTERM");
+    setTimeout(() => {
+      try { proc.kill("SIGKILL"); } catch { /* already dead */ }
+    }, 2000);
+    this.activeProcesses.delete(sessionId);
+  }
+
+  // --- Helpers ---
+
+  protected spawnProcess(args: string[], cwd: string): ChildProcess {
+    console.log(`[${this.id}] spawn: ${this.cliCommand} ${args.join(" ")} (cwd=${cwd})`);
+    const proc = spawn(this.cliCommand, args, {
+      cwd,
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+    proc.stdin?.end();
+
+    proc.stderr?.on("data", (data: Buffer) => {
+      const text = data.toString().trim();
+      if (text) console.error(`[${this.id}] stderr: ${text}`);
+    });
+
+    return proc;
+  }
+
+  /** Read provider config from PPM settings */
+  protected getProviderConfig() {
+    try {
+      const ai = configService.get("ai");
+      return ai.providers[this.id] ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** Kill all active processes (cleanup on server start) */
+  cleanupAll(): void {
+    for (const [sessionId, proc] of this.activeProcesses) {
+      console.log(`[${this.id}] cleanup: killing orphaned process for session ${sessionId}`);
+      try { proc.kill("SIGTERM"); } catch { /* ignore */ }
+    }
+    this.activeProcesses.clear();
+  }
+}
+
+function waitForExit(proc: ChildProcess): Promise<number> {
+  return new Promise((resolve, reject) => {
+    proc.on("close", (code) => resolve(code ?? 1));
+    proc.on("error", (err) => reject(err));
+  });
+}

package/src/providers/cursor-cli/cursor-event-mapper.ts

@@ -0,0 +1,85 @@
+import type { ChatEvent } from "../provider.interface.ts";
+
+interface CursorRawEvent {
+  type: string;
+  subtype?: string;
+  session_id?: string;
+  model?: string;
+  message?: {
+    content?: Array<{
+      type?: string;
+      text?: string;
+      toolName?: string;
+      name?: string;
+      args?: unknown;
+      input?: unknown;
+      toolCallId?: string;
+      id?: string;
+    }>;
+  };
+  result?: string;
+}
+
+/**
+ * Map a single Cursor NDJSON line → ChatEvent[].
+ * Returns empty array for events we don't care about.
+ */
+export function mapCursorEvent(raw: unknown, sessionId: string): ChatEvent[] {
+  const event = raw as CursorRawEvent;
+  if (!event?.type) return [];
+
+  switch (event.type) {
+    case "system":
+      if (event.subtype === "init") {
+        return [{ type: "system", subtype: "init" }];
+      }
+      return [];
+
+    case "user":
+      return [];
+
+    case "assistant": {
+      const events: ChatEvent[] = [];
+      const content = event.message?.content;
+      if (!Array.isArray(content)) return [];
+
+      for (const part of content) {
+        if (!part) continue;
+
+        if (part.type === "text" && part.text) {
+          events.push({ type: "text", content: part.text });
+        }
+
+        if (part.type === "reasoning" && part.text) {
+          events.push({ type: "thinking", content: part.text });
+        }
+
+        if (part.type === "tool-call" || part.type === "tool_use") {
+          const toolName = normalizeToolName(part.toolName || part.name || "Unknown");
+          const toolId = part.toolCallId || part.id || crypto.randomUUID();
+          events.push({
+            type: "tool_use",
+            tool: toolName,
+            input: part.args || part.input || {},
+            toolUseId: toolId,
+          });
+        }
+      }
+      return events;
+    }
+
+    case "result":
+      return [];
+
+    default:
+      return [];
+  }
+}
+
+/** Normalize Cursor tool names to PPM standard */
+function normalizeToolName(name: string): string {
+  switch (name) {
+    case "ApplyPatch": return "Edit";
+    default: return name;
+  }
+}

package/src/providers/cursor-cli/cursor-history.ts

@@ -0,0 +1,207 @@
+import { createHash } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readdirSync } from "node:fs";
+import type { ChatMessage, SessionInfo } from "../provider.interface.ts";
+
+const DEFAULT_CHATS_DIR = join(homedir(), ".cursor", "chats");
+
+/**
+ * List all Cursor sessions found in ~/.cursor/chats/.
+ * Scans directory structure: {cwdHash}/{sessionId}/store.db
+ * Reads meta table for session name and createdAt.
+ * @param chatsDir — override for testing (defaults to ~/.cursor/chats)
+ */
+export async function listCursorSessions(providerId: string, chatsDir?: string): Promise<SessionInfo[]> {
+  const dir = chatsDir ?? DEFAULT_CHATS_DIR;
+  if (!existsSync(dir)) return [];
+  const { Database } = await import("bun:sqlite");
+  const sessions: SessionInfo[] = [];
+
+  try {
+    for (const cwdHash of readdirSync(dir)) {
+      const cwdDir = join(dir, cwdHash);
+      try {
+        for (const sessionId of readdirSync(cwdDir)) {
+          const dbPath = join(cwdDir, sessionId, "store.db");
+          if (!existsSync(dbPath)) continue;
+
+          let title = `Cursor ${sessionId.slice(0, 8)}`;
+          let createdAt = new Date().toISOString();
+
+          // Read meta table for name + createdAt (value is hex-encoded JSON)
+          try {
+            const db = new Database(dbPath, { readonly: true });
+            const row = db.query("SELECT value FROM meta LIMIT 1").get() as { value: string | Buffer } | null;
+            db.close();
+            if (row?.value) {
+              const hex = typeof row.value === "string" ? row.value : Buffer.from(row.value).toString("utf-8");
+              const json = Buffer.from(hex, "hex").toString("utf-8");
+              const meta = JSON.parse(json);
+              if (meta.name) title = meta.name.split("\n")[0].slice(0, 80);
+              if (meta.createdAt) createdAt = new Date(meta.createdAt).toISOString();
+            }
+          } catch { /* use defaults */ }
+
+          sessions.push({ id: sessionId, providerId, title, createdAt });
+        }
+      } catch { /* skip unreadable dir */ }
+    }
+  } catch { /* skip if chats dir unreadable */ }
+
+  return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+}
+
+/**
+ * Load chat history from Cursor's SQLite DAG storage.
+ * Path: ~/.cursor/chats/{MD5(cwd)}/{sessionId}/store.db
+ * Falls back to scanning all cwdHash dirs if projectPath doesn't match.
+ */
+export async function loadCursorHistory(
+  sessionId: string,
+  projectPath?: string,
+  chatsDir?: string,
+): Promise<ChatMessage[]> {
+  const baseDir = chatsDir ?? DEFAULT_CHATS_DIR;
+  let dbPath: string | null = null;
+
+  // Try direct path first (fast path when projectPath is known)
+  if (projectPath) {
+    const cwdHash = createHash("md5").update(projectPath).digest("hex");
+    const candidate = join(baseDir, cwdHash, sessionId, "store.db");
+    if (existsSync(candidate)) dbPath = candidate;
+  }
+
+  // Fallback: scan all cwdHash dirs for this sessionId
+  if (!dbPath && existsSync(baseDir)) {
+    try {
+      for (const cwdHash of readdirSync(baseDir)) {
+        const candidate = join(baseDir, cwdHash, sessionId, "store.db");
+        if (existsSync(candidate)) { dbPath = candidate; break; }
+      }
+    } catch { /* skip */ }
+  }
+
+  if (!dbPath) return [];
+
+  try {
+    // Use Bun's native SQLite
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(dbPath, { readonly: true });
+
+    const blobs = db
+      .query("SELECT rowid, id, data FROM blobs ORDER BY rowid")
+      .all() as Array<{ rowid: number; id: string; data: Buffer }>;
+    db.close();
+
+    return parseDagBlobs(blobs, sessionId);
+  } catch (err) {
+    console.warn(`[cursor-history] Failed to load session ${sessionId}:`, err);
+    return [];
+  }
+}
+
+/** Parse DAG blobs into ordered ChatMessages */
+function parseDagBlobs(
+  blobs: Array<{ rowid: number; id: string; data: Buffer }>,
+  _sessionId: string,
+): ChatMessage[] {
+  const messages: ChatMessage[] = [];
+
+  for (const blob of blobs) {
+    try {
+      const text = extractTextContent(blob.data);
+      if (!text) continue;
+
+      // Try to parse as JSON
+      try {
+        const parsed = JSON.parse(text);
+
+        // Format: { role: "...", content: "..." | [...] } — structured message
+        // Skip system prompts — they're huge and not useful for history
+        if (parsed.role === "system") continue;
+        if (parsed.role && parsed.content) {
+          let content: string;
+          if (typeof parsed.content === "string") {
+            content = parsed.content;
+          } else if (Array.isArray(parsed.content)) {
+            // Content parts: [{ type: "text", text: "..." }, ...]
+            content = parsed.content
+              .filter((p: any) => p.type === "text" && p.text)
+              .map((p: any) => p.text)
+              .join("\n") || JSON.stringify(parsed.content);
+          } else {
+            content = JSON.stringify(parsed.content);
+          }
+          // Filter out Cursor's injected <user_info> system context messages
+          if (parsed.role === "user" && /^<user_info>\s/i.test(content.trimStart())) continue;
+          // Strip Cursor's <user_query> wrapper from user messages
+          if (parsed.role === "user") {
+            const match = content.match(/<user_query>\s*([\s\S]*?)\s*<\/user_query>/);
+            if (match?.[1]) content = match[1];
+          }
+          messages.push({
+            id: blob.id,
+            role: parsed.role,
+            content,
+            timestamp: new Date().toISOString(),
+          });
+          continue;
+        }
+
+        // Format: [{ type: "text", text: "..." }] — content parts array
+        if (Array.isArray(parsed)) {
+          const textParts = parsed
+            .filter((p: any) => p.type === "text" && p.text)
+            .map((p: any) => p.text)
+            .join("\n");
+          if (textParts) {
+            messages.push({
+              id: blob.id,
+              role: messages.length % 2 === 0 ? "user" : "assistant",
+              content: textParts,
+              timestamp: new Date().toISOString(),
+            });
+            continue;
+          }
+        }
+      } catch { /* not JSON */ }
+    } catch { /* skip corrupt blob */ }
+  }
+
+  return messages;
+}
+
+/**
+ * Extract readable text from a DAG blob.
+ * Handles 2 known formats:
+ * 1. UTF-8 JSON string starting with { or [ (role/content messages)
+ * 2. JSON array (content parts like [{type:"text",text:"..."}])
+ * Skips binary DAG metadata blobs (parent refs, headers).
+ */
+function extractTextContent(data: Buffer | Uint8Array): string | null {
+  if (!data || data.length === 0) return null;
+
+  const buf = Buffer.from(data);
+
+  // Quick binary check: if first byte is not printable ASCII, it's a DAG metadata blob
+  const firstByte = buf[0];
+  if (firstByte !== undefined && firstByte < 0x20 && firstByte !== 0x0a && firstByte !== 0x0d && firstByte !== 0x09) {
+    return null;
+  }
+
+  const text = buf.toString("utf-8");
+
+  // Only accept clean JSON starting with { or [
+  if (text.startsWith("{") || text.startsWith("[")) {
+    // Validate it's actually parseable JSON
+    try {
+      JSON.parse(text);
+      return text;
+    } catch {
+      return null;
+    }
+  }
+
+  return null;
+}

package/src/providers/cursor-cli/cursor-provider.ts

@@ -0,0 +1,146 @@
+import { CliProvider } from "../cli-provider-base.ts";
+import { mapCursorEvent } from "./cursor-event-mapper.ts";
+import { listCursorSessions, loadCursorHistory } from "./cursor-history.ts";
+import type { ChatEvent, ChatMessage, SessionInfo, ModelOption } from "../provider.interface.ts";
+import type { ChildProcess } from "node:child_process";
+
+const TRUST_PATTERNS = [
+  /workspace trust required/i,
+  /do you trust the contents/i,
+  /pass --trust/i,
+];
+
+/**
+ * Cursor CLI provider — spawns `cursor-agent` with NDJSON streaming.
+ * Extends CliProvider with Cursor-specific event mapping, arg building,
+ * workspace trust auto-retry, and SQLite DAG history.
+ */
+export class CursorCliProvider extends CliProvider {
+  readonly id = "cursor";
+  readonly name = "Cursor";
+  readonly cliCommand = "cursor-agent";
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      const cmd = process.platform === "win32" ? "where" : "which";
+      const proc = Bun.spawn([cmd, "cursor-agent"], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+      return proc.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
+
+  buildArgs(params: {
+    sessionId?: string;
+    message: string;
+    model?: string;
+    permissionMode?: string;
+    isResume: boolean;
+  }): string[] {
+    const args: string[] = [];
+
+    if (params.sessionId && params.isResume) {
+      args.push(`--resume=${params.sessionId}`);
+    }
+
+    args.push("-p", params.message);
+
+    if (!params.isResume && params.model) {
+      args.push("--model", params.model);
+    }
+
+    args.push("--output-format", "stream-json");
+
+    // Permission mode → CLI flags
+    const mode = params.permissionMode || "default";
+    if (mode === "bypassPermissions") {
+      args.push("-f");
+    }
+
+    return args;
+  }
+
+  mapEvent(raw: unknown, sessionId: string): ChatEvent[] {
+    return mapCursorEvent(raw, sessionId);
+  }
+
+  extractSessionId(raw: unknown): string | null {
+    const obj = raw as Record<string, unknown>;
+    if (obj?.type === "system" && obj?.subtype === "init") {
+      return (obj.session_id as string) || null;
+    }
+    return null;
+  }
+
+  // Override listSessions to include Cursor's native history
+  override async listSessions(): Promise<SessionInfo[]> {
+    const inMemory = await super.listSessions();
+    try {
+      const native = await listCursorSessions(this.id);
+      // Merge: in-memory first, then native (deduplicated)
+      const seen = new Set(inMemory.map((s) => s.id));
+      const merged = [...inMemory];
+      for (const s of native) {
+        if (!seen.has(s.id)) merged.push(s);
+      }
+      return merged;
+    } catch {
+      return inMemory;
+    }
+  }
+
+  // Optional: load history from SQLite
+  async getMessages(sessionId: string): Promise<ChatMessage[]> {
+    const meta = this.sessions.get(sessionId);
+    return loadCursorHistory(sessionId, meta?.projectPath);
+  }
+
+  /** Cached models list with TTL from `cursor-agent --list-models` */
+  private modelsCache: { models: ModelOption[]; expiry: number } | null = null;
+  private static CACHE_TTL = 5 * 60 * 1000; // 5 min
+
+  async listModels(): Promise<ModelOption[]> {
+    if (this.modelsCache && Date.now() < this.modelsCache.expiry) {
+      return this.modelsCache.models;
+    }
+    try {
+      const proc = Bun.spawn(["cursor-agent", "--list-models"], {
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const timeout = setTimeout(() => proc.kill(), 10_000);
+      const text = await new Response(proc.stdout).text();
+      clearTimeout(timeout);
+      await proc.exited;
+      const models: ModelOption[] = [];
+      for (const line of text.split("\n")) {
+        // Format: "model-id - Model Label" or "model-id - Model Label  (current, default)"
+        const match = line.match(/^(\S+)\s+-\s+(.+?)(?:\s+\(.*\))?$/);
+        if (match?.[1] && match[2]) {
+          models.push({ value: match[1], label: match[2].trim() });
+        }
+      }
+      if (models.length > 0) {
+        this.modelsCache = { models, expiry: Date.now() + CursorCliProvider.CACHE_TTL };
+      }
+      return models;
+    } catch {
+      return [];
+    }
+  }
+
+  // Workspace trust detection: log warning so user knows to re-run with --trust
+  protected override spawnProcess(args: string[], cwd: string): ChildProcess {
+    const proc = super.spawnProcess(args, cwd);
+
+    proc.stderr?.on("data", (data: Buffer) => {
+      const text = data.toString();
+      if (TRUST_PATTERNS.some((p) => p.test(text))) {
+        console.warn("[cursor] Workspace trust prompt detected. Re-run with bypassPermissions mode or add --trust flag.");
+      }
+    });
+
+    return proc;
+  }
+}

package/src/providers/mock-provider.ts

@@ -167,7 +167,7 @@ export class MockProvider implements AIProvider {
     }
   }
 
-  getMessages(sessionId: string): ChatMessage[] {
+  async getMessages(sessionId: string): Promise<ChatMessage[]> {
     return this.messageHistory.get(sessionId) ?? [];
   }
 }

package/src/providers/provider.interface.ts

@@ -8,4 +8,5 @@ export type {
   ToolApprovalHandler,
   UsageInfo,
   SendMessageOpts,
+  ModelOption,
 } from "../types/chat.ts";