@hienlh/ppm 0.5.21 → 0.6.1

package/src/services/db.service.ts

@@ -0,0 +1,303 @@
+import { Database } from "bun:sqlite";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { mkdirSync, existsSync } from "node:fs";
+
+const PPM_DIR = resolve(homedir(), ".ppm");
+const CURRENT_SCHEMA_VERSION = 1;
+
+let db: Database | null = null;
+let dbProfile: string | null = null;
+
+/** Set DB profile before first access. "dev" → ppm.dev.db, null → ppm.db */
+export function setDbProfile(profile: string | null): void {
+  if (db) throw new Error("Cannot change DB profile after DB is open");
+  dbProfile = profile;
+}
+
+function getDbPath(): string {
+  if (dbProfile) return resolve(PPM_DIR, `ppm.${dbProfile}.db`);
+  return resolve(PPM_DIR, "ppm.db");
+}
+
+/** Get or create the singleton DB instance (lazy init) */
+export function getDb(): Database {
+  if (db) return db;
+  if (!existsSync(PPM_DIR)) mkdirSync(PPM_DIR, { recursive: true });
+  db = new Database(getDbPath());
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  runMigrations(db);
+  return db;
+}
+
+/** Close the DB (for graceful shutdown or tests) */
+export function closeDb(): void {
+  if (db) { db.close(); db = null; }
+}
+
+/** For tests: open an isolated in-memory DB with schema applied */
+export function openTestDb(): Database {
+  const testDb = new Database(":memory:");
+  testDb.exec("PRAGMA journal_mode = WAL");
+  testDb.exec("PRAGMA foreign_keys = ON");
+  runMigrations(testDb);
+  return testDb;
+}
+
+/** Override the singleton with a custom DB instance (for tests) */
+export function setDb(instance: Database): void {
+  if (db) db.close();
+  db = instance;
+}
+
+// ---------------------------------------------------------------------------
+// Schema migrations
+// ---------------------------------------------------------------------------
+
+function runMigrations(database: Database): void {
+  const row = database.query("PRAGMA user_version").get() as { user_version: number };
+  const current = row.user_version;
+
+  if (current < 1) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS config (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS projects (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        path TEXT NOT NULL UNIQUE,
+        name TEXT NOT NULL UNIQUE,
+        color TEXT,
+        sort_order INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS session_map (
+        ppm_id TEXT PRIMARY KEY,
+        sdk_id TEXT NOT NULL,
+        project_name TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS push_subscriptions (
+        endpoint TEXT PRIMARY KEY,
+        p256dh TEXT NOT NULL,
+        auth TEXT NOT NULL,
+        expiration_time TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS session_logs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS usage_history (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        cost_usd REAL,
+        input_tokens INTEGER,
+        output_tokens INTEGER,
+        model TEXT,
+        session_id TEXT,
+        project_name TEXT,
+        five_hour_pct REAL,
+        weekly_pct REAL,
+        recorded_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_session_logs_session ON session_logs(session_id);
+      CREATE INDEX IF NOT EXISTS idx_session_logs_created ON session_logs(created_at);
+      CREATE INDEX IF NOT EXISTS idx_usage_session ON usage_history(session_id);
+      CREATE INDEX IF NOT EXISTS idx_usage_recorded ON usage_history(recorded_at);
+      CREATE INDEX IF NOT EXISTS idx_projects_sort ON projects(sort_order);
+
+      PRAGMA user_version = 1;
+    `);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Config helpers
+// ---------------------------------------------------------------------------
+
+export function getConfigValue(key: string): string | null {
+  const row = getDb().query("SELECT value FROM config WHERE key = ?").get(key) as { value: string } | null;
+  return row?.value ?? null;
+}
+
+export function setConfigValue(key: string, value: string): void {
+  getDb().query(
+    "INSERT INTO config (key, value, updated_at) VALUES (?, ?, datetime('now')) ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at",
+  ).run(key, value);
+}
+
+export function getAllConfig(): Record<string, string> {
+  const rows = getDb().query("SELECT key, value FROM config").all() as { key: string; value: string }[];
+  const result: Record<string, string> = {};
+  for (const r of rows) result[r.key] = r.value;
+  return result;
+}
+
+export function deleteConfigValue(key: string): void {
+  getDb().query("DELETE FROM config WHERE key = ?").run(key);
+}
+
+// ---------------------------------------------------------------------------
+// Project helpers
+// ---------------------------------------------------------------------------
+
+export interface ProjectRow {
+  id: number;
+  path: string;
+  name: string;
+  color: string | null;
+  sort_order: number;
+}
+
+export function getProjects(): ProjectRow[] {
+  return getDb().query("SELECT id, path, name, color, sort_order FROM projects ORDER BY sort_order, id").all() as ProjectRow[];
+}
+
+export function upsertProject(path: string, name: string, color?: string | null): void {
+  const maxOrder = (getDb().query("SELECT COALESCE(MAX(sort_order), -1) as m FROM projects").get() as { m: number }).m;
+  getDb().query(
+    "INSERT INTO projects (path, name, color, sort_order) VALUES (?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET name = excluded.name, color = excluded.color",
+  ).run(path, name, color ?? null, maxOrder + 1);
+}
+
+export function deleteProject(nameOrPath: string): void {
+  getDb().query("DELETE FROM projects WHERE name = ? OR path = ?").run(nameOrPath, nameOrPath);
+}
+
+export function updateProject(currentName: string, newName: string, newPath: string, color?: string | null): void {
+  getDb().query(
+    "UPDATE projects SET name = ?, path = ?, color = ? WHERE name = ?",
+  ).run(newName, newPath, color ?? null, currentName);
+}
+
+// ---------------------------------------------------------------------------
+// Session map helpers
+// ---------------------------------------------------------------------------
+
+export function getSessionMapping(ppmId: string): string | null {
+  const row = getDb().query("SELECT sdk_id FROM session_map WHERE ppm_id = ?").get(ppmId) as { sdk_id: string } | null;
+  return row?.sdk_id ?? null;
+}
+
+export function setSessionMapping(ppmId: string, sdkId: string, projectName?: string): void {
+  getDb().query(
+    "INSERT INTO session_map (ppm_id, sdk_id, project_name) VALUES (?, ?, ?) ON CONFLICT(ppm_id) DO UPDATE SET sdk_id = excluded.sdk_id, project_name = excluded.project_name",
+  ).run(ppmId, sdkId, projectName ?? null);
+}
+
+export function getAllSessionMappings(): Record<string, string> {
+  const rows = getDb().query("SELECT ppm_id, sdk_id FROM session_map").all() as { ppm_id: string; sdk_id: string }[];
+  const result: Record<string, string> = {};
+  for (const r of rows) result[r.ppm_id] = r.sdk_id;
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Push subscription helpers
+// ---------------------------------------------------------------------------
+
+export interface PushSubRow {
+  endpoint: string;
+  p256dh: string;
+  auth: string;
+  expiration_time: string | null;
+}
+
+export function getPushSubscriptions(): PushSubRow[] {
+  return getDb().query("SELECT endpoint, p256dh, auth, expiration_time FROM push_subscriptions").all() as PushSubRow[];
+}
+
+export function upsertPushSubscription(endpoint: string, p256dh: string, auth: string, expirationTime?: string | null): void {
+  getDb().query(
+    "INSERT INTO push_subscriptions (endpoint, p256dh, auth, expiration_time) VALUES (?, ?, ?, ?) ON CONFLICT(endpoint) DO UPDATE SET p256dh = excluded.p256dh, auth = excluded.auth, expiration_time = excluded.expiration_time",
+  ).run(endpoint, p256dh, auth, expirationTime ?? null);
+}
+
+export function deletePushSubscription(endpoint: string): void {
+  getDb().query("DELETE FROM push_subscriptions WHERE endpoint = ?").run(endpoint);
+}
+
+// ---------------------------------------------------------------------------
+// Session log helpers
+// ---------------------------------------------------------------------------
+
+export interface SessionLogRow {
+  id: number;
+  session_id: string;
+  level: string;
+  message: string;
+  created_at: string;
+}
+
+export function insertSessionLog(sessionId: string, level: string, message: string): void {
+  getDb().query(
+    "INSERT INTO session_logs (session_id, level, message) VALUES (?, ?, ?)",
+  ).run(sessionId, level, message);
+}
+
+export function getSessionLogs(sessionId: string, limit = 100): SessionLogRow[] {
+  return getDb().query(
+    "SELECT id, session_id, level, message, created_at FROM session_logs WHERE session_id = ? ORDER BY id DESC LIMIT ?",
+  ).all(sessionId, limit) as SessionLogRow[];
+}
+
+// ---------------------------------------------------------------------------
+// Usage history helpers
+// ---------------------------------------------------------------------------
+
+export interface UsageRow {
+  id: number;
+  cost_usd: number | null;
+  input_tokens: number | null;
+  output_tokens: number | null;
+  model: string | null;
+  session_id: string | null;
+  project_name: string | null;
+  five_hour_pct: number | null;
+  weekly_pct: number | null;
+  recorded_at: string;
+}
+
+export function insertUsageRecord(record: {
+  costUsd?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  model?: string;
+  sessionId?: string;
+  projectName?: string;
+  fiveHourPct?: number;
+  weeklyPct?: number;
+}): void {
+  getDb().query(
+    "INSERT INTO usage_history (cost_usd, input_tokens, output_tokens, model, session_id, project_name, five_hour_pct, weekly_pct) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+  ).run(
+    record.costUsd ?? null, record.inputTokens ?? null, record.outputTokens ?? null,
+    record.model ?? null, record.sessionId ?? null, record.projectName ?? null,
+    record.fiveHourPct ?? null, record.weeklyPct ?? null,
+  );
+}
+
+export function getUsageSince(since: string): UsageRow[] {
+  return getDb().query(
+    "SELECT * FROM usage_history WHERE recorded_at >= ? ORDER BY recorded_at DESC",
+  ).all(since) as UsageRow[];
+}
+
+export function getDbFilePath(): string {
+  return getDbPath();
+}
+
+// Auto-close on process exit
+process.on("beforeExit", closeDb);

package/src/services/push-notification.service.ts

@@ -1,11 +1,11 @@
 import webpush from "web-push";
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { resolve, dirname } from "node:path";
-import { homedir } from "node:os";
 import { configService } from "./config.service.ts";
 import type { PushConfig } from "../types/config.ts";
-
-const SUBS_PATH = resolve(homedir(), ".ppm", "push-subscriptions.json");
+import {
+  getPushSubscriptions,
+  upsertPushSubscription,
+  deletePushSubscription,
+} from "./db.service.ts";
 
 interface PushSubscriptionData {
   endpoint: string;
@@ -13,23 +13,6 @@ interface PushSubscriptionData {
   expirationTime?: number | null;
 }
 
-/** Load subscriptions from disk */
-function loadSubscriptions(): PushSubscriptionData[] {
-  try {
-    if (existsSync(SUBS_PATH)) {
-      return JSON.parse(readFileSync(SUBS_PATH, "utf-8"));
-    }
-  } catch { /* corrupt file — start fresh */ }
-  return [];
-}
-
-/** Save subscriptions to disk */
-function saveSubscriptions(subs: PushSubscriptionData[]): void {
-  const dir = dirname(SUBS_PATH);
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(SUBS_PATH, JSON.stringify(subs, null, 2), "utf-8");
-}
-
 class PushNotificationService {
   private initialized = false;
 
@@ -67,35 +50,40 @@ class PushNotificationService {
 
   /** Save a new push subscription */
   saveSubscription(sub: PushSubscriptionData): void {
-    const subs = loadSubscriptions();
-    // Deduplicate by endpoint
-    const filtered = subs.filter((s) => s.endpoint !== sub.endpoint);
-    filtered.push(sub);
-    saveSubscriptions(filtered);
+    upsertPushSubscription(
+      sub.endpoint,
+      sub.keys.p256dh,
+      sub.keys.auth,
+      sub.expirationTime != null ? String(sub.expirationTime) : null,
+    );
   }
 
   /** Remove a push subscription by endpoint */
   removeSubscription(endpoint: string): void {
-    const subs = loadSubscriptions();
-    saveSubscriptions(subs.filter((s) => s.endpoint !== endpoint));
+    deletePushSubscription(endpoint);
   }
 
   /** Send push notification to all subscriptions (fire-and-forget) */
   async notifyAll(title: string, body: string): Promise<void> {
     this.init();
-    const subs = loadSubscriptions();
-    if (subs.length === 0) return;
+    const dbSubs = getPushSubscriptions();
+    if (dbSubs.length === 0) return;
 
     const payload = JSON.stringify({ title, body });
     const expired: string[] = [];
 
+    const subs: PushSubscriptionData[] = dbSubs.map((r) => ({
+      endpoint: r.endpoint,
+      keys: { p256dh: r.p256dh, auth: r.auth },
+      expirationTime: r.expiration_time ? Number(r.expiration_time) : null,
+    }));
+
     await Promise.allSettled(
       subs.map(async (sub) => {
         try {
           await webpush.sendNotification(sub, payload);
         } catch (error: unknown) {
           const statusCode = (error as { statusCode?: number }).statusCode;
-          // 404 or 410 = subscription expired/invalid — mark for removal
           if (statusCode === 410 || statusCode === 404) {
             expired.push(sub.endpoint);
           }
@@ -103,12 +91,10 @@ class PushNotificationService {
       }),
     );
 
-    // Auto-cleanup expired subscriptions
+    for (const endpoint of expired) {
+      deletePushSubscription(endpoint);
+    }
     if (expired.length > 0) {
-      const remaining = loadSubscriptions().filter(
-        (s) => !expired.includes(s.endpoint),
-      );
-      saveSubscriptions(remaining);
       console.log(`[push] Removed ${expired.length} expired subscriptions`);
     }
   }

package/src/services/session-log.service.ts

@@ -1,43 +1,31 @@
-import { resolve } from "node:path";
-import { homedir } from "node:os";
-import { appendFileSync, mkdirSync, existsSync, readFileSync } from "node:fs";
-
-const SESSION_LOG_DIR = resolve(homedir(), ".ppm", "sessions");
-
-/** Ensure log directory exists */
-function ensureDir() {
-  if (!existsSync(SESSION_LOG_DIR)) mkdirSync(SESSION_LOG_DIR, { recursive: true });
-}
+import { insertSessionLog, getSessionLogs as dbGetSessionLogs } from "./db.service.ts";
 
 /** Redact sensitive values */
 function redact(text: string): string {
   return text
     .replace(/Token:\s*\S+/gi, "Token: [REDACTED]")
     .replace(/Bearer\s+\S+/gi, "Bearer [REDACTED]")
-    .replace(/password['":\s]+\S+/gi, "password: [REDACTED]")
-    .replace(/api[_-]?key['":\s]+\S+/gi, "api_key: [REDACTED]")
+    .replace(/password['\":\s]+\S+/gi, "password: [REDACTED]")
+    .replace(/api[_-]?key['\":\s]+\S+/gi, "api_key: [REDACTED]")
     .replace(/ANTHROPIC_API_KEY=\S+/gi, "ANTHROPIC_API_KEY=[REDACTED]")
-    .replace(/secret['":\s]+\S+/gi, "secret: [REDACTED]");
+    .replace(/secret['\":\s]+\S+/gi, "secret: [REDACTED]");
 }
 
-/** Append a log entry to a session's log file */
+/** Append a log entry to a session's log in SQLite */
 export function logSessionEvent(sessionId: string, level: string, message: string) {
-  ensureDir();
-  const ts = new Date().toISOString();
-  const logFile = resolve(SESSION_LOG_DIR, `${sessionId}.log`);
   try {
-    appendFileSync(logFile, `[${ts}] [${level}] ${redact(message)}\n`);
+    insertSessionLog(sessionId, level, redact(message));
   } catch { /* ignore write errors */ }
 }
 
-/** Read a session's log file (last N lines) */
+/** Read a session's log entries (last N lines) */
 export function getSessionLog(sessionId: string, tailLines = 100): string {
-  const logFile = resolve(SESSION_LOG_DIR, `${sessionId}.log`);
-  if (!existsSync(logFile)) return "";
   try {
-    const content = readFileSync(logFile, "utf-8");
-    const lines = content.split("\n");
-    return lines.slice(-tailLines).join("\n").trim();
+    const rows = dbGetSessionLogs(sessionId, tailLines);
+    // Reverse to chronological order (DB returns DESC)
+    return rows.reverse().map((r) =>
+      `[${r.created_at}] [${r.level}] ${r.message}`
+    ).join("\n").trim();
   } catch {
     return "";
   }

package/src/services/sqlite.service.ts

@@ -0,0 +1,145 @@
+import { Database } from "bun:sqlite";
+import { resolve } from "node:path";
+import { existsSync } from "node:fs";
+
+export interface TableInfo {
+  name: string;
+  rowCount: number;
+}
+
+export interface ColumnInfo {
+  cid: number;
+  name: string;
+  type: string;
+  notnull: boolean;
+  pk: boolean;
+  dflt_value: string | null;
+}
+
+export interface QueryResult {
+  columns: string[];
+  rows: Record<string, unknown>[];
+  rowsAffected: number;
+  changeType: "select" | "modify";
+}
+
+/** Auto-close idle databases after 5 minutes */
+const IDLE_TIMEOUT_MS = 5 * 60 * 1000;
+
+interface CachedDb {
+  db: Database;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+class SqliteService {
+  private cache = new Map<string, CachedDb>();
+
+  /** Resolve db path — supports both project-relative and absolute paths */
+  private resolvePath(projectPath: string, dbRelPath: string): string {
+    const isAbsolute = /^(\/|[A-Za-z]:[/\\])/.test(dbRelPath);
+    const abs = isAbsolute ? dbRelPath : resolve(projectPath, dbRelPath);
+    if (!isAbsolute && !abs.startsWith(projectPath)) throw new Error("Access denied: path outside project");
+    if (!existsSync(abs)) throw new Error(`Database not found: ${dbRelPath}`);
+    return abs;
+  }
+
+  /** Open (or reuse cached) database */
+  private open(absPath: string): Database {
+    const cached = this.cache.get(absPath);
+    if (cached) {
+      clearTimeout(cached.timer);
+      cached.timer = setTimeout(() => this.close(absPath), IDLE_TIMEOUT_MS);
+      return cached.db;
+    }
+    const db = new Database(absPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    const timer = setTimeout(() => this.close(absPath), IDLE_TIMEOUT_MS);
+    this.cache.set(absPath, { db, timer });
+    return db;
+  }
+
+  /** Close and remove from cache */
+  private close(absPath: string) {
+    const cached = this.cache.get(absPath);
+    if (!cached) return;
+    clearTimeout(cached.timer);
+    try { cached.db.close(); } catch { /* already closed */ }
+    this.cache.delete(absPath);
+  }
+
+  /** List all user tables with row counts */
+  getTables(projectPath: string, dbPath: string): TableInfo[] {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    const tables = db.query(
+      "SELECT name FROM sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all() as { name: string }[];
+
+    return tables.map((t) => {
+      const row = db.query(`SELECT COUNT(*) as cnt FROM "${t.name}"`).get() as { cnt: number };
+      return { name: t.name, rowCount: row.cnt };
+    });
+  }
+
+  /** Get column schema for a table */
+  getTableSchema(projectPath: string, dbPath: string, table: string): ColumnInfo[] {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    return db.query(`PRAGMA table_info("${table}")`).all() as ColumnInfo[];
+  }
+
+  /** Get paginated rows from a table */
+  getTableData(
+    projectPath: string, dbPath: string, table: string,
+    page = 1, limit = 100, orderBy?: string, orderDir: "ASC" | "DESC" = "ASC",
+  ): { columns: string[]; rows: Record<string, unknown>[]; total: number; page: number; limit: number } {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+
+    const total = (db.query(`SELECT COUNT(*) as cnt FROM "${table}"`).get() as { cnt: number }).cnt;
+    const offset = (page - 1) * limit;
+    const order = orderBy ? `ORDER BY "${orderBy}" ${orderDir}` : "";
+    const rows = db.query(`SELECT rowid, * FROM "${table}" ${order} LIMIT ? OFFSET ?`).all(limit, offset) as Record<string, unknown>[];
+
+    // Get column names from first row or pragma
+    const schema = db.query(`PRAGMA table_info("${table}")`).all() as { name: string }[];
+    const columns = ["rowid", ...schema.map((c) => c.name)];
+
+    return { columns, rows, total, page, limit };
+  }
+
+  /** Execute arbitrary SQL */
+  executeQuery(projectPath: string, dbPath: string, sql: string): QueryResult {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    const trimmed = sql.trim().toUpperCase();
+    const isSelect = trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN");
+
+    if (isSelect) {
+      const stmt = db.query(sql);
+      const rows = stmt.all() as Record<string, unknown>[];
+      const columns = rows.length > 0 ? Object.keys(rows[0]!) : [];
+      return { columns, rows, rowsAffected: 0, changeType: "select" };
+    }
+
+    const result = db.run(sql);
+    return { columns: [], rows: [], rowsAffected: result.changes, changeType: "modify" };
+  }
+
+  /** Update a single cell value */
+  updateCell(
+    projectPath: string, dbPath: string, table: string,
+    rowid: number, column: string, value: unknown,
+  ): void {
+    const abs = this.resolvePath(projectPath, dbPath);
+    const db = this.open(abs);
+    db.run(`UPDATE "${table}" SET "${column}" = ? WHERE rowid = ?`, [value as never, rowid]);
+  }
+
+  /** Close all cached databases (for shutdown) */
+  closeAll() {
+    for (const absPath of this.cache.keys()) this.close(absPath);
+  }
+}
+
+export const sqliteService = new SqliteService();