comfy-pr 1.4.2 → 1.5.0

package/bot/cli.ts

@@ -374,6 +374,39 @@ async function main() {
             await loadEnvLocal();
 
             const url = args.url as string;
+
+            // Handle @username — resolve to DM channel then read recent messages
+            if (url.startsWith("@")) {
+              const { getSlack } = await import("@/lib/slack");
+              const slack = getSlack();
+              const name = url.slice(1).toLowerCase();
+              type SlackUser = { id?: string; name?: string; real_name?: string };
+              let found: SlackUser | undefined;
+              let cursor: string | undefined;
+              do {
+                const res = await slack.users.list({ limit: 200, ...(cursor ? { cursor } : {}) });
+                found = (res.members as SlackUser[] | undefined)?.find(
+                  (u) =>
+                    (u.name ?? "").toLowerCase() === name ||
+                    (u.real_name ?? "").toLowerCase() === name,
+                );
+                cursor = res.response_metadata?.next_cursor || undefined;
+              } while (!found && cursor);
+              if (!found?.id) {
+                console.error(`User not found: ${url}`);
+                process.exit(1);
+              }
+              const dmRes = await slack.conversations.open({ users: found.id });
+              const channelId = dmRes.channel?.id;
+              if (!channelId) {
+                console.error("Could not open DM");
+                process.exit(1);
+              }
+              const messages = await readRecentMessages(channelId, 20);
+              console.log(yaml.stringify(messages));
+              return;
+            }
+
             const parsed = parseSlackUrlSmart(url);
 
             switch (parsed.type) {

package/bot/error-collector.ts

@@ -1,8 +1,12 @@
 /**
  * Error Collector - Monitors child workspace for errors and collects them
+ *
+ * Strategy: fs.watch for fast event-driven response, plus a slow safety-net
+ * poll (default 60s) since recursive watch can drop events on some FS layers
+ * and inside containers.
  */
 
-import { readdir, readFile, appendFile, mkdir } from "fs/promises";
+import { readdir, readFile, appendFile, mkdir, watch } from "fs/promises";
 import { existsSync } from "fs";
 import path from "path";
 
@@ -19,13 +23,16 @@ export class ErrorCollector {
   private onError?: (errorPath: string, content: string) => void;
   private checkInterval: number;
   private intervalId?: Timer;
+  private watchAbort?: AbortController;
   private processedErrors = new Set<string>();
+  private debounceTimers = new Map<string, Timer>();
 
   constructor(options: ErrorCollectorOptions) {
     this.workspaceDir = options.workspaceDir;
     this.outputLogPath = options.outputLogPath;
     this.onError = options.onError;
-    this.checkInterval = options.checkInterval || 10000; // 10 seconds default
+    // Slow safety-net poll. Real-time detection comes from fs.watch.
+    this.checkInterval = options.checkInterval || 60_000;
   }
 
   async start() {
@@ -35,7 +42,46 @@ export class ErrorCollector {
     // Initial scan
     await this.scanForErrors();
 
-    // Periodic scanning
+    // Event-driven watcher (recursive). Bursts of writes are coalesced via
+    // a 500ms per-file debounce.
+    if (existsSync(this.workspaceDir)) {
+      this.watchAbort = new AbortController();
+      (async () => {
+        try {
+          const watcher = watch(this.workspaceDir, {
+            recursive: true,
+            signal: this.watchAbort!.signal,
+          });
+          for await (const ev of watcher) {
+            const filename = ev.filename;
+            if (!filename) continue;
+            const lower = filename.toLowerCase();
+            const looksLikeError =
+              lower.includes("error") ||
+              /-errors?\.md$/i.test(filename) ||
+              /tools[_-]errors\.md$/i.test(filename);
+            if (!looksLikeError) continue;
+
+            const full = path.join(this.workspaceDir, filename);
+            const prev = this.debounceTimers.get(full);
+            if (prev) clearTimeout(prev);
+            this.debounceTimers.set(
+              full,
+              setTimeout(() => {
+                this.debounceTimers.delete(full);
+                this.processErrorFile(full).catch(() => {});
+              }, 500),
+            );
+          }
+        } catch (err: unknown) {
+          if ((err as { name?: string })?.name !== "AbortError") {
+            console.error("[ErrorCollector] watch failed, falling back to poll only:", err);
+          }
+        }
+      })();
+    }
+
+    // Periodic scanning (safety net for FS layers that drop watch events)
     this.intervalId = setInterval(() => {
       this.scanForErrors().catch((err) => {
         console.error("[ErrorCollector] Scan failed:", err);
@@ -48,6 +94,10 @@ export class ErrorCollector {
       clearInterval(this.intervalId);
       this.intervalId = undefined;
     }
+    this.watchAbort?.abort();
+    this.watchAbort = undefined;
+    for (const t of this.debounceTimers.values()) clearTimeout(t);
+    this.debounceTimers.clear();
   }
 
   private async scanForErrors() {

package/bot/index.ts

@@ -5,9 +5,56 @@
  * Slack Bot
  * @author snomiao <snomiao@gmail.com>
  */
+import { join } from "path";
+
+/**
+ * Load .env.local with override semantics so that values in the file
+ * take precedence over stale shell env vars injected by pm2/parent shell.
+ * Prevents the SLACK_SIGNING_SECRET mismatch incident (2026-04-24).
+ */
+async function loadEnvLocalWithOverride() {
+  const envPath = join(import.meta.dir, "../.env.local");
+  try {
+    const text = await Bun.file(envPath).text();
+    let applied = 0;
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq <= 0) continue;
+      const key = trimmed.slice(0, eq).trim();
+      const value = trimmed
+        .slice(eq + 1)
+        .trim()
+        .replace(/^["']|["']$/g, "");
+      process.env[key] = value;
+      applied++;
+    }
+    console.log(`[env] Loaded ${applied} entries from ${envPath} (override)`);
+  } catch {
+    console.log(`[env] ${envPath} not found, using shell env only`);
+  }
+
+  // Log short prefixes (≤6 chars) so an operator can confirm the right
+  // value loaded without exposing enough to attempt token reuse if the log
+  // ends up shared. PRBOT_PORT and NODE_ENV are not secrets so the full
+  // value is fine.
+  const prefix = (k: string) =>
+    `${k}=${process.env[k] ? process.env[k]!.slice(0, 6) + "…" : "(unset)"}`;
+  const literal = (k: string) => `${k}=${process.env[k] ?? "(unset)"}`;
+  console.log(
+    "[env] " +
+      [
+        prefix("SLACK_SIGNING_SECRET"),
+        prefix("SLACK_BOT_TOKEN"),
+        literal("PRBOT_PORT"),
+        literal("NODE_ENV"),
+      ].join(" | "),
+  );
+}
 
-// supports only slack now
 if (import.meta.main) {
+  await loadEnvLocalWithOverride();
   console.log("Starting ComfyPR Slack Bot...");
   const client = await (await import("./slack-bot.ts")).startSlackBot();
   console.log("ComfyPR Slack Bot Done.");