@hienlh/ppm 0.10.5 → 0.11.0

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/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,

package/src/services/jira-api-client.ts

@@ -0,0 +1,216 @@
+import type {
+  JiraCredentials,
+  JiraIssue,
+  JiraSearchResponse,
+  JiraTransition,
+  JiraRateLimitState,
+} from "../types/jira.ts";
+
+// ── Error class ───────────────────────────────────────────────────────
+
+export class JiraApiError extends Error {
+  constructor(
+    message: string,
+    public status: number,
+    public retryAfter?: number,
+    public rateLimitRemaining?: number,
+  ) {
+    super(message);
+    this.name = "JiraApiError";
+  }
+}
+
+// ── Rate limit state per config (keyed by baseUrl) ────────────────────
+
+const rateLimitStates = new Map<string, JiraRateLimitState>();
+
+export function getRateLimitState(baseUrl: string): JiraRateLimitState {
+  return rateLimitStates.get(baseUrl) ?? {
+    remaining: null, limit: null, resetAt: null,
+    backingOff: false, pausedUntil: null,
+  };
+}
+
+function extractRateLimits(headers: Headers, baseUrl: string): void {
+  const remaining = headers.get("x-ratelimit-remaining");
+  const limit = headers.get("x-ratelimit-limit");
+  const state = getRateLimitState(baseUrl);
+  if (remaining !== null) state.remaining = parseInt(remaining, 10);
+  if (limit !== null) state.limit = parseInt(limit, 10);
+  // Check if backing off needed
+  if (state.remaining !== null && state.limit !== null && state.limit > 0) {
+    state.backingOff = state.remaining / state.limit < 0.2;
+  }
+  rateLimitStates.set(baseUrl, state);
+}
+
+// ── Auth helper ───────────────────────────────────────────────────────
+
+function buildAuthHeader(creds: JiraCredentials): string {
+  return "Basic " + Buffer.from(`${creds.email}:${creds.token}`).toString("base64");
+}
+
+// ── Core fetch wrapper ────────────────────────────────────────────────
+
+async function jiraFetch<T>(
+  creds: JiraCredentials,
+  method: string,
+  path: string,
+  body?: unknown,
+): Promise<T> {
+  const url = `${creds.baseUrl.replace(/\/$/, "")}${path}`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 15_000);
+
+  try {
+    const res = await fetch(url, {
+      method,
+      headers: {
+        Authorization: buildAuthHeader(creds),
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: body ? JSON.stringify(body) : undefined,
+      signal: controller.signal,
+    });
+
+    extractRateLimits(res.headers, creds.baseUrl);
+
+    if (res.status === 429) {
+      const retryAfter = parseInt(res.headers.get("retry-after") ?? "300", 10);
+      const state = getRateLimitState(creds.baseUrl);
+      state.pausedUntil = Date.now() + retryAfter * 1000;
+      rateLimitStates.set(creds.baseUrl, state);
+      throw new JiraApiError("Rate limited by Jira", 429, retryAfter);
+    }
+
+    if (res.status === 204) return undefined as T; // void responses (PUT update)
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new JiraApiError(
+        `Jira API ${res.status}: ${text.slice(0, 200)}`,
+        res.status,
+        undefined,
+        getRateLimitState(creds.baseUrl).remaining ?? undefined,
+      );
+    }
+
+    return (await res.json()) as T;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// ── Public API ────────────────────────────────────────────────────────
+
+const DEFAULT_FIELDS = "summary,status,priority,assignee,description,updated,created";
+
+export async function searchIssues(
+  creds: JiraCredentials,
+  jql: string,
+  fields = DEFAULT_FIELDS,
+  maxResults = 50,
+  nextPageToken?: string,
+): Promise<JiraSearchResponse> {
+  const body: Record<string, unknown> = {
+    jql, fields: fields.split(","), maxResults,
+  };
+  if (nextPageToken) body.nextPageToken = nextPageToken;
+  return jiraFetch<JiraSearchResponse>(creds, "POST", "/rest/api/3/search/jql", body);
+}
+
+export async function getIssue(
+  creds: JiraCredentials,
+  issueKey: string,
+  fields = DEFAULT_FIELDS,
+): Promise<JiraIssue> {
+  return jiraFetch<JiraIssue>(creds, "GET", `/rest/api/3/issue/${issueKey}?fields=${fields}`);
+}
+
+export async function updateIssue(
+  creds: JiraCredentials,
+  issueKey: string,
+  fields: Record<string, unknown>,
+): Promise<void> {
+  await jiraFetch<void>(creds, "PUT", `/rest/api/3/issue/${issueKey}`, { fields });
+}
+
+export async function getTransitions(
+  creds: JiraCredentials,
+  issueKey: string,
+): Promise<JiraTransition[]> {
+  const res = await jiraFetch<{ transitions: JiraTransition[] }>(
+    creds, "GET", `/rest/api/3/issue/${issueKey}/transitions`,
+  );
+  return res.transitions;
+}
+
+export async function transitionIssue(
+  creds: JiraCredentials,
+  issueKey: string,
+  transitionId: string,
+): Promise<void> {
+  await jiraFetch<void>(creds, "POST", `/rest/api/3/issue/${issueKey}/transitions`, {
+    transition: { id: transitionId },
+  });
+}
+
+export async function testConnection(creds: JiraCredentials): Promise<boolean> {
+  // Use bounded JQL — unbounded queries return 400 on /search/jql
+  await searchIssues(creds, "created >= -30d ORDER BY created DESC", "summary", 1);
+  return true;
+}
+
+/** Escape JQL special characters in user input */
+function escapeJql(value: string): string {
+  // Remove control characters, escape JQL reserved chars
+  return value
+    .replace(/[\x00-\x1f]/g, "")
+    .replace(/[\\'"{}()\[\]+\-&|!~*?^]/g, "\\$&");
+}
+
+export async function searchText(
+  creds: JiraCredentials,
+  query: string,
+  maxResults = 20,
+): Promise<JiraSearchResponse> {
+  const jql = `text ~ "${escapeJql(query)}" ORDER BY updated DESC`;
+  return searchIssues(creds, jql, DEFAULT_FIELDS, maxResults);
+}
+
+/** Fetch Jira project list for filter builder */
+export async function getProjects(
+  creds: JiraCredentials,
+): Promise<Array<{ key: string; name: string }>> {
+  return jiraFetch<Array<{ key: string; name: string }>>(
+    creds, "GET", "/rest/api/3/project/search?maxResults=100",
+  ).then((res: any) => (res.values ?? res).map((p: any) => ({ key: p.key, name: p.name })));
+}
+
+/** Fetch metadata for filter builder (issue types, priorities, statuses) */
+export async function getFieldOptions(
+  creds: JiraCredentials,
+  fieldName: "issuetype" | "priority" | "status",
+): Promise<Array<{ id: string; name: string }>> {
+  if (fieldName === "issuetype") {
+    return jiraFetch<Array<{ id: string; name: string }>>(creds, "GET", "/rest/api/3/issuetype");
+  }
+  if (fieldName === "priority") {
+    return jiraFetch<Array<{ id: string; name: string }>>(creds, "GET", "/rest/api/3/priority");
+  }
+  // statuses
+  return jiraFetch<Array<any>>(creds, "GET", "/rest/api/3/status")
+    .then((list) => list.map((s: any) => ({ id: s.id, name: s.name })));
+}
+
+/** Fetch assignable users for filter builder */
+export async function getAssignableUsers(
+  creds: JiraCredentials,
+): Promise<Array<{ accountId: string; displayName: string }>> {
+  return jiraFetch<Array<any>>(creds, "GET", "/rest/api/3/users/search?maxResults=100")
+    .then((list) => list
+      .filter((u: any) => u.accountType === "atlassian")
+      .map((u: any) => ({ accountId: u.accountId, displayName: u.displayName })),
+    );
+}

package/src/services/jira-config.service.ts

@@ -0,0 +1,83 @@
+import { getDb } from "./db.service.ts";
+import { encrypt, decrypt } from "../lib/account-crypto.ts";
+import type { JiraConfigRow, JiraConfig, JiraCredentials } from "../types/jira.ts";
+
+// ── Row → API mapper ──────────────────────────────────────────────────
+
+function rowToConfig(row: JiraConfigRow): JiraConfig {
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    baseUrl: row.base_url,
+    email: row.email,
+    hasToken: !!row.api_token_encrypted,
+    createdAt: row.created_at,
+  };
+}
+
+// ── Public API ────────────────────────────────────────────────────────
+
+export function getConfigByProjectId(projectId: number): JiraConfig | null {
+  const row = getDb()
+    .query("SELECT * FROM jira_config WHERE project_id = ?")
+    .get(projectId) as JiraConfigRow | null;
+  return row ? rowToConfig(row) : null;
+}
+
+export function getConfigById(id: number): JiraConfigRow | null {
+  return getDb()
+    .query("SELECT * FROM jira_config WHERE id = ?")
+    .get(id) as JiraConfigRow | null;
+}
+
+export function getAllConfigs(): JiraConfig[] {
+  const rows = getDb()
+    .query("SELECT * FROM jira_config ORDER BY id")
+    .all() as JiraConfigRow[];
+  return rows.map(rowToConfig);
+}
+
+export function upsertConfig(
+  projectId: number,
+  baseUrl: string,
+  email: string,
+  plainToken?: string,
+): JiraConfig {
+  if (plainToken) {
+    // Full upsert with new token
+    const encrypted = encrypt(plainToken);
+    getDb().query(`
+      INSERT INTO jira_config (project_id, base_url, email, api_token_encrypted)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(project_id) DO UPDATE SET
+        base_url = excluded.base_url,
+        email = excluded.email,
+        api_token_encrypted = excluded.api_token_encrypted
+    `).run(projectId, baseUrl, email, encrypted);
+  } else {
+    // Update URL/email only, preserve existing token
+    getDb().query(`
+      UPDATE jira_config SET base_url = ?, email = ? WHERE project_id = ?
+    `).run(baseUrl, email, projectId);
+  }
+  return getConfigByProjectId(projectId)!;
+}
+
+export function deleteConfig(projectId: number): boolean {
+  const result = getDb()
+    .query("DELETE FROM jira_config WHERE project_id = ?")
+    .run(projectId);
+  return result.changes > 0;
+}
+
+export function getDecryptedCredentials(configId: number): JiraCredentials | null {
+  const row = getConfigById(configId);
+  if (!row) return null;
+  try {
+    const token = decrypt(row.api_token_encrypted);
+    return { baseUrl: row.base_url, email: row.email, token };
+  } catch (e) {
+    console.warn(`[jira] Failed to decrypt token for config ${configId}:`, (e as Error).message);
+    return null;
+  }
+}