comfy-pr 0.2.26 → 1.0.1

package/bot/RestartManager.spec.ts

@@ -0,0 +1,163 @@
+import { describe, test, expect, beforeEach, afterEach, mock } from "bun:test";
+import { RestartManager } from "./RestartManager";
+import { writeFile, mkdir, rm } from "fs/promises";
+import { join } from "path";
+
+describe("RestartManager", () => {
+  let testDir: string;
+  let restartManager: RestartManager;
+  let isIdleMock: ReturnType<typeof mock>;
+  let onRestartMock: ReturnType<typeof mock>;
+
+  beforeEach(async () => {
+    // Create a temporary test directory
+    testDir = join(process.cwd(), ".test-restart-manager");
+    await mkdir(testDir, { recursive: true });
+
+    // Create mocks
+    isIdleMock = mock(() => true);
+    onRestartMock = mock(() => {});
+  });
+
+  afterEach(async () => {
+    // Clean up
+    if (restartManager) {
+      restartManager.stop();
+    }
+    await rm(testDir, { recursive: true, force: true });
+  });
+
+  test("should start watching directories", () => {
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+      debounceDelay: 100,
+      idleCheckInterval: 100,
+    });
+
+    restartManager.start();
+    // If no error is thrown, the test passes
+    expect(true).toBe(true);
+  });
+
+  test("should queue restart when file changes and bot is idle", async () => {
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+      debounceDelay: 100,
+      idleCheckInterval: 100,
+    });
+
+    restartManager.start();
+
+    // Manually trigger file change (simulating what fs.watch would do)
+    // @ts-ignore - accessing private method for testing
+    restartManager.onFileChange("test.ts");
+
+    // Wait for debounce + idle check
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    // Should have called onRestart since bot is idle
+    expect(onRestartMock).toHaveBeenCalled();
+  });
+
+  test("should wait for idle state before restarting", async () => {
+    let isIdle = false;
+    isIdleMock = mock(() => isIdle);
+
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+      debounceDelay: 100,
+      idleCheckInterval: 100,
+    });
+
+    restartManager.start();
+
+    // Manually trigger file change
+    // @ts-ignore - accessing private method for testing
+    restartManager.onFileChange("test.ts");
+
+    // Wait for debounce
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Should not have restarted yet (bot is busy)
+    expect(onRestartMock).not.toHaveBeenCalled();
+
+    // Make bot idle
+    isIdle = true;
+
+    // Wait for idle check
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // Should have restarted now
+    expect(onRestartMock).toHaveBeenCalled();
+  });
+
+  test("should ignore markdown files", async () => {
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+      debounceDelay: 100,
+      idleCheckInterval: 100,
+    });
+
+    restartManager.start();
+
+    // Create a markdown file (should be ignored)
+    const mdFile = join(testDir, "README.md");
+    await writeFile(mdFile, "# Test");
+
+    // Wait for debounce + idle check
+    await new Promise((resolve) => setTimeout(resolve, 300));
+
+    // Should NOT have called onRestart (markdown files are ignored)
+    expect(onRestartMock).not.toHaveBeenCalled();
+  });
+
+  test("should debounce multiple file changes", async () => {
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+      debounceDelay: 200,
+      idleCheckInterval: 100,
+    });
+
+    restartManager.start();
+
+    // Trigger multiple file changes quickly
+    // @ts-ignore - accessing private method for testing
+    restartManager.onFileChange("test1.ts");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // @ts-ignore
+    restartManager.onFileChange("test2.ts");
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    // @ts-ignore
+    restartManager.onFileChange("test3.ts");
+
+    // Wait for debounce + idle check
+    await new Promise((resolve) => setTimeout(resolve, 400));
+
+    // Should only restart once despite multiple changes
+    expect(onRestartMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("should stop watching when stop() is called", () => {
+    restartManager = new RestartManager({
+      watchPaths: [testDir],
+      isIdle: isIdleMock,
+      onRestart: onRestartMock,
+    });
+
+    restartManager.start();
+    restartManager.stop();
+
+    // If no error is thrown, the test passes
+    expect(true).toBe(true);
+  });
+});

package/bot/RestartManager.ts

@@ -0,0 +1,190 @@
+import { watch, type FSWatcher } from "fs";
+import { resolve } from "path";
+
+/**
+ * RestartManager watches for file changes and queues a restart
+ * that only executes when the bot is idle (no active tasks).
+ *
+ * @example
+ * const restartManager = new RestartManager({
+ *   watchPaths: ['bot/**\/*.ts', 'src/**\/*.ts'],
+ *   isIdle: () => TaskInputFlows.size === 0,
+ *   onRestart: () => process.exit(0),
+ *   idleCheckInterval: 5000,
+ *   debounceDelay: 1000
+ * });
+ * restartManager.start();
+ */
+export class RestartManager {
+  private restartPending = false;
+  private watchers: FSWatcher[] = [];
+  private debounceTimer: Timer | null = null;
+  private idleCheckTimer: Timer | null = null;
+
+  constructor(
+    private options: {
+      /** Paths to watch for changes (can use glob patterns with Bun) */
+      watchPaths: string[];
+      /** Function that returns true when the bot is idle */
+      isIdle: () => boolean;
+      /** Callback to execute the restart (typically process.exit(0)) */
+      onRestart: () => void;
+      /** How often to check if bot is idle (ms) */
+      idleCheckInterval?: number;
+      /** Debounce delay for file changes (ms) */
+      debounceDelay?: number;
+      /** Logger function */
+      logger?: {
+        info: (msg: string, meta?: unknown) => void;
+        warn: (msg: string, meta?: unknown) => void;
+      };
+    },
+  ) {
+    this.options.idleCheckInterval ??= 5000;
+    this.options.debounceDelay ??= 1000;
+    this.options.logger ??= {
+      info: (msg) => console.log(`[RestartManager] ${msg}`),
+      warn: (msg) => console.warn(`[RestartManager] ${msg}`),
+    };
+  }
+
+  /**
+   * Start watching for file changes
+   */
+  start() {
+    const { watchPaths, logger } = this.options;
+
+    logger!.info(`Starting file watcher for ${watchPaths.length} paths`);
+
+    for (const watchPath of watchPaths) {
+      try {
+        const absolutePath = resolve(watchPath);
+        const watcher = watch(absolutePath, { recursive: true }, (eventType, filename) => {
+          logger!.info(`File event: ${eventType} on ${filename}`);
+          if (filename) {
+            this.onFileChange(filename);
+          }
+        });
+
+        this.watchers.push(watcher);
+        logger!.info(`Watching: ${absolutePath}`);
+      } catch (error) {
+        logger!.warn(`Failed to watch ${watchPath}: ${error}`);
+      }
+    }
+  }
+
+  /**
+   * Stop watching and clear pending restart
+   */
+  stop() {
+    const { logger } = this.options;
+
+    for (const watcher of this.watchers) {
+      watcher.close();
+    }
+    this.watchers = [];
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+
+    if (this.idleCheckTimer) {
+      clearInterval(this.idleCheckTimer);
+      this.idleCheckTimer = null;
+    }
+
+    this.restartPending = false;
+    logger!.info("File watcher stopped");
+  }
+
+  /**
+   * Handle file change event
+   */
+  private onFileChange(filename: string) {
+    const { debounceDelay, logger } = this.options;
+
+    // Ignore certain files
+    if (this.shouldIgnoreFile(filename)) {
+      return;
+    }
+
+    logger!.info(`File changed: ${filename}`);
+
+    // Clear existing debounce timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+    }
+
+    // Debounce file changes
+    this.debounceTimer = setTimeout(() => {
+      this.queueRestart();
+    }, debounceDelay);
+  }
+
+  /**
+   * Queue a restart to execute when idle
+   */
+  private queueRestart() {
+    const { logger, isIdle, idleCheckInterval } = this.options;
+
+    if (this.restartPending) {
+      logger!.info("Restart already pending, skipping duplicate queue");
+      return;
+    }
+
+    this.restartPending = true;
+    logger!.warn("⏳ Restart queued - waiting for bot to become idle...");
+
+    // Check if already idle
+    if (isIdle()) {
+      this.executeRestart();
+      return;
+    }
+
+    // Start checking for idle state
+    this.idleCheckTimer = setInterval(() => {
+      if (isIdle()) {
+        this.executeRestart();
+      } else {
+        logger!.info("Bot is busy, waiting for idle state...");
+      }
+    }, idleCheckInterval);
+  }
+
+  /**
+   * Execute the restart
+   */
+  private executeRestart() {
+    const { logger, onRestart } = this.options;
+
+    if (this.idleCheckTimer) {
+      clearInterval(this.idleCheckTimer);
+      this.idleCheckTimer = null;
+    }
+
+    logger!.warn("🔄 Bot is idle - restarting now!");
+    this.stop();
+    onRestart();
+  }
+
+  /**
+   * Check if file should be ignored
+   */
+  private shouldIgnoreFile(filename: string): boolean {
+    const ignorePatterns = [
+      /node_modules/,
+      /\.cache/,
+      /\.logs/,
+      /\.git/,
+      /\.nedb/,
+      /\.sqlite/,
+      /\.log$/,
+      /\.md$/, // Ignore markdown files
+      /~$/, // Ignore temp files
+    ];
+
+    return ignorePatterns.some((pattern) => pattern.test(filename));
+  }
+}

package/bot/WorkingTasksManager.spec.ts

@@ -0,0 +1,154 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import Keyv from "keyv";
+
+describe("Working Tasks Manager", () => {
+  let State: Keyv;
+
+  beforeEach(() => {
+    // Use in-memory store for testing
+    State = new Keyv();
+  });
+
+  // Helper functions (same as in bot/index.ts)
+  async function addWorkingTask(event: unknown) {
+    const workingTasks = ((await State.get("current-working-tasks")) as
+      | { workingMessageEvents: unknown[] }
+      | undefined) || { workingMessageEvents: [] };
+    const events = workingTasks.workingMessageEvents || [];
+
+    const exists = events.some(
+      (e: unknown) =>
+        (e as Record<string, unknown>).ts === (event as Record<string, unknown>).ts &&
+        (e as Record<string, unknown>).channel === (event as Record<string, unknown>).channel,
+    );
+    if (!exists) {
+      events.push(event);
+      await State.set("current-working-tasks", { workingMessageEvents: events });
+    }
+  }
+
+  async function removeWorkingTask(event: unknown) {
+    const workingTasks = ((await State.get("current-working-tasks")) as
+      | { workingMessageEvents: unknown[] }
+      | undefined) || { workingMessageEvents: [] };
+    const events = workingTasks.workingMessageEvents || [];
+
+    const filtered = events.filter(
+      (e: unknown) =>
+        !(
+          (e as Record<string, unknown>).ts === (event as Record<string, unknown>).ts &&
+          (e as Record<string, unknown>).channel === (event as Record<string, unknown>).channel
+        ),
+    );
+    await State.set("current-working-tasks", { workingMessageEvents: filtered });
+  }
+
+  test("should add task to working list", async () => {
+    const event = {
+      type: "app_mention" as const,
+      user: "U123",
+      ts: "1234567890.123456",
+      text: "test message",
+      team: "T123",
+      blocks: [],
+      channel: "C123",
+      event_ts: "1234567890.123456",
+    };
+
+    await addWorkingTask(event);
+
+    const workingTasks = (await State.get("current-working-tasks")) as
+      | { workingMessageEvents: Array<Record<string, unknown>> }
+      | undefined;
+    expect(workingTasks).toBeDefined();
+    expect(workingTasks?.workingMessageEvents).toHaveLength(1);
+    expect(workingTasks?.workingMessageEvents[0].ts).toBe(event.ts);
+  });
+
+  test("should not add duplicate tasks", async () => {
+    const event = {
+      type: "app_mention" as const,
+      user: "U123",
+      ts: "1234567890.123456",
+      text: "test message",
+      team: "T123",
+      blocks: [],
+      channel: "C123",
+      event_ts: "1234567890.123456",
+    };
+
+    await addWorkingTask(event);
+    await addWorkingTask(event); // Add same event again
+
+    const workingTasks = (await State.get("current-working-tasks")) as
+      | { workingMessageEvents: unknown[] }
+      | undefined;
+    expect(workingTasks?.workingMessageEvents).toHaveLength(1);
+  });
+
+  test("should remove task from working list", async () => {
+    const event = {
+      type: "app_mention" as const,
+      user: "U123",
+      ts: "1234567890.123456",
+      text: "test message",
+      team: "T123",
+      blocks: [],
+      channel: "C123",
+      event_ts: "1234567890.123456",
+    };
+
+    await addWorkingTask(event);
+    await removeWorkingTask(event);
+
+    const workingTasks = (await State.get("current-working-tasks")) as
+      | { workingMessageEvents: unknown[] }
+      | undefined;
+    expect(workingTasks?.workingMessageEvents).toHaveLength(0);
+  });
+
+  test("should handle multiple tasks", async () => {
+    const event1 = {
+      type: "app_mention" as const,
+      user: "U123",
+      ts: "1234567890.123456",
+      text: "test message 1",
+      team: "T123",
+      blocks: [],
+      channel: "C123",
+      event_ts: "1234567890.123456",
+    };
+
+    const event2 = {
+      type: "app_mention" as const,
+      user: "U456",
+      ts: "1234567890.654321",
+      text: "test message 2",
+      team: "T123",
+      blocks: [],
+      channel: "C456",
+      event_ts: "1234567890.654321",
+    };
+
+    await addWorkingTask(event1);
+    await addWorkingTask(event2);
+
+    let workingTasks = (await State.get("current-working-tasks")) as
+      | { workingMessageEvents: Array<Record<string, unknown>> }
+      | undefined;
+    expect(workingTasks?.workingMessageEvents).toHaveLength(2);
+
+    await removeWorkingTask(event1);
+
+    workingTasks = (await State.get("current-working-tasks")) as
+      | { workingMessageEvents: Array<Record<string, unknown>> }
+      | undefined;
+    expect(workingTasks?.workingMessageEvents).toHaveLength(1);
+    expect(workingTasks?.workingMessageEvents[0].ts).toBe(event2.ts);
+  });
+
+  test("should handle empty state on first access", async () => {
+    const workingTasks = await State.get("current-working-tasks");
+    expect(workingTasks).toBeUndefined();
+  });
+});