@hienlh/ppm 0.10.4 → 0.11.0

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;
+  }
+}

package/src/services/jira-debug-session.service.ts

@@ -0,0 +1,240 @@
+import { chatService } from "./chat.service.ts";
+import { getDb } from "./db.service.ts";
+import { updateResultStatus, getResultById } from "./jira-watcher-db.service.ts";
+import { notificationService } from "./notification.service.ts";
+import { forwardEventToSession } from "../server/ws/chat.ts";
+import type { JiraWatcherRow } from "../types/jira.ts";
+import type { PermissionMode } from "../types/config.ts";
+
+const MAX_CONCURRENT = 2;
+const MAX_PER_PROJECT = 1;
+
+interface QueueItem {
+  resultId: number;
+  prompt?: string;
+  resume?: boolean; // reuse existing session instead of creating new
+}
+
+class JiraDebugSessionService {
+  private queue: QueueItem[] = [];
+  private active = new Map<number, AbortController>(); // resultId → abort
+  private activeByProject = new Map<string, number>(); // projectPath → count
+  private enqueuedIds = new Set<number>(); // guard against double-enqueue
+
+  /** Reset zombie results from previous server run (running/queued with no active process) */
+  init(): void {
+    const zombies = getDb().query(
+      `UPDATE jira_watch_results SET status = 'failed', ai_summary = 'Server restarted during debug'
+       WHERE status IN ('running', 'queued') AND deleted = 0 RETURNING id, issue_key`,
+    ).all() as { id: number; issue_key: string }[];
+    if (zombies.length > 0) {
+      console.log(`[jira-debug] Reset ${zombies.length} zombie results: ${zombies.map((z) => z.issue_key).join(", ")}`);
+    }
+  }
+
+  /** Enqueue a result for debug. Accepts "pending" or "failed" (retry). */
+  enqueue(resultId: number, promptOverride?: string): void {
+    if (this.enqueuedIds.has(resultId)) return; // prevent double-enqueue
+    const result = getResultById(resultId);
+    if (!result) throw new Error("Result not found");
+    if (result.status !== "pending" && result.status !== "failed") {
+      throw new Error(`Result status is "${result.status}", expected "pending" or "failed"`);
+    }
+
+    this.enqueuedIds.add(resultId);
+    updateResultStatus(resultId, "queued");
+    this.broadcastStatusChange(resultId, result.issueKey, "queued");
+    this.queue.push({ resultId, prompt: promptOverride });
+    this.processQueue();
+  }
+
+  /** Resume a failed session that already has a sessionId */
+  resumeDebug(resultId: number, prompt?: string): void {
+    if (this.enqueuedIds.has(resultId)) return;
+    const result = getResultById(resultId);
+    if (!result) throw new Error("Result not found");
+    if (result.status !== "failed") throw new Error("Only failed results can be resumed");
+    if (!result.sessionId) throw new Error("No session to resume — use debug instead");
+
+    this.enqueuedIds.add(resultId);
+    updateResultStatus(resultId, "queued");
+    this.broadcastStatusChange(resultId, result.issueKey, "queued");
+    this.queue.push({
+      resultId,
+      prompt: prompt ?? "Continue debugging. The previous session was interrupted before completing.",
+      resume: true,
+    });
+    this.processQueue();
+  }
+
+  /** Cancel a running or queued debug session */
+  cancelDebug(resultId: number): boolean {
+    // Remove from queue if still queued
+    const qIdx = this.queue.findIndex((q) => q.resultId === resultId);
+    if (qIdx >= 0) {
+      this.queue.splice(qIdx, 1);
+      this.enqueuedIds.delete(resultId);
+      const result = getResultById(resultId);
+      updateResultStatus(resultId, "failed", { aiSummary: "Cancelled by user" });
+      if (result) this.broadcastStatusChange(resultId, result.issueKey, "failed");
+      return true;
+    }
+    // Abort if actively running
+    const abort = this.active.get(resultId);
+    if (!abort) return false;
+    abort.abort();
+    const result = getResultById(resultId);
+    updateResultStatus(resultId, "failed", { aiSummary: "Cancelled by user" });
+    if (result) this.broadcastStatusChange(resultId, result.issueKey, "failed");
+    return true;
+  }
+
+  // [H2 fix] Iterate through queue to avoid head-of-line blocking
+  private processQueue(): void {
+    let i = 0;
+    while (i < this.queue.length && this.active.size < MAX_CONCURRENT) {
+      const item = this.queue[i]!;
+      const project = this.resolveProjectInfo(item.resultId);
+      if (!project) { this.queue.splice(i, 1); continue; }
+
+      const projectCount = this.activeByProject.get(project.path) ?? 0;
+      if (projectCount >= MAX_PER_PROJECT) { i++; continue; }
+
+      this.queue.splice(i, 1);
+      this.runDebugSession(item.resultId, item.prompt, project, item.resume).catch((e) => {
+        console.error(`[jira-debug] session error resultId=${item.resultId}:`, e.message);
+      });
+    }
+  }
+
+  // [H3 fix] Single method for project lookup — used by both processQueue and runDebugSession
+  private resolveProjectInfo(resultId: number): { path: string; name: string } | null {
+    return getDb().query(`
+      SELECT p.path, p.name FROM jira_watch_results r
+      JOIN jira_watchers w ON w.id = r.watcher_id
+      JOIN jira_config c ON c.id = w.jira_config_id
+      JOIN projects p ON p.id = c.project_id
+      WHERE r.id = ?
+    `).get(resultId) as { path: string; name: string } | null;
+  }
+
+  private resolveWatcherForResult(resultId: number): JiraWatcherRow | null {
+    return getDb().query(`
+      SELECT w.* FROM jira_watch_results r
+      JOIN jira_watchers w ON w.id = r.watcher_id
+      WHERE r.id = ?
+    `).get(resultId) as JiraWatcherRow | null;
+  }
+
+  private async runDebugSession(
+    resultId: number, promptOverride: string | undefined,
+    project: { path: string; name: string },
+    resume?: boolean,
+  ): Promise<void> {
+    const result = getResultById(resultId);
+    if (!result) return;
+
+    // Build prompt
+    let prompt: string;
+    if (promptOverride) {
+      prompt = promptOverride;
+    } else {
+      const watcher = this.resolveWatcherForResult(resultId);
+      if (watcher?.prompt_template) {
+        prompt = watcher.prompt_template
+          .replace(/\{issue_key\}/g, result.issueKey)
+          .replace(/\{summary\}/g, result.issueSummary ?? "")
+          .replace(/\{description\}/g, "(fetched from Jira)")
+          .replace(/\{status\}/g, "")
+          .replace(/\{priority\}/g, "");
+      } else {
+        prompt = `Debug Jira issue ${result.issueKey}: ${result.issueSummary ?? "No summary"}`;
+      }
+    }
+
+    // Track concurrency
+    const abort = new AbortController();
+    this.active.set(resultId, abort);
+    this.activeByProject.set(project.path, (this.activeByProject.get(project.path) ?? 0) + 1);
+
+    updateResultStatus(resultId, "running");
+    this.broadcastStatusChange(resultId, result.issueKey, "running");
+
+    try {
+      // Resume: reuse existing session (SDK can resume from disk even after restart)
+      let session: { id: string; providerId: string };
+      if (resume && result.sessionId) {
+        // SDK provider's sendMessage auto-resumes sessions from disk via resumeSession()
+        // We just need the sessionId and the correct providerId
+        const existing = chatService.getSession(result.sessionId);
+        session = existing
+          ? { id: existing.id, providerId: existing.providerId }
+          : { id: result.sessionId, providerId: "claude" }; // default provider
+      } else {
+        session = await chatService.createSession(undefined, {
+          projectPath: project.path,
+          projectName: project.name,
+          title: `[Jira Debug] ${result.issueKey}: ${(result.issueSummary ?? "").slice(0, 50)}`,
+        });
+      }
+
+      // Persist sessionId immediately so UI can show "Open" button while running
+      updateResultStatus(resultId, "running", { sessionId: session.id });
+      this.broadcastStatusChange(resultId, result.issueKey, "running", session.id);
+
+      // bypassPermissions: automated debug sessions run without user approval (same as PPMBot)
+      const opts = { permissionMode: "bypassPermissions" as PermissionMode };
+      const events = chatService.sendMessage(session.providerId, session.id, prompt, opts);
+
+      let lastAssistantText = "";
+      for await (const event of events) {
+        if (abort.signal.aborted) break;
+        if (event.type === "text") lastAssistantText = event.content;
+        // Forward events to any connected WS client viewing this session
+        forwardEventToSession(session.id, event);
+      }
+
+      if (abort.signal.aborted) return;
+
+      const aiSummary = lastAssistantText.slice(0, 500) || "Debug session completed (no text output)";
+      updateResultStatus(resultId, "done", { sessionId: session.id, aiSummary });
+
+      // Broadcast WS event + notification
+      this.broadcastStatusChange(resultId, result.issueKey, "done", session.id);
+
+      notificationService.broadcast("done", {
+        title: `Jira: ${result.issueKey}`,
+        body: aiSummary.slice(0, 200),
+        project: project.name,
+        sessionId: session.id,
+      }).catch(() => {});
+    } catch (e: any) {
+      if (!abort.signal.aborted) {
+        updateResultStatus(resultId, "failed", { aiSummary: e.message?.slice(0, 300) ?? "Unknown error" });
+        this.broadcastStatusChange(resultId, result.issueKey, "failed");
+      }
+    } finally {
+      this.cleanup(resultId, project.path);
+      this.processQueue();
+    }
+  }
+
+  private broadcastStatusChange(resultId: number, issueKey: string, status: string, sessionId?: string): void {
+    notificationService.broadcastWs({
+      type: "jira:status_change",
+      resultId, issueKey, status, sessionId,
+    }).catch(() => {});
+  }
+
+  // [C1 fix] Idempotent cleanup — safe to call multiple times
+  private cleanup(resultId: number, projectPath: string): void {
+    if (!this.active.has(resultId)) return; // already cleaned up
+    this.active.delete(resultId);
+    this.enqueuedIds.delete(resultId);
+    const count = (this.activeByProject.get(projectPath) ?? 1) - 1;
+    if (count <= 0) this.activeByProject.delete(projectPath);
+    else this.activeByProject.set(projectPath, count);
+  }
+}
+
+export const jiraDebugService = new JiraDebugSessionService();