@hienlh/ppm 0.10.4 → 0.11.0

package/src/server/routes/jira-watcher-routes.ts

@@ -0,0 +1,316 @@
+import { Hono } from "hono";
+import {
+  createWatcher, updateWatcher, deleteWatcher,
+  getWatchersByConfigId, getWatcherById,
+  getResultsByWatcherId, getResultById, softDeleteResult,
+  getWatcherStats, insertResult, markResultRead, getUnreadCount,
+} from "../../services/jira-watcher-db.service.ts";
+import { jiraWatcherService, clampInterval } from "../../services/jira-watcher.service.ts";
+import { jiraDebugService } from "../../services/jira-debug-session.service.ts";
+import { getDecryptedCredentials } from "../../services/jira-config.service.ts";
+import {
+  getIssue, updateIssue, getTransitions, transitionIssue,
+  searchText, searchIssues, getProjects, getFieldOptions, getAssignableUsers,
+} from "../../services/jira-api-client.ts";
+import { ok, err } from "../../types/api.ts";
+import type { JiraWatcherMode } from "../../types/jira.ts";
+
+/** Validate Jira issue key format (e.g. PROJ-123) */
+const ISSUE_KEY_RE = /^[A-Z][A-Z0-9_]+-\d+$/i;
+
+export const jiraWatcherRoutes = new Hono();
+
+// ── Watcher CRUD ──────────────────────────────────────────────────────
+
+jiraWatcherRoutes.get("/watchers", (c) => {
+  const configId = c.req.query("configId");
+  if (!configId) return c.json(err("configId query param required"), 400);
+  return c.json(ok(getWatchersByConfigId(parseInt(configId, 10))));
+});
+
+jiraWatcherRoutes.post("/watchers", async (c) => {
+  const body = await c.req.json<{
+    configId: number; name: string; jql: string;
+    promptTemplate?: string; intervalMs?: number; mode?: JiraWatcherMode;
+  }>();
+  if (!body.configId || !body.name || !body.jql) {
+    return c.json(err("configId, name, and jql are required"), 400);
+  }
+  if (body.mode && !["debug", "notify"].includes(body.mode)) {
+    return c.json(err("mode must be 'debug' or 'notify'"), 400);
+  }
+  const interval = body.intervalMs ? clampInterval(body.intervalMs) : 120000;
+  const watcher = createWatcher(body.configId, body.name, body.jql, {
+    promptTemplate: body.promptTemplate,
+    intervalMs: interval,
+    mode: body.mode,
+  });
+  // Auto-start if enabled
+  jiraWatcherService.startWatcher(watcher.id, watcher.intervalMs);
+  return c.json(ok(watcher), 201);
+});
+
+jiraWatcherRoutes.put("/watchers/:id", async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  const body = await c.req.json<Partial<{
+    name: string; jql: string; promptTemplate: string | null;
+    intervalMs: number; enabled: boolean; mode: JiraWatcherMode;
+  }>>();
+  if (body.intervalMs !== undefined) body.intervalMs = clampInterval(body.intervalMs);
+  if (body.mode !== undefined && !["debug", "notify"].includes(body.mode)) {
+    return c.json(err("mode must be 'debug' or 'notify'"), 400);
+  }
+  const watcher = updateWatcher(id, body);
+  if (!watcher) return c.json(err("Watcher not found"), 404);
+  // Restart or stop based on enabled state
+  if (watcher.enabled) {
+    jiraWatcherService.startWatcher(watcher.id, watcher.intervalMs);
+  } else {
+    jiraWatcherService.stopWatcher(watcher.id);
+  }
+  return c.json(ok(watcher));
+});
+
+jiraWatcherRoutes.delete("/watchers/:id", (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  jiraWatcherService.stopWatcher(id);
+  if (!deleteWatcher(id)) return c.json(err("Watcher not found"), 404);
+  return c.json(ok({ deleted: true }));
+});
+
+jiraWatcherRoutes.post("/watchers/test-jql", async (c) => {
+  const body = await c.req.json<{ configId: number; jql: string }>();
+  if (!body.configId || !body.jql) return c.json(err("configId and jql required"), 400);
+  const creds = getDecryptedCredentials(body.configId);
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try {
+    const response = await searchIssues(creds, body.jql, undefined, 20);
+    return c.json(ok({ issues: response.issues, total: response.total }));
+  } catch (e: any) {
+    return c.json(err(`JQL search failed: ${e.message}`), 502);
+  }
+});
+
+jiraWatcherRoutes.post("/watchers/:id/pull", async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  try {
+    const count = await jiraWatcherService.pollWatcher(id, "manual");
+    return c.json(ok({ polled: true, newIssues: count }));
+  } catch (e: any) {
+    return c.json(err(`Poll failed: ${e.message}`), 502);
+  }
+});
+
+jiraWatcherRoutes.post("/watchers/pull-all", async (c) => {
+  try {
+    const all = (await import("../../services/jira-watcher-db.service.ts")).getAllEnabledWatchers();
+    let total = 0;
+    for (const w of all) {
+      try { total += await jiraWatcherService.pollWatcher(w.id, "manual"); } catch {}
+    }
+    return c.json(ok({ polled: true, watcherCount: all.length, newIssues: total }));
+  } catch (e: any) {
+    return c.json(err(`Pull failed: ${e.message}`), 502);
+  }
+});
+
+// ── Debug sessions ───────────────────────────────────────────────────
+
+jiraWatcherRoutes.post("/results/:id/debug", async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  const body = await c.req.json<{ prompt?: string }>().catch(() => ({} as { prompt?: string }));
+  const result = getResultById(id);
+  if (!result) return c.json(err("Result not found"), 404);
+  if (result.status !== "pending" && result.status !== "failed") {
+    return c.json(err("Result must be pending or failed to debug"), 400);
+  }
+  try {
+    jiraDebugService.enqueue(id, body.prompt);
+    return c.json(ok({ queued: true }));
+  } catch (e: any) {
+    return c.json(err(e.message), 500);
+  }
+});
+
+jiraWatcherRoutes.post("/results/:id/resume", async (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  const body = await c.req.json<{ prompt?: string }>().catch(() => ({} as { prompt?: string }));
+  const result = getResultById(id);
+  if (!result) return c.json(err("Result not found"), 404);
+  if (result.status !== "failed") return c.json(err("Only failed results can be resumed"), 400);
+  if (!result.sessionId) return c.json(err("No session to resume"), 400);
+  try {
+    jiraDebugService.resumeDebug(id, body.prompt);
+    return c.json(ok({ resumed: true }));
+  } catch (e: any) {
+    return c.json(err(e.message), 500);
+  }
+});
+
+jiraWatcherRoutes.post("/results/:id/cancel", (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  const cancelled = jiraDebugService.cancelDebug(id);
+  if (!cancelled) return c.json(err("No active debug session for this result"), 404);
+  return c.json(ok({ cancelled: true }));
+});
+
+jiraWatcherRoutes.patch("/results/:id/read", (c) => {
+  const id = parseInt(c.req.param("id"), 10);
+  if (!markResultRead(id)) return c.json(err("Result not found or already read"), 404);
+  return c.json(ok({ read: true }));
+});
+
+jiraWatcherRoutes.get("/results/unread-count", (c) => {
+  return c.json(ok({ count: getUnreadCount() }));
+});
+
+// ── Results ───────────────────────────────────────────────────────────
+
+jiraWatcherRoutes.get("/results", (c) => {
+  const watcherId = c.req.query("watcherId");
+  const status = c.req.query("status");
+  const limit = parseInt(c.req.query("limit") ?? "50", 10);
+  const offset = parseInt(c.req.query("offset") ?? "0", 10);
+  const results = getResultsByWatcherId(
+    watcherId ? parseInt(watcherId, 10) : undefined,
+    { status: status ?? undefined, limit, offset },
+  );
+  return c.json(ok(results));
+});
+
+jiraWatcherRoutes.get("/results/stats", (c) => {
+  return c.json(ok(getWatcherStats()));
+});
+
+jiraWatcherRoutes.get("/results/:id", (c) => {
+  const result = getResultById(parseInt(c.req.param("id"), 10));
+  if (!result) return c.json(err("Result not found"), 404);
+  return c.json(ok(result));
+});
+
+jiraWatcherRoutes.delete("/results/:id", (c) => {
+  if (!softDeleteResult(parseInt(c.req.param("id"), 10))) {
+    return c.json(err("Result not found"), 404);
+  }
+  return c.json(ok({ deleted: true }));
+});
+
+// ── Manual ticket tracking ────────────────────────────────────────────
+
+jiraWatcherRoutes.post("/results/manual", async (c) => {
+  const body = await c.req.json<{ configId: number; issueKey: string }>();
+  if (!body.configId || !body.issueKey) return c.json(err("configId and issueKey required"), 400);
+  if (!ISSUE_KEY_RE.test(body.issueKey)) return c.json(err("Invalid issueKey format"), 400);
+  const creds = getDecryptedCredentials(body.configId);
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try {
+    const issue = await getIssue(creds, body.issueKey);
+    const { inserted, resultId } = insertResult(
+      null, issue.key, issue.fields.summary, issue.fields.updated, "manual",
+    );
+    if (!inserted) return c.json(err("Issue already tracked"), 409);
+    return c.json(ok({ resultId, issueKey: issue.key }), 201);
+  } catch (e: any) {
+    return c.json(err(`Jira API error: ${e.message}`), 502);
+  }
+});
+
+// ── Search ────────────────────────────────────────────────────────────
+
+jiraWatcherRoutes.get("/search/:configId", async (c) => {
+  const configId = parseInt(c.req.param("configId"), 10);
+  const q = c.req.query("q") ?? "";
+  if (!q) return c.json(err("q query param required"), 400);
+  const creds = getDecryptedCredentials(configId);
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try {
+    const results = await searchText(creds, q);
+    return c.json(ok(results));
+  } catch (e: any) {
+    return c.json(err(`Search failed: ${e.message}`), 502);
+  }
+});
+
+// ── Ticket proxy ──────────────────────────────────────────────────────
+
+jiraWatcherRoutes.get("/ticket/:configId/:issueKey", async (c) => {
+  const issueKey = c.req.param("issueKey");
+  if (!ISSUE_KEY_RE.test(issueKey)) return c.json(err("Invalid issueKey format"), 400);
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try {
+    const issue = await getIssue(creds, issueKey);
+    return c.json(ok(issue));
+  } catch (e: any) {
+    return c.json(err(`Jira error: ${e.message}`), 502);
+  }
+});
+
+jiraWatcherRoutes.put("/ticket/:configId/:issueKey", async (c) => {
+  const issueKey = c.req.param("issueKey");
+  if (!ISSUE_KEY_RE.test(issueKey)) return c.json(err("Invalid issueKey format"), 400);
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  const body = await c.req.json<{ fields: Record<string, unknown> }>();
+  try {
+    await updateIssue(creds, issueKey, body.fields ?? body);
+    return c.json(ok({ updated: true }));
+  } catch (e: any) {
+    return c.json(err(`Jira error: ${e.message}`), 502);
+  }
+});
+
+jiraWatcherRoutes.get("/ticket/:configId/:issueKey/transitions", async (c) => {
+  const issueKey = c.req.param("issueKey");
+  if (!ISSUE_KEY_RE.test(issueKey)) return c.json(err("Invalid issueKey format"), 400);
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try {
+    const transitions = await getTransitions(creds, issueKey);
+    return c.json(ok(transitions));
+  } catch (e: any) {
+    return c.json(err(`Jira error: ${e.message}`), 502);
+  }
+});
+
+jiraWatcherRoutes.post("/ticket/:configId/:issueKey/transition", async (c) => {
+  const issueKey = c.req.param("issueKey");
+  if (!ISSUE_KEY_RE.test(issueKey)) return c.json(err("Invalid issueKey format"), 400);
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  const body = await c.req.json<{ transitionId: string }>();
+  if (!body.transitionId) return c.json(err("transitionId required"), 400);
+  try {
+    await transitionIssue(creds, issueKey, body.transitionId);
+    return c.json(ok({ transitioned: true }));
+  } catch (e: any) {
+    return c.json(err(`Jira error: ${e.message}`), 502);
+  }
+});
+
+// ── Metadata for filter builder ───────────────────────────────────────
+
+jiraWatcherRoutes.get("/metadata/:configId/projects", async (c) => {
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try { return c.json(ok(await getProjects(creds))); }
+  catch (e: any) { return c.json(err(e.message), 502); }
+});
+
+jiraWatcherRoutes.get("/metadata/:configId/assignees", async (c) => {
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  try { return c.json(ok(await getAssignableUsers(creds))); }
+  catch (e: any) { return c.json(err(e.message), 502); }
+});
+
+jiraWatcherRoutes.get("/metadata/:configId/:field", async (c) => {
+  const creds = getDecryptedCredentials(parseInt(c.req.param("configId"), 10));
+  if (!creds) return c.json(err("Invalid config"), 404);
+  const field = c.req.param("field") as "issuetype" | "priority" | "status";
+  if (!["issuetype", "priority", "status"].includes(field)) {
+    return c.json(err("Invalid field"), 400);
+  }
+  try { return c.json(ok(await getFieldOptions(creds, field))); }
+  catch (e: any) { return c.json(err(e.message), 502); }
+});

package/src/server/routes/jira.ts

@@ -0,0 +1,7 @@
+import { Hono } from "hono";
+import { jiraConfigRoutes } from "./jira-config-routes.ts";
+import { jiraWatcherRoutes } from "./jira-watcher-routes.ts";
+
+export const jiraRoutes = new Hono();
+jiraRoutes.route("/config", jiraConfigRoutes);
+jiraRoutes.route("/", jiraWatcherRoutes);

package/src/server/ws/chat.ts

@@ -54,12 +54,33 @@ export function hasActiveClient(): boolean {
   return false;
 }
 
+/** Broadcast event to ALL connected WebSocket clients across all sessions */
+export function broadcastGlobalEvent(event: unknown): void {
+  const json = JSON.stringify(event);
+  for (const entry of activeSessions.values()) {
+    for (const ws of entry.clients) {
+      try { ws.send(json); } catch {}
+    }
+  }
+}
+
 /** Remove a client from the session, cleaning up its ping interval */
 function evictClient(entry: SessionEntry, ws: ChatWsSocket): void {
   clearClientPing(entry, ws);
   entry.clients.delete(ws);
 }
 
+/**
+ * Forward an event to connected WS clients for a session (if any).
+ * Used by background processes (e.g. Jira debug) that run sessions server-side
+ * but want to stream events to any frontend client viewing that session.
+ */
+export function forwardEventToSession(sessionId: string, event: unknown): void {
+  const entry = activeSessions.get(sessionId);
+  if (!entry || entry.clients.size === 0) return; // no connected clients, silently drop
+  bufferAndBroadcast(sessionId, event);
+}
+
 /** Broadcast event to all connected clients for a session */
 function broadcast(sessionId: string, event: unknown): void {
   const entry = activeSessions.get(sessionId);

package/src/services/db.service.ts

@@ -3,7 +3,7 @@ import { resolve } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { encrypt, decrypt } from "../lib/account-crypto.ts";
 import { getPpmDir } from "./ppm-dir.ts";
-const CURRENT_SCHEMA_VERSION = 15;
+const CURRENT_SCHEMA_VERSION = 18;
 
 let db: Database | null = null;
 let dbProfile: string | null = null;
@@ -491,6 +491,70 @@ function runMigrations(database: Database): void {
       PRAGMA user_version = 17;
     `);
   }
+
+  if (current < 18) {
+    database.exec(`
+      CREATE TABLE IF NOT EXISTS jira_config (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        project_id INTEGER UNIQUE REFERENCES projects(id) ON DELETE CASCADE,
+        base_url TEXT NOT NULL,
+        email TEXT NOT NULL,
+        api_token_encrypted TEXT NOT NULL,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS jira_watchers (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        jira_config_id INTEGER NOT NULL REFERENCES jira_config(id) ON DELETE CASCADE,
+        name TEXT NOT NULL,
+        jql TEXT NOT NULL,
+        prompt_template TEXT,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        mode TEXT NOT NULL DEFAULT 'debug',
+        interval_ms INTEGER NOT NULL DEFAULT 120000,
+        last_polled_at TEXT,
+        created_at TEXT DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_jira_watchers_config
+        ON jira_watchers(jira_config_id);
+      CREATE INDEX IF NOT EXISTS idx_jira_watchers_enabled
+        ON jira_watchers(enabled);
+
+      CREATE TABLE IF NOT EXISTS jira_watch_results (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        watcher_id INTEGER REFERENCES jira_watchers(id) ON DELETE CASCADE,
+        issue_key TEXT NOT NULL,
+        issue_summary TEXT,
+        issue_updated TEXT,
+        session_id TEXT,
+        status TEXT NOT NULL DEFAULT 'pending',
+        ai_summary TEXT,
+        source TEXT NOT NULL DEFAULT 'watcher',
+        deleted INTEGER NOT NULL DEFAULT 0,
+        created_at TEXT DEFAULT (datetime('now')),
+        UNIQUE(watcher_id, issue_key, issue_updated)
+      );
+      CREATE INDEX IF NOT EXISTS idx_jira_results_watcher
+        ON jira_watch_results(watcher_id, deleted);
+      CREATE INDEX IF NOT EXISTS idx_jira_results_status
+        ON jira_watch_results(status);
+
+      PRAGMA user_version = 18;
+    `);
+  }
+
+  if (current < 19) {
+    database.exec(`
+      ALTER TABLE jira_watch_results ADD COLUMN read_at TEXT;
+      ALTER TABLE jira_watch_results ADD COLUMN triggered_by TEXT DEFAULT 'auto';
+      -- Cleanup stale running results from bot_task era
+      UPDATE jira_watch_results SET status = 'failed', ai_summary = 'Stale: migrated from bot_task flow' WHERE status = 'running';
+      -- Index for unread count query (status='done' AND read_at IS NULL AND deleted=0)
+      CREATE INDEX IF NOT EXISTS idx_jira_results_unread
+        ON jira_watch_results(status, read_at) WHERE deleted = 0;
+      PRAGMA user_version = 19;
+    `);
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/services/extension-host-worker.ts

@@ -28,12 +28,13 @@ self.addEventListener("message", (event: MessageEvent<RpcMessage>) => {
 // --- RPC handlers ---
 
 rpc.onRequest("ext:activate", async (params) => {
-  const [extId, entryPath, extensionPath, storedState, baseUrl] = params as [string, string, string, Record<string, Record<string, string | null>>?, string?];
+  const [extId, entryPath, extensionPath, storedState, baseUrl, authToken] = params as [string, string, string, Record<string, Record<string, string | null>>?, string?, string?];
   console.log(`[ExtHost] activating ${extId} from ${entryPath}`);
   if (activeExtensions.has(extId)) return { ok: true, already: true };
 
-  // Expose server base URL so extensions can use fetch() with absolute URLs
+  // Expose server base URL and auth token so extensions can use fetch() with absolute URLs
   if (baseUrl) (globalThis as any).__PPM_BASE_URL__ = baseUrl;
+  if (authToken) (globalThis as any).__PPM_AUTH_TOKEN__ = authToken;
 
   // Create RpcClient adapter for vscode-compat (Worker's RPC → vscode-compat interface)
   const rpcClient = {

package/src/services/extension.service.ts

@@ -138,14 +138,16 @@ class ExtensionService {
       workspace: Object.fromEntries(workspaceStorage.map((r) => [r.key, r.value])),
     };
 
-    // Pass server base URL so extensions can make fetch() calls in the Worker
+    // Pass server base URL + auth token so extensions can make fetch() calls in the Worker
     const { configService: cfg } = await import("./config.service.ts");
     const port = cfg.get("port") ?? 8080;
     const baseUrl = `http://localhost:${port}`;
+    const authConfig = cfg.get("auth");
+    const authToken = authConfig?.enabled ? authConfig.token : undefined;
 
     console.log(`[ExtService] activating ${id} (entry: ${entryPath})`);
     const result = await rpc.sendRequest<{ ok: boolean; error?: string }>(
-      "ext:activate", id, entryPath, extDir, storedState, baseUrl,
+      "ext:activate", id, entryPath, extDir, storedState, baseUrl, authToken,
     );
     if (!result.ok) {
       this.activationErrors.set(id, result.error ?? "Unknown activation error");

package/src/services/file.service.ts

@@ -127,6 +127,48 @@ class FileService {
     return nodes;
   }
 
+  /** Search project for files matching a given filename (exact, case-sensitive) */
+  resolveFilename(projectPath: string, filename: string, maxResults = 20): FileNode[] {
+    const ig = loadGitignore(projectPath);
+    const matches: FileNode[] = [];
+    this.walkForFilename(projectPath, projectPath, filename, ig, matches, maxResults);
+    return matches;
+  }
+
+  private walkForFilename(
+    rootPath: string,
+    dirPath: string,
+    targetName: string,
+    ig: Ignore,
+    results: FileNode[],
+    maxResults: number,
+  ): void {
+    if (results.length >= maxResults) return;
+    if (!existsSync(dirPath)) return;
+
+    let entries;
+    try { entries = readdirSync(dirPath, { withFileTypes: true }); }
+    catch { return; }
+
+    for (const entry of entries) {
+      if (results.length >= maxResults) return;
+      if (this.isExcluded(entry.name)) continue;
+
+      const fullPath = join(dirPath, entry.name);
+      const relPath = relative(rootPath, fullPath);
+      const relPosix = relPath.split("\\").join("/");
+
+      const checkPath = entry.isDirectory() ? `${relPosix}/` : relPosix;
+      if (ig.ignores(checkPath) || ig.ignores(relPosix)) continue;
+
+      if (entry.isDirectory()) {
+        this.walkForFilename(rootPath, fullPath, targetName, ig, results, maxResults);
+      } else if (entry.name === targetName) {
+        results.push({ name: entry.name, path: relPath, type: "file" });
+      }
+    }
+  }
+
   /** Read file content with encoding detection */
   readFile(
     projectPath: string,