@hienlh/ppm 0.5.20 → 0.6.0

package/src/server/routes/sqlite.ts

@@ -0,0 +1,75 @@
+import { Hono } from "hono";
+import { sqliteService } from "../../services/sqlite.service.ts";
+import { ok, err } from "../../types/api.ts";
+
+type Env = { Variables: { projectPath: string; projectName: string } };
+
+export const sqliteRoutes = new Hono<Env>();
+
+/** GET /sqlite/tables?path=relative/path.db */
+sqliteRoutes.get("/tables", (c) => {
+  try {
+    const dbPath = c.req.query("path");
+    if (!dbPath) return c.json(err("Missing query parameter: path"), 400);
+    const tables = sqliteService.getTables(c.get("projectPath"), dbPath);
+    return c.json(ok(tables));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** GET /sqlite/schema?path=...&table=... */
+sqliteRoutes.get("/schema", (c) => {
+  try {
+    const dbPath = c.req.query("path");
+    const table = c.req.query("table");
+    if (!dbPath || !table) return c.json(err("Missing query parameters: path, table"), 400);
+    const schema = sqliteService.getTableSchema(c.get("projectPath"), dbPath, table);
+    return c.json(ok(schema));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** GET /sqlite/data?path=...&table=...&page=1&limit=100&orderBy=...&orderDir=ASC */
+sqliteRoutes.get("/data", (c) => {
+  try {
+    const dbPath = c.req.query("path");
+    const table = c.req.query("table");
+    if (!dbPath || !table) return c.json(err("Missing query parameters: path, table"), 400);
+    const page = parseInt(c.req.query("page") ?? "1", 10);
+    const limit = Math.min(parseInt(c.req.query("limit") ?? "100", 10), 1000);
+    const orderBy = c.req.query("orderBy");
+    const orderDir = c.req.query("orderDir") === "DESC" ? "DESC" : "ASC";
+    const data = sqliteService.getTableData(c.get("projectPath"), dbPath, table, page, limit, orderBy, orderDir as "ASC" | "DESC");
+    return c.json(ok(data));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** POST /sqlite/query — body: { path, sql } */
+sqliteRoutes.post("/query", async (c) => {
+  try {
+    const body = await c.req.json<{ path: string; sql: string }>();
+    if (!body.path || !body.sql) return c.json(err("Missing required fields: path, sql"), 400);
+    const result = sqliteService.executeQuery(c.get("projectPath"), body.path, body.sql);
+    return c.json(ok(result));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});
+
+/** PUT /sqlite/cell — body: { path, table, rowid, column, value } */
+sqliteRoutes.put("/cell", async (c) => {
+  try {
+    const body = await c.req.json<{ path: string; table: string; rowid: number; column: string; value: unknown }>();
+    if (!body.path || !body.table || body.rowid == null || !body.column) {
+      return c.json(err("Missing required fields: path, table, rowid, column"), 400);
+    }
+    sqliteService.updateCell(c.get("projectPath"), body.path, body.table, body.rowid, body.column, body.value);
+    return c.json(ok({ updated: true }));
+  } catch (e) {
+    return c.json(err((e as Error).message), 500);
+  }
+});

package/src/server/routes/tunnel.ts

@@ -1,14 +1,29 @@
 import { Hono } from "hono";
+import { networkInterfaces } from "node:os";
 import { tunnelService } from "../../services/tunnel.service.ts";
 import { configService } from "../../services/config.service.ts";
 import { ok, err } from "../../types/api.ts";
 
+/** Return first non-internal IPv4 address */
+function getLocalIp(): string | null {
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (net.family === "IPv4" && !net.internal) return net.address;
+    }
+  }
+  return null;
+}
+
 export const tunnelRoutes = new Hono();
 
-/** GET /api/tunnel — current tunnel status */
+/** GET /api/tunnel — current tunnel status + local URL */
 tunnelRoutes.get("/", (c) => {
   const url = tunnelService.getTunnelUrl();
-  return c.json(ok({ active: !!url, url }));
+  const port = configService.get("port") ?? 8080;
+  const localIp = getLocalIp();
+  const localUrl = localIp ? `http://${localIp}:${port}` : null;
+  return c.json(ok({ active: !!url, url, localUrl }));
 });
 
 /** POST /api/tunnel/start — start tunnel if not already running */

package/src/server/ws/chat.ts

@@ -2,6 +2,7 @@ import { chatService } from "../../services/chat.service.ts";
 import { providerRegistry } from "../../providers/registry.ts";
 import { resolveProjectPath } from "../helpers/resolve-project.ts";
 import { logSessionEvent } from "../../services/session-log.service.ts";
+import { listSessions as sdkListSessions } from "@anthropic-ai/claude-agent-sdk";
 import type { ChatWsClientMessage } from "../../types/api.ts";
 
 const PING_INTERVAL_MS = 15_000; // 15s keepalive
@@ -148,6 +149,16 @@ async function runStreamLoop(sessionId: string, providerId: string, content: str
       } else if (evType === "done") {
         logSessionEvent(sessionId, "DONE", `subtype=${ev.resultSubtype ?? "none"} turns=${ev.numTurns ?? "?"} ctx=${ev.contextWindowPct ?? "?"}%`);
         if (ev.contextWindowPct != null) lastContextWindowPct = ev.contextWindowPct;
+        // Fire-and-forget: fetch updated session title from SDK summary
+        sdkListSessions({ dir: entry.projectPath, limit: 50 }).then((sessions) => {
+          const found = sessions.find((s) => s.sessionId === sessionId || s.sessionId === ev.sessionId);
+          if (found?.summary) {
+            safeSend(sessionId, { type: "title_updated", title: found.summary });
+            // Also update in-memory session title
+            const session = chatService.getSession(sessionId);
+            if (session) session.title = found.summary;
+          }
+        }).catch(() => {});
         // Fire-and-forget push notification
         import("../../services/push-notification.service.ts").then(({ pushService }) => {
           const project = entry.projectName || "Project";
@@ -254,7 +265,18 @@ export const chatWebSocket = {
         sessionId,
         isStreaming: existing.isStreaming,
         pendingApproval: existing.pendingApprovalEvent ?? null,
+        sessionTitle: session?.title || null,
       }));
+      // Async: resolve title from SDK if in-memory title is generic
+      if (!session?.title || session.title === "Chat" || session.title === "Resumed Chat") {
+        sdkListSessions({ dir: projectPath, limit: 50 }).then((sessions) => {
+          const found = sessions.find((s) => s.sessionId === sessionId);
+          if (found?.summary) {
+            safeSend(sessionId, { type: "title_updated", title: found.summary });
+            if (session) session.title = found.summary;
+          }
+        }).catch(() => {});
+      }
       console.log(`[chat] session=${sessionId} FE reconnected (streaming=${existing.isStreaming}, catchUp=${existing.needsCatchUp})`);
       return;
     }
@@ -276,7 +298,17 @@ export const chatWebSocket = {
       needsCatchUp: false,
       catchUpText: "",
     });
-    ws.send(JSON.stringify({ type: "connected", sessionId }));
+    ws.send(JSON.stringify({ type: "connected", sessionId, sessionTitle: session?.title || null }));
+    // Async: resolve title from SDK if in-memory title is generic
+    if (!session?.title || session.title === "Chat" || session.title === "Resumed Chat") {
+      sdkListSessions({ dir: projectPath, limit: 50 }).then((sessions) => {
+        const found = sessions.find((s) => s.sessionId === sessionId);
+        if (found?.summary) {
+          safeSend(sessionId, { type: "title_updated", title: found.summary });
+          if (session) session.title = found.summary;
+        }
+      }).catch(() => {});
+    }
   },
 
   async message(ws: ChatWsSocket, msg: string | ArrayBuffer | Uint8Array) {

package/src/services/config.service.ts

@@ -1,68 +1,78 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { resolve, dirname } from "node:path";
+import { existsSync, readFileSync, renameSync } from "node:fs";
+import { resolve } from "node:path";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
-import yaml from "js-yaml";
-import type { PpmConfig } from "../types/config.ts";
+import type { PpmConfig, ProjectConfig } from "../types/config.ts";
 import { DEFAULT_CONFIG, sanitizeConfig } from "../types/config.ts";
+import {
+  getConfigValue,
+  setConfigValue,
+  getAllConfig,
+  getProjects,
+  upsertProject,
+  deleteProject as dbDeleteProject,
+  getDb,
+  getDbFilePath,
+} from "./db.service.ts";
 
 const PPM_DIR = resolve(homedir(), ".ppm");
-const GLOBAL_CONFIG_PATH = resolve(PPM_DIR, "config.yaml");
-const LOCAL_CONFIG_PATH = resolve(process.cwd(), "ppm.yaml");
+
+/** Top-level config keys stored in the config table (not projects) */
+const CONFIG_TABLE_KEYS: (keyof PpmConfig)[] = [
+  "device_name", "port", "host", "theme", "auth", "ai", "push",
+];
 
 class ConfigService {
   private config: PpmConfig = structuredClone(DEFAULT_CONFIG);
-  private configPath: string = GLOBAL_CONFIG_PATH;
 
-  /** Load config from: explicit path → ./ppm.yaml → ~/.ppm/config.yaml */
+  /** Load config from DB. If explicitPath given, import that YAML first. */
   load(explicitPath?: string): PpmConfig {
-    const searchPaths = [
-      explicitPath,
-      LOCAL_CONFIG_PATH,
-      GLOBAL_CONFIG_PATH,
-    ].filter(Boolean) as string[];
-
-    for (const p of searchPaths) {
-      const found = existsSync(p);
-      if (!found) {
-        console.log(`[config] Not found: ${p}`);
-        continue;
-      }
-      try {
-        const raw = readFileSync(p, "utf-8");
-        const parsed = yaml.load(raw) as Partial<PpmConfig> | null;
-        if (parsed) {
-          this.config = { ...structuredClone(DEFAULT_CONFIG), ...parsed };
-          this.configPath = p;
-          console.log(`[config] Loaded from: ${p}`);
-          // Auto-generate token if auth enabled but token is empty
-          if (this.config.auth.enabled && !this.config.auth.token) {
-            this.config.auth.token = randomBytes(16).toString("hex");
-            this.save();
-          }
-          // Fix invalid config values and persist corrections
-          if (sanitizeConfig(this.config)) {
-            this.save();
-          }
-          return this.config;
-        }
-        console.log(`[config] Empty or invalid YAML: ${p}`);
-      } catch (err) {
-        console.error(`[config] Error reading ${p}:`, (err as Error).message);
-      }
+    // Import explicit YAML if provided (e.g. `ppm start -c path`)
+    if (explicitPath && existsSync(explicitPath)) {
+      this.importFromYaml(explicitPath);
+    }
+
+    // Auto-migrate: if config.yaml exists but DB has no config rows
+    // Skip migration when using in-memory DB (tests)
+    if (!getDbFilePath().includes(":memory:")) {
+      this.migrateYamlIfNeeded();
+    }
+
+    // Load from DB
+    const dbConfig = getAllConfig();
+    const dbProjects = getProjects();
+
+    if (Object.keys(dbConfig).length > 0 || dbProjects.length > 0) {
+      this.config = this.assembleConfig(dbConfig, dbProjects);
+      console.log("[config] Loaded from SQLite");
+    } else {
+      console.log("[config] No config found, creating defaults");
+      this.config = this.createDefault();
+    }
+
+    // Auto-generate token if auth enabled but empty
+    if (this.config.auth.enabled && !this.config.auth.token) {
+      this.config.auth.token = randomBytes(16).toString("hex");
+      this.save();
+    }
+
+    if (sanitizeConfig(this.config)) {
+      this.save();
     }
 
-    // No config found — create default
-    console.log(`[config] No config found, creating default at ${GLOBAL_CONFIG_PATH}`);
-    this.config = this.createDefault();
     return this.config;
   }
 
-  /** Save current config to disk */
+  /** Save current config to DB */
   save(): void {
-    const dir = dirname(this.configPath);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    writeFileSync(this.configPath, yaml.dump(this.config), "utf-8");
+    for (const key of CONFIG_TABLE_KEYS) {
+      const value = this.config[key];
+      if (value !== undefined) {
+        setConfigValue(String(key), JSON.stringify(value));
+      }
+    }
+    // Sync projects to DB
+    this.syncProjectsToDb(this.config.projects);
   }
 
   /** Get a top-level config key */
@@ -70,9 +80,14 @@ class ConfigService {
     return this.config[key];
   }
 
-  /** Set a top-level config key */
+  /** Set a top-level config key (persists immediately) */
   set<K extends keyof PpmConfig>(key: K, value: PpmConfig[K]): void {
     this.config[key] = value;
+    if (key === "projects") {
+      this.syncProjectsToDb(value as ProjectConfig[]);
+    } else {
+      setConfigValue(String(key), JSON.stringify(value));
+    }
   }
 
   /** Get the full config object */
@@ -80,24 +95,133 @@ class ConfigService {
     return this.config;
   }
 
-  /** Get the path config was loaded from */
+  /** Get the DB file path (replaces getConfigPath for YAML) */
   getConfigPath(): string {
-    return this.configPath;
+    return getDbFilePath();
   }
 
-  /** Set the config path explicitly (for init command) */
-  setConfigPath(p: string): void {
-    this.configPath = p;
-  }
+  /** No-op — kept for backward compatibility (init command) */
+  setConfigPath(_p: string): void {}
+
+  // ── Private helpers ──────────────────────────────────────────────────
 
-  /** Create default config with auto-generated auth token */
   private createDefault(): PpmConfig {
     const config = structuredClone(DEFAULT_CONFIG);
     config.auth.token = randomBytes(16).toString("hex");
-    this.configPath = GLOBAL_CONFIG_PATH;
+    this.config = config;
     this.save();
     return config;
   }
+
+  private assembleConfig(
+    dbRows: Record<string, string>,
+    dbProjects: { path: string; name: string; color: string | null }[],
+  ): PpmConfig {
+    const config = structuredClone(DEFAULT_CONFIG);
+    for (const [key, jsonValue] of Object.entries(dbRows)) {
+      if (key in config && key !== "projects") {
+        try {
+          (config as any)[key] = JSON.parse(jsonValue);
+        } catch { /* keep default */ }
+      }
+    }
+    // Projects from dedicated table
+    config.projects = dbProjects.map((p) => ({
+      path: p.path,
+      name: p.name,
+      ...(p.color ? { color: p.color } : {}),
+    }));
+    return config;
+  }
+
+  private syncProjectsToDb(projects: ProjectConfig[]): void {
+    const db = getDb();
+    db.exec("DELETE FROM projects");
+    const stmt = db.query(
+      "INSERT INTO projects (path, name, color, sort_order) VALUES (?, ?, ?, ?)",
+    );
+    for (let i = 0; i < projects.length; i++) {
+      const p = projects[i]!;
+      stmt.run(p.path, p.name, p.color ?? null, i);
+    }
+  }
+
+  private migrateYamlIfNeeded(): void {
+    const yamlPaths = [
+      resolve(PPM_DIR, "config.yaml"),
+      resolve(PPM_DIR, "config.dev.yaml"),
+    ];
+    for (const yamlPath of yamlPaths) {
+      if (!existsSync(yamlPath)) continue;
+      const existing = getAllConfig();
+      if (Object.keys(existing).length > 0) return;
+      this.importFromYaml(yamlPath);
+      try {
+        renameSync(yamlPath, yamlPath + ".bak");
+        console.log(`[config] Migrated ${yamlPath} → SQLite (backup: .bak)`);
+      } catch {}
+    }
+    this.migrateSessionMapIfNeeded();
+    this.migratePushSubsIfNeeded();
+  }
+
+  private importFromYaml(path: string): void {
+    try {
+      const yaml = require("js-yaml");
+      const raw = readFileSync(path, "utf-8");
+      const parsed = yaml.load(raw) as Partial<PpmConfig> | null;
+      if (!parsed) return;
+      const merged = { ...structuredClone(DEFAULT_CONFIG), ...parsed };
+      for (const key of CONFIG_TABLE_KEYS) {
+        const value = (merged as any)[key];
+        if (value !== undefined) {
+          setConfigValue(String(key), JSON.stringify(value));
+        }
+      }
+      if (merged.projects?.length) {
+        this.syncProjectsToDb(merged.projects);
+      }
+    } catch (err) {
+      console.error(`[config] Error importing YAML ${path}:`, (err as Error).message);
+    }
+  }
+
+  private migrateSessionMapIfNeeded(): void {
+    const mapPath = resolve(PPM_DIR, "session-map.json");
+    if (!existsSync(mapPath)) return;
+    try {
+      const { setSessionMapping } = require("./db.service.ts");
+      const map = JSON.parse(readFileSync(mapPath, "utf-8")) as Record<string, string>;
+      for (const [ppmId, sdkId] of Object.entries(map)) {
+        setSessionMapping(ppmId, sdkId);
+      }
+      renameSync(mapPath, mapPath + ".bak");
+      console.log("[config] Migrated session-map.json → SQLite");
+    } catch {}
+  }
+
+  private migratePushSubsIfNeeded(): void {
+    const subsPath = resolve(PPM_DIR, "push-subscriptions.json");
+    if (!existsSync(subsPath)) return;
+    try {
+      const { upsertPushSubscription } = require("./db.service.ts");
+      const subs = JSON.parse(readFileSync(subsPath, "utf-8")) as Array<{
+        endpoint: string;
+        keys: { p256dh: string; auth: string };
+        expirationTime?: number | null;
+      }>;
+      for (const sub of subs) {
+        upsertPushSubscription(
+          sub.endpoint,
+          sub.keys.p256dh,
+          sub.keys.auth,
+          sub.expirationTime != null ? String(sub.expirationTime) : null,
+        );
+      }
+      renameSync(subsPath, subsPath + ".bak");
+      console.log("[config] Migrated push-subscriptions.json → SQLite");
+    } catch {}
+  }
 }
 
 /** Singleton config service */