@hienlh/ppm 0.10.5 → 0.11.1

package/src/cli/commands/jira-watcher-cmd.ts

@@ -0,0 +1,149 @@
+import type { Command } from "commander";
+
+const C = {
+  reset: "\x1b[0m", green: "\x1b[32m", red: "\x1b[31m",
+  yellow: "\x1b[33m", cyan: "\x1b[36m", dim: "\x1b[2m",
+};
+
+export function registerJiraWatcherCommands(jira: Command): void {
+  const watch = jira.command("watch").description("Manage Jira watchers");
+
+  watch.command("add")
+    .description("Create a new watcher")
+    .requiredOption("--config <id>", "Jira config ID")
+    .requiredOption("--name <name>", "Watcher name")
+    .requiredOption("--jql <jql>", "JQL filter query")
+    .option("--interval <ms>", "Poll interval in ms", "120000")
+    .option("--prompt <template>", "Custom prompt template")
+    .option("--mode <mode>", "debug or notify", "debug")
+    .action(async (opts) => {
+      try {
+        const { createWatcher } = await import("../../services/jira-watcher-db.service.ts");
+        const w = createWatcher(Number(opts.config), opts.name, opts.jql, {
+          intervalMs: Number(opts.interval), promptTemplate: opts.prompt, mode: opts.mode,
+        });
+        console.log(`${C.green}✓${C.reset} Watcher created (id: ${w.id})`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  watch.command("list")
+    .description("List watchers")
+    .option("--config <id>", "Filter by config ID")
+    .action(async (opts) => {
+      try {
+        const { getWatchersByConfigId } = await import("../../services/jira-watcher-db.service.ts");
+        const { getAllEnabledWatchers } = await import("../../services/jira-watcher-db.service.ts");
+        const list = opts.config
+          ? getWatchersByConfigId(Number(opts.config))
+          : getAllEnabledWatchers().map((w) => ({ id: w.id, name: w.name, jql: w.jql, mode: w.mode, intervalMs: w.interval_ms, enabled: w.enabled === 1 }));
+        if (!list.length) { console.log("No watchers found."); return; }
+        console.table(list);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  watch.command("enable <id>").description("Enable watcher").action(async (id) => {
+    try {
+      const { updateWatcher } = await import("../../services/jira-watcher-db.service.ts");
+      updateWatcher(Number(id), { enabled: true });
+      console.log(`${C.green}✓${C.reset} Watcher ${id} enabled`);
+    } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+  });
+
+  watch.command("disable <id>").description("Disable watcher").action(async (id) => {
+    try {
+      const { updateWatcher } = await import("../../services/jira-watcher-db.service.ts");
+      updateWatcher(Number(id), { enabled: false });
+      console.log(`${C.green}✓${C.reset} Watcher ${id} disabled`);
+    } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+  });
+
+  watch.command("remove <id>").description("Delete watcher").action(async (id) => {
+    try {
+      const { deleteWatcher } = await import("../../services/jira-watcher-db.service.ts");
+      deleteWatcher(Number(id));
+      console.log(`${C.green}✓${C.reset} Watcher ${id} deleted`);
+    } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+  });
+
+  watch.command("test <id>").description("Dry-run poll (show matches without creating tasks)")
+    .action(async (id) => {
+      try {
+        const { getDb } = await import("../../services/db.service.ts");
+        const w = getDb().query("SELECT * FROM jira_watchers WHERE id = ?").get(Number(id)) as any;
+        if (!w) { console.error(`${C.red}✗${C.reset} Watcher not found`); process.exit(1); }
+        const { getDecryptedCredentials } = await import("../../services/jira-config.service.ts");
+        const creds = getDecryptedCredentials(w.jira_config_id);
+        if (!creds) { console.error(`${C.red}✗${C.reset} No credentials`); process.exit(1); }
+        const { searchIssues } = await import("../../services/jira-api-client.ts");
+        const res = await searchIssues(creds, w.jql);
+        console.log(`Found ${res.total} issues (showing ${res.issues.length}):`);
+        for (const i of res.issues) console.log(`  ${C.cyan}${i.key}${C.reset} ${i.fields.summary}`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  watch.command("pull [id]").description("Manual pull (one watcher or all enabled)")
+    .action(async (id?: string) => {
+      try {
+        const { jiraWatcherService } = await import("../../services/jira-watcher.service.ts");
+        if (id) {
+          const count = await jiraWatcherService.pollWatcher(Number(id));
+          console.log(`${C.green}✓${C.reset} Pulled ${count} new issue(s)`);
+        } else {
+          const { getAllEnabledWatchers } = await import("../../services/jira-watcher-db.service.ts");
+          let total = 0;
+          for (const w of getAllEnabledWatchers()) {
+            try { total += await jiraWatcherService.pollWatcher(w.id); } catch {}
+          }
+          console.log(`${C.green}✓${C.reset} Pulled ${total} new issue(s) total`);
+        }
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  // ── Results ───────────────────────────────────────────────────────
+
+  const results = jira.command("results").description("View Jira watch results");
+  results
+    .option("--watcher <id>", "Filter by watcher ID")
+    .option("--status <status>", "Filter by status")
+    .action(async (opts) => {
+      try {
+        const { getResultsByWatcherId } = await import("../../services/jira-watcher-db.service.ts");
+        const list = getResultsByWatcherId(
+          opts.watcher ? Number(opts.watcher) : undefined,
+          { status: opts.status },
+        );
+        if (!list.length) { console.log("No results."); return; }
+        console.table(list.map((r) => ({
+          id: r.id, key: r.issueKey, status: r.status,
+          summary: (r.issueSummary ?? "").slice(0, 50), source: r.source,
+        })));
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  results.command("delete <id>").description("Soft-delete result").action(async (id) => {
+    try {
+      const { softDeleteResult } = await import("../../services/jira-watcher-db.service.ts");
+      softDeleteResult(Number(id));
+      console.log(`${C.green}✓${C.reset} Result ${id} deleted`);
+    } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+  });
+
+  // ── Ticket ────────────────────────────────────────────────────────
+
+  jira.command("track <issueKey>")
+    .description("Manually track a Jira issue")
+    .requiredOption("--config <id>", "Jira config ID")
+    .action(async (issueKey, opts) => {
+      try {
+        const { getDecryptedCredentials } = await import("../../services/jira-config.service.ts");
+        const creds = getDecryptedCredentials(Number(opts.config));
+        if (!creds) { console.error(`${C.red}✗${C.reset} Invalid config`); process.exit(1); }
+        const { getIssue } = await import("../../services/jira-api-client.ts");
+        const issue = await getIssue(creds, issueKey);
+        const { insertResult } = await import("../../services/jira-watcher-db.service.ts");
+        const { inserted } = insertResult(null, issue.key, issue.fields.summary, issue.fields.updated, "manual");
+        if (!inserted) { console.log(`${C.yellow}Already tracked${C.reset}`); return; }
+        console.log(`${C.green}✓${C.reset} Tracking ${issue.key}: ${issue.fields.summary}`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+}

package/src/index.ts

@@ -157,4 +157,7 @@ registerDbCommands(program);
 const { registerBotCommands } = await import("./cli/commands/bot-cmd.ts");
 registerBotCommands(program);
 
+const { registerJiraCommands } = await import("./cli/commands/jira-cmd.ts");
+await registerJiraCommands(program);
+
 program.parse();

package/src/server/index.ts

@@ -150,6 +150,10 @@ app.route("/api/postgres", postgresRoutes);
 app.route("/api/db", databaseRoutes);
 app.route("/api/accounts", accountsRoutes);
 
+// Jira watcher
+import { jiraRoutes } from "./routes/jira.ts";
+app.route("/api/jira", jiraRoutes);
+
 // Agent Teams management
 import { teamRoutes } from "./routes/teams.ts";
 app.route("/api/teams", teamRoutes);
@@ -650,5 +654,20 @@ if (process.argv.includes("__serve__")) {
       console.error("[ppmbot] Startup error:", e);
     });
 
+  // Start Jira watchers (non-blocking, cleanup on exit)
+  import("../services/jira-watcher.service.ts")
+    .then(({ jiraWatcherService }) => {
+      // Reset zombie debug sessions from previous server run
+      import("../services/jira-debug-session.service.ts").then(({ jiraDebugService }) => {
+        jiraDebugService.init();
+      }).catch(() => {});
+      jiraWatcherService.startAll().catch((e) => {
+        console.error("[jira] Failed to start watchers:", (e as Error).message);
+      });
+      process.on("SIGTERM", () => jiraWatcherService.stopAll());
+      process.on("SIGINT", () => jiraWatcherService.stopAll());
+    })
+    .catch(() => {});
+
   console.log(`Server child ready on port ${port}`);
 }

package/src/server/routes/files.ts

@@ -160,6 +160,21 @@ function globToPathRegex(glob: string): RegExp {
   return new RegExp(re);
 }
 
+/** GET /files/resolve?name=filename — resolve filename to project path(s) */
+fileRoutes.get("/resolve", (c) => {
+  try {
+    const projectPath = c.get("projectPath");
+    const name = c.req.query("name");
+    if (!name || name.includes("/") || name.includes("\\")) {
+      return c.json(err("Invalid filename"), 400);
+    }
+    const matches = fileService.resolveFilename(projectPath, name);
+    return c.json(ok({ matches }));
+  } catch (e) {
+    return c.json(err((e as Error).message), errorStatus(e));
+  }
+});
+
 /** GET /files/search?q=...&caseSensitive=false — search file content with grep */
 fileRoutes.get("/search", async (c) => {
   const projectPath = c.get("projectPath");

package/src/server/routes/fs-browse.ts

@@ -1,5 +1,7 @@
 import { Hono } from "hono";
-import { existsSync } from "fs";
+import { existsSync, mkdirSync, rmSync, statSync } from "fs";
+import { resolve } from "path";
+import { $ } from "bun";
 import {
   browse,
   list,
@@ -73,6 +75,43 @@ fsBrowseRoutes.get("/raw", (c) => {
   }
 });
 
+/** DELETE /api/fs/rmdir — delete a directory { path } */
+fsBrowseRoutes.delete("/rmdir", async (c) => {
+  try {
+    const body = await c.req.json<{ path: string }>();
+    if (!body.path) return c.json(err("path is required"), 400);
+
+    const abs = resolve(body.path);
+    if (!existsSync(abs)) return c.json(err("Directory not found"), 404);
+    if (!statSync(abs).isDirectory()) return c.json(err("Path is not a directory"), 400);
+
+    rmSync(abs, { recursive: true });
+    return c.json(ok({ removed: abs }));
+  } catch (e) {
+    return c.json(err((e as Error).message), errorStatus(e));
+  }
+});
+
+/** POST /api/fs/mkdir — create directory and git init { path } */
+fsBrowseRoutes.post("/mkdir", async (c) => {
+  try {
+    const body = await c.req.json<{ path: string }>();
+    if (!body.path) return c.json(err("path is required"), 400);
+
+    const abs = resolve(body.path);
+    if (existsSync(abs)) {
+      return c.json(err(`Directory already exists: ${abs}`), 400);
+    }
+
+    mkdirSync(abs, { recursive: true });
+    // git init in the new directory
+    await $`git init ${abs}`.quiet();
+    return c.json(ok({ path: abs, gitInitialized: true }), 201);
+  } catch (e) {
+    return c.json(err((e as Error).message), errorStatus(e));
+  }
+});
+
 /** PUT /api/fs/write — write file outside project { path, content } */
 fsBrowseRoutes.put("/write", async (c) => {
   try {

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

@@ -0,0 +1,74 @@
+import { Hono } from "hono";
+import {
+  getAllConfigs, getConfigByProjectId,
+  upsertConfig, deleteConfig, getDecryptedCredentials,
+} from "../../services/jira-config.service.ts";
+import { getProjects } from "../../services/db.service.ts";
+import { testConnection } from "../../services/jira-api-client.ts";
+import { ok, err } from "../../types/api.ts";
+
+export const jiraConfigRoutes = new Hono();
+
+/** GET /projects — list projects with integer IDs for frontend selectors */
+jiraConfigRoutes.get("/projects", (c) => {
+  return c.json(ok(getProjects()));
+});
+
+/** GET / — list all configs */
+jiraConfigRoutes.get("/", (c) => {
+  return c.json(ok(getAllConfigs()));
+});
+
+/** GET /:projectId — get config for project */
+jiraConfigRoutes.get("/:projectId", (c) => {
+  const projectId = parseInt(c.req.param("projectId"), 10);
+  if (isNaN(projectId)) return c.json(err("Invalid projectId"), 400);
+  const config = getConfigByProjectId(projectId);
+  if (!config) return c.json(err("No Jira config for this project"), 404);
+  return c.json(ok(config));
+});
+
+/** PUT /:projectId — upsert config (token optional on update) */
+jiraConfigRoutes.put("/:projectId", async (c) => {
+  const projectId = parseInt(c.req.param("projectId"), 10);
+  if (isNaN(projectId)) return c.json(err("Invalid projectId"), 400);
+  const body = await c.req.json<{ baseUrl?: string; email?: string; token?: string }>();
+  if (!body.baseUrl || !body.email) {
+    return c.json(err("baseUrl and email are required"), 400);
+  }
+  if (!body.baseUrl.startsWith("https://")) {
+    return c.json(err("baseUrl must start with https://"), 400);
+  }
+  // Token required for new configs, optional for updates
+  const existing = getConfigByProjectId(projectId);
+  if (!existing && !body.token) {
+    return c.json(err("token is required for new configs"), 400);
+  }
+  const config = upsertConfig(projectId, body.baseUrl, body.email, body.token);
+  return c.json(ok(config));
+});
+
+/** DELETE /:projectId — delete config + cascade */
+jiraConfigRoutes.delete("/:projectId", (c) => {
+  const projectId = parseInt(c.req.param("projectId"), 10);
+  if (isNaN(projectId)) return c.json(err("Invalid projectId"), 400);
+  const deleted = deleteConfig(projectId);
+  if (!deleted) return c.json(err("Config not found"), 404);
+  return c.json(ok({ deleted: true }));
+});
+
+/** POST /:projectId/test — test Jira connection */
+jiraConfigRoutes.post("/:projectId/test", async (c) => {
+  const projectId = parseInt(c.req.param("projectId"), 10);
+  if (isNaN(projectId)) return c.json(err("Invalid projectId"), 400);
+  const config = getConfigByProjectId(projectId);
+  if (!config) return c.json(err("No Jira config for this project"), 404);
+  const creds = getDecryptedCredentials(config.id);
+  if (!creds) return c.json(err("Failed to decrypt credentials"), 500);
+  try {
+    await testConnection(creds);
+    return c.json(ok({ connected: true }));
+  } catch (e: any) {
+    return c.json(err(`Connection failed: ${e.message}`), 502);
+  }
+});

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);