@hienlh/ppm 0.10.4 → 0.11.0

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

@@ -0,0 +1,92 @@
+import { Command } from "commander";
+
+const C = {
+  reset: "\x1b[0m", bold: "\x1b[1m", green: "\x1b[32m",
+  red: "\x1b[31m", yellow: "\x1b[33m", cyan: "\x1b[36m", dim: "\x1b[2m",
+};
+
+export async function registerJiraCommands(program: Command): Promise<void> {
+  const jira = program.command("jira").description("Jira watcher utilities");
+  registerConfigCommands(jira);
+  await registerWatcherCommands(jira);
+}
+
+// ── Config commands ───────────────────────────────────────────────────
+
+function registerConfigCommands(jira: Command): void {
+  const config = jira.command("config").description("Manage Jira configs");
+
+  config
+    .command("set <projectName>")
+    .description("Set Jira config for a project")
+    .requiredOption("--url <url>", "Jira base URL (https://...)")
+    .requiredOption("--email <email>", "Jira account email")
+    .requiredOption("--token <token>", "API token (⚠ visible in shell history)")
+    .action(async (projectName: string, opts: { url: string; email: string; token: string }) => {
+      try {
+        const { getDb } = await import("../../services/db.service.ts");
+        const project = getDb().query("SELECT id FROM projects WHERE name = ?").get(projectName) as { id: number } | null;
+        if (!project) { console.error(`${C.red}✗${C.reset} Project "${projectName}" not found`); process.exit(1); }
+        const { upsertConfig } = await import("../../services/jira-config.service.ts");
+        const cfg = upsertConfig(project.id, opts.url, opts.email, opts.token);
+        console.log(`${C.green}✓${C.reset} Jira config saved for "${projectName}" (id: ${cfg.id})`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  config
+    .command("show <projectName>")
+    .description("Show Jira config (token masked)")
+    .action(async (projectName: string) => {
+      try {
+        const { getDb } = await import("../../services/db.service.ts");
+        const project = getDb().query("SELECT id FROM projects WHERE name = ?").get(projectName) as { id: number } | null;
+        if (!project) { console.error(`${C.red}✗${C.reset} Project not found`); process.exit(1); }
+        const { getConfigByProjectId } = await import("../../services/jira-config.service.ts");
+        const cfg = getConfigByProjectId(project.id);
+        if (!cfg) { console.log(`${C.yellow}No Jira config for "${projectName}"${C.reset}`); return; }
+        console.log(`  URL:   ${cfg.baseUrl}`);
+        console.log(`  Email: ${cfg.email}`);
+        console.log(`  Token: ${cfg.hasToken ? "****" : "(none)"}`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  config
+    .command("remove <projectName>")
+    .description("Remove Jira config (cascades watchers + results)")
+    .action(async (projectName: string) => {
+      try {
+        const { getDb } = await import("../../services/db.service.ts");
+        const project = getDb().query("SELECT id FROM projects WHERE name = ?").get(projectName) as { id: number } | null;
+        if (!project) { console.error(`${C.red}✗${C.reset} Project not found`); process.exit(1); }
+        const { deleteConfig } = await import("../../services/jira-config.service.ts");
+        deleteConfig(project.id);
+        console.log(`${C.green}✓${C.reset} Config removed for "${projectName}"`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+
+  config
+    .command("test <projectName>")
+    .description("Test Jira connection")
+    .action(async (projectName: string) => {
+      try {
+        const { getDb } = await import("../../services/db.service.ts");
+        const project = getDb().query("SELECT id FROM projects WHERE name = ?").get(projectName) as { id: number } | null;
+        if (!project) { console.error(`${C.red}✗${C.reset} Project not found`); process.exit(1); }
+        const { getConfigByProjectId, getDecryptedCredentials } = await import("../../services/jira-config.service.ts");
+        const cfg = getConfigByProjectId(project.id);
+        if (!cfg) { console.error(`${C.red}✗${C.reset} No config found`); process.exit(1); }
+        const creds = getDecryptedCredentials(cfg.id);
+        if (!creds) { console.error(`${C.red}✗${C.reset} Failed to decrypt token`); process.exit(1); }
+        const { testConnection } = await import("../../services/jira-api-client.ts");
+        await testConnection(creds);
+        console.log(`${C.green}✓${C.reset} Connection successful`);
+      } catch (e: any) { console.error(`${C.red}✗${C.reset} ${e.message}`); process.exit(1); }
+    });
+}
+
+// ── Watcher + result + ticket commands ────────────────────────────────
+
+async function registerWatcherCommands(jira: Command): Promise<void> {
+  const { registerJiraWatcherCommands } = await import("./jira-watcher-cmd.ts");
+  registerJiraWatcherCommands(jira);
+}

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