@symbiosis-lab/moss-plugin-github 1.5.1

package/src/__tests__/progress-timeout.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Tests for progress reporting timeout fix
+ *
+ * Bug: GitHub Pages polling times out because reportProgress is called AFTER sleep,
+ * causing 60-second inactivity timeout (6 iterations × 5s sleep + API calls = >60s)
+ *
+ * Fix: Move reportProgress to START of each iteration (before sleep) to reset
+ * the inactivity timer every 5 seconds.
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+
+describe("Progress Timeout Fix", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("waitForPagesLive polling loop", () => {
+    it("calls reportProgress BEFORE sleep to reset inactivity timer", async () => {
+      // This test simulates the polling loop structure
+      const reportProgress = vi.fn().mockResolvedValue(undefined);
+      const checkPagesStatus = vi.fn();
+
+      // Simulate 3 iterations where status is "building"
+      checkPagesStatus.mockResolvedValue({ status: "building" });
+
+      const maxAttempts = 3;
+      const pollInterval = 100; // Short interval for testing
+
+      // Track the order of operations
+      const operations: string[] = [];
+
+      // Simulate the CORRECT polling loop (reportProgress BEFORE sleep)
+      for (let i = 0; i < maxAttempts; i++) {
+        operations.push("check-status");
+        await checkPagesStatus();
+
+        // Still building - report progress THEN sleep
+        if (i < maxAttempts - 1) {
+          operations.push(`report-progress-${i + 1}`);
+          await reportProgress("verifying", 9, 10, `Waiting for GitHub Pages... (${i + 1}/${maxAttempts})`);
+
+          operations.push(`sleep-${i + 1}`);
+          await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+      }
+
+      // Verify order: For each iteration, progress is reported BEFORE sleep
+      expect(operations).toEqual([
+        "check-status",
+        "report-progress-1",
+        "sleep-1",
+        "check-status",
+        "report-progress-2",
+        "sleep-2",
+        "check-status",
+      ]);
+
+      // Verify reportProgress was called exactly 2 times (not on last iteration)
+      expect(reportProgress).toHaveBeenCalledTimes(2);
+
+      // Verify each call has the correct iteration number (total=10 for REST API flow)
+      expect(reportProgress).toHaveBeenNthCalledWith(1, "verifying", 9, 10, "Waiting for GitHub Pages... (1/3)");
+      expect(reportProgress).toHaveBeenNthCalledWith(2, "verifying", 9, 10, "Waiting for GitHub Pages... (2/3)");
+    });
+
+    it("demonstrates WRONG pattern (reportProgress AFTER sleep)", async () => {
+      // This test shows the buggy pattern for comparison
+      const reportProgress = vi.fn().mockResolvedValue(undefined);
+      const checkPagesStatus = vi.fn();
+
+      checkPagesStatus.mockResolvedValue({ status: "building" });
+
+      const maxAttempts = 3;
+      const pollInterval = 100;
+
+      const operations: string[] = [];
+
+      // Simulate the BUGGY polling loop (sleep BEFORE reportProgress)
+      for (let i = 0; i < maxAttempts; i++) {
+        operations.push("check-status");
+        await checkPagesStatus();
+
+        // Still building - sleep THEN report progress (WRONG!)
+        if (i < maxAttempts - 1) {
+          operations.push(`sleep-${i + 1}`);
+          await new Promise(resolve => setTimeout(resolve, pollInterval));
+
+          operations.push(`report-progress-${i + 1}`);
+          await reportProgress("verifying", 9, 10, `Waiting for GitHub Pages... (${i + 1}/${maxAttempts})`);
+        }
+      }
+
+      // In buggy pattern: sleep happens BEFORE progress report
+      // This means the inactivity timer is NOT reset until after the sleep
+      expect(operations).toEqual([
+        "check-status",
+        "sleep-1",
+        "report-progress-1",
+        "check-status",
+        "sleep-2",
+        "report-progress-2",
+        "check-status",
+      ]);
+
+      // This demonstrates the problem: with 6 iterations × 5s sleep = 30s of sleeping
+      // Plus API call time, we exceed 60s before resetting the timer
+    });
+
+    it("resets inactivity timer every 5 seconds with correct ordering", async () => {
+      // Mock time to track when reportProgress is called relative to sleep
+      vi.useFakeTimers();
+      const startTime = Date.now();
+
+      const reportProgress = vi.fn().mockResolvedValue(undefined);
+      const checkPagesStatus = vi.fn().mockResolvedValue({ status: "building" });
+
+      const maxAttempts = 6;
+      const pollInterval = 5000; // Real interval: 5 seconds
+
+      const progressCallTimes: number[] = [];
+
+      // Wrap reportProgress to record timing
+      const timedReportProgress = async (...args: Parameters<typeof reportProgress>) => {
+        progressCallTimes.push(Date.now() - startTime);
+        await reportProgress(...args);
+      };
+
+      // Start polling loop
+      const pollingPromise = (async () => {
+        for (let i = 0; i < maxAttempts; i++) {
+          await checkPagesStatus();
+
+          if (i < maxAttempts - 1) {
+            // CORRECT: Report progress BEFORE sleep
+            await timedReportProgress("verifying", 9, 10, `Waiting for GitHub Pages... (${i + 1}/${maxAttempts})`);
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+          }
+        }
+      })();
+
+      // Advance time and flush promises for each iteration
+      for (let i = 0; i < maxAttempts - 1; i++) {
+        await vi.advanceTimersByTimeAsync(pollInterval);
+      }
+
+      await pollingPromise;
+
+      // Verify progress is reported at the START of each 5-second interval
+      // Intervals should be: 0ms, 5000ms, 10000ms, 15000ms, 20000ms
+      expect(progressCallTimes).toHaveLength(5); // 6 attempts - 1 (no progress on last)
+
+      // Each call should be ~5000ms apart
+      for (let i = 1; i < progressCallTimes.length; i++) {
+        const interval = progressCallTimes[i] - progressCallTimes[i - 1];
+        expect(interval).toBe(5000);
+      }
+
+      // First call should happen at time 0 (relative to start)
+      expect(progressCallTimes[0]).toBe(0);
+
+      vi.useRealTimers();
+    });
+
+    it("keeps total polling time under 60 seconds with proper progress reporting", async () => {
+      // With 6 attempts × 5s interval = 30s total sleep time
+      // Plus API call overhead (~1s per call) = ~36s total
+      // This is well under the 60s inactivity timeout when progress is reported correctly
+
+      const maxAttempts = 6;
+      const pollInterval = 5000;
+      const apiCallTime = 1000; // Mock API call taking 1s
+
+      let totalTime = 0;
+
+      // Simulate timing of correct approach
+      for (let i = 0; i < maxAttempts; i++) {
+        // API call
+        totalTime += apiCallTime;
+
+        if (i < maxAttempts - 1) {
+          // Progress report (resets timer) - negligible time
+          totalTime += 1;
+
+          // Sleep
+          totalTime += pollInterval;
+        }
+      }
+
+      // Total time should be under 60s (inactivity timeout)
+      expect(totalTime).toBeLessThan(60000);
+
+      // Actual calculation: 6 × 1000 (API) + 5 × 5000 (sleep) + 5 × 1 (report) = 31005ms
+      expect(totalTime).toBe(31005);
+    });
+  });
+
+  describe("deploy heartbeat interval", () => {
+    it("heartbeat interval must be shorter than progress panel stale timeout (15s)", async () => {
+      // The progress panel auto-removes tasks after STALE_TIMEOUT_MS (15s).
+      // If the deploy heartbeat fires less frequently than that, the progress
+      // bar disappears between heartbeats — making it invisible during long pushes.
+      const { DEPLOY_HEARTBEAT_INTERVAL_MS } = await import("../constants");
+      const STALE_TIMEOUT_MS = 15_000; // from src/preview/progress-panel.ts
+
+      expect(DEPLOY_HEARTBEAT_INTERVAL_MS).toBeLessThan(STALE_TIMEOUT_MS);
+    });
+  });
+});

package/src/__tests__/repo-setup-progress.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Tests for Phase 3 fix: Progress heartbeat during interactive form
+ *
+ * Problem: The 60-second inactivity timer expires while user fills out the
+ * "Choose repository name" form because no progress updates are sent during showBrowserForm().
+ *
+ * Solution: Wrap showBrowserForm with a progress heartbeat that sends updates
+ * every DEPLOY_HEARTBEAT_INTERVAL_MS (10s) to keep the inactivity timer alive
+ * and the progress panel visible (must be < STALE_TIMEOUT_MS of 15s).
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+
+// Mock moss-api
+const mockOpenBrowserWithHtml = vi.fn().mockResolvedValue(undefined);
+const mockCloseBrowser = vi.fn().mockResolvedValue(undefined);
+const mockOnEvent = vi.fn();
+
+vi.mock("@symbiosis-lab/moss-api", () => ({
+  openBrowserWithHtml: (...args: unknown[]) => mockOpenBrowserWithHtml(...args),
+  closeBrowser: () => mockCloseBrowser(),
+  onEvent: (...args: unknown[]) => mockOnEvent(...args),
+  executeBinary: vi.fn().mockResolvedValue({ success: true, stdout: "", stderr: "" }),
+}));
+
+// Mock utils
+const mockReportProgress = vi.fn().mockResolvedValue(undefined);
+
+vi.mock("../utils", () => ({
+  reportProgress: (...args: unknown[]) => mockReportProgress(...args),
+}));
+
+// Mock token module
+const mockGetToken = vi.fn();
+const mockGetTokenFromGit = vi.fn();
+const mockStoreToken = vi.fn();
+
+vi.mock("../token", () => ({
+  getToken: () => mockGetToken(),
+  getTokenFromGit: () => mockGetTokenFromGit(),
+  storeToken: (token: string) => mockStoreToken(token),
+}));
+
+// Mock auth module
+const mockPromptLogin = vi.fn();
+const mockValidateToken = vi.fn();
+const mockHasRequiredScopes = vi.fn();
+
+vi.mock("../auth", () => ({
+  promptLogin: () => mockPromptLogin(),
+  validateToken: (token: string) => mockValidateToken(token),
+  hasRequiredScopes: (scopes: string[]) => mockHasRequiredScopes(scopes),
+}));
+
+// Mock github-api module
+const mockGetAuthenticatedUser = vi.fn();
+const mockCheckRepoExists = vi.fn();
+const mockCreateRepository = vi.fn();
+const mockGetRepoSshUrl = vi.fn();
+
+vi.mock("../github-api", () => ({
+  getAuthenticatedUser: (token: string) => mockGetAuthenticatedUser(token),
+  checkRepoExists: (owner: string, name: string, token: string) => mockCheckRepoExists(owner, name, token),
+  createRepository: (name: string, token: string, description?: string) => mockCreateRepository(name, token, description),
+  getRepoSshUrl: (owner: string, repo: string, token: string) => mockGetRepoSshUrl(owner, repo, token),
+}));
+
+describe("Phase 3: Progress Heartbeat During Interactive Form", () => {
+  let ensureGitHubRepo: () => Promise<{
+    name: string;
+    sshUrl: string;
+    fullName: string;
+  } | null>;
+
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    vi.useRealTimers();
+
+    // Setup: Authenticated user with root repo taken (triggers UI)
+    mockGetToken.mockResolvedValue("test-token");
+    mockGetAuthenticatedUser.mockResolvedValue({ login: "testuser" });
+    mockCheckRepoExists.mockResolvedValue(true); // Root repo exists - triggers UI
+
+    // Dynamic import to get the function
+    const module = await import("../repo-setup");
+    ensureGitHubRepo = module.ensureGitHubRepo;
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("sends progress heartbeat every 30 seconds during form interaction", async () => {
+    vi.useFakeTimers();
+
+    // Simulate user taking 75 seconds to fill out form (should trigger 2 heartbeats)
+    let eventHandler: ((payload: unknown) => void) | null = null;
+    mockOnEvent.mockImplementation(async (eventName: string, handler: (payload: unknown) => void) => {
+      if (eventName === "github:deploy-choice") {
+        eventHandler = handler;
+      }
+      return vi.fn(); // Return unlisten function
+    });
+
+    mockCreateRepository.mockResolvedValue({
+      name: "my-website",
+      fullName: "testuser/my-website",
+      sshUrl: "git@github.com:testuser/my-website.git",
+    });
+
+    // Start the repo setup (will call openBrowserWithHtml and start heartbeat)
+    const resultPromise = ensureGitHubRepo();
+
+    // Fast-forward: 0s -> no heartbeat yet (first one starts immediately but we check calls)
+    await vi.advanceTimersByTimeAsync(0);
+    expect(mockReportProgress).not.toHaveBeenCalled(); // No progress yet
+
+    // Fast-forward: 10s -> first heartbeat
+    await vi.advanceTimersByTimeAsync(10000);
+    expect(mockReportProgress).toHaveBeenCalledTimes(1);
+    expect(mockReportProgress).toHaveBeenCalledWith("setup", 0, 6, "Setting up GitHub repository...");
+
+    // Fast-forward: 20s -> second heartbeat
+    await vi.advanceTimersByTimeAsync(10000);
+    expect(mockReportProgress).toHaveBeenCalledTimes(2);
+    expect(mockReportProgress).toHaveBeenNthCalledWith(2, "setup", 0, 6, "Setting up GitHub repository...");
+
+    // Fast-forward: 25s -> user submits form
+    await vi.advanceTimersByTimeAsync(5000);
+
+    // User submits form via event
+    eventHandler!({ action: "custom-domain", repoName: "my-website" });
+
+    // Wait for completion
+    await vi.runAllTimersAsync();
+    const result = await resultPromise;
+
+    // Total progress calls: 2 heartbeats during form
+    expect(mockReportProgress).toHaveBeenCalledTimes(2);
+
+    // Verify successful result
+    expect(result).toEqual({
+      name: "my-website",
+      sshUrl: "git@github.com:testuser/my-website.git",
+      fullName: "testuser/my-website",
+    });
+  });
+
+  it("clears heartbeat interval when form is submitted", async () => {
+    vi.useFakeTimers();
+
+    // User submits form after 15 seconds (should trigger 1 heartbeat, then clear)
+    let eventHandler: ((payload: unknown) => void) | null = null;
+    mockOnEvent.mockImplementation(async (eventName: string, handler: (payload: unknown) => void) => {
+      if (eventName === "github:deploy-choice") {
+        eventHandler = handler;
+      }
+      return vi.fn();
+    });
+
+    mockCreateRepository.mockResolvedValue({
+      name: "quick-submit",
+      fullName: "testuser/quick-submit",
+      sshUrl: "git@github.com:testuser/quick-submit.git",
+    });
+
+    // Start the repo setup
+    const resultPromise = ensureGitHubRepo();
+
+    // Fast-forward: 15s -> first heartbeat happens at 10s
+    await vi.advanceTimersByTimeAsync(15000);
+    expect(mockReportProgress).toHaveBeenCalledTimes(1);
+
+    // User submits form (should clear interval)
+    eventHandler!({ action: "custom-domain", repoName: "quick-submit" });
+
+    // Wait for completion
+    await vi.runAllTimersAsync();
+    await resultPromise;
+
+    // Reset mock to track future calls
+    mockReportProgress.mockClear();
+
+    // Fast-forward another 10s - NO more heartbeats should occur
+    await vi.advanceTimersByTimeAsync(10000);
+    expect(mockReportProgress).not.toHaveBeenCalled();
+  });
+
+  it("clears heartbeat interval when form is cancelled", async () => {
+    vi.useFakeTimers();
+
+    // User cancels form after 15 seconds (timeout without event)
+    mockOnEvent.mockImplementation(async () => {
+      return vi.fn(); // Don't trigger event handler (simulates cancellation)
+    });
+
+    // Start the repo setup (will timeout after 300s but we'll test before that)
+    const resultPromise = ensureGitHubRepo();
+
+    // Fast-forward: 15s -> first heartbeat happens at 10s
+    await vi.advanceTimersByTimeAsync(15000);
+    expect(mockReportProgress).toHaveBeenCalledTimes(1);
+
+    // Fast-forward to timeout (300s total)
+    await vi.advanceTimersByTimeAsync(285000);
+
+    // Wait for completion
+    await vi.runAllTimersAsync();
+    const result = await resultPromise;
+
+    expect(result).toBeNull();
+
+    // Reset mock to track future calls
+    mockReportProgress.mockClear();
+
+    // Fast-forward another 10s - NO more heartbeats should occur
+    await vi.advanceTimersByTimeAsync(10000);
+    expect(mockReportProgress).not.toHaveBeenCalled();
+  });
+
+  it("prevents timeout during long form interaction (>60s)", async () => {
+    vi.useFakeTimers();
+
+    // Simulate user taking 120 seconds (2 minutes) - should NOT timeout
+    let eventHandler: ((payload: unknown) => void) | null = null;
+    mockOnEvent.mockImplementation(async (eventName: string, handler: (payload: unknown) => void) => {
+      if (eventName === "github:deploy-choice") {
+        eventHandler = handler;
+      }
+      return vi.fn();
+    });
+
+    mockCreateRepository.mockResolvedValue({
+      name: "slow-user",
+      fullName: "testuser/slow-user",
+      sshUrl: "git@github.com:testuser/slow-user.git",
+    });
+
+    // Start the repo setup
+    const resultPromise = ensureGitHubRepo();
+
+    // Fast-forward: 120s in 10s increments to simulate heartbeats
+    await vi.advanceTimersByTimeAsync(10000); // 10s - 1st heartbeat
+    await vi.advanceTimersByTimeAsync(10000); // 20s - 2nd heartbeat
+    await vi.advanceTimersByTimeAsync(10000); // 30s - 3rd heartbeat
+    await vi.advanceTimersByTimeAsync(10000); // 40s - 4th heartbeat
+    await vi.advanceTimersByTimeAsync(80000); // 120s total
+
+    // Verify 12 heartbeats occurred (every 10s for 120s)
+    expect(mockReportProgress).toHaveBeenCalledTimes(12);
+
+    // User finally submits form
+    eventHandler!({ action: "custom-domain", repoName: "slow-user" });
+
+    // Wait for completion
+    await vi.runAllTimersAsync();
+    const result = await resultPromise;
+
+    // Should complete successfully - NO timeout
+    expect(result).toEqual({
+      name: "slow-user",
+      sshUrl: "git@github.com:testuser/slow-user.git",
+      fullName: "testuser/slow-user",
+    });
+  });
+
+  it("uses consistent progress message for all heartbeats", async () => {
+    vi.useFakeTimers();
+
+    let eventHandler: ((payload: unknown) => void) | null = null;
+    mockOnEvent.mockImplementation(async (eventName: string, handler: (payload: unknown) => void) => {
+      if (eventName === "github:deploy-choice") {
+        eventHandler = handler;
+      }
+      return vi.fn();
+    });
+
+    mockCreateRepository.mockResolvedValue({
+      name: "test",
+      fullName: "testuser/test",
+      sshUrl: "git@github.com:testuser/test.git",
+    });
+
+    // Start the repo setup
+    const resultPromise = ensureGitHubRepo();
+
+    // Trigger 3 heartbeats (10s each)
+    await vi.advanceTimersByTimeAsync(10000);
+    await vi.advanceTimersByTimeAsync(10000);
+    await vi.advanceTimersByTimeAsync(10000);
+
+    expect(mockReportProgress).toHaveBeenCalledTimes(3);
+
+    // All heartbeats should use the same message
+    expect(mockReportProgress).toHaveBeenNthCalledWith(1, "setup", 0, 6, "Setting up GitHub repository...");
+    expect(mockReportProgress).toHaveBeenNthCalledWith(2, "setup", 0, 6, "Setting up GitHub repository...");
+    expect(mockReportProgress).toHaveBeenNthCalledWith(3, "setup", 0, 6, "Setting up GitHub repository...");
+
+    // Complete
+    eventHandler!({ action: "custom-domain", repoName: "test" });
+    await vi.runAllTimersAsync();
+    await resultPromise;
+  });
+
+  it("handles openBrowserWithHtml rejection gracefully", async () => {
+    vi.useFakeTimers();
+
+    // Simulate error during browser opening
+    mockOpenBrowserWithHtml.mockRejectedValue(new Error("Form display error"));
+
+    // Start the repo setup (catch the error to prevent unhandled rejection)
+    let result: any;
+    let error: any;
+    try {
+      result = await ensureGitHubRepo();
+    } catch (e) {
+      error = e;
+    }
+
+    // Fast-forward to trigger any pending timers
+    await vi.runAllTimersAsync();
+
+    // Should return null on error (the wrapper catches and returns null)
+    // Or if it throws, that's also acceptable behavior
+    if (!error) {
+      expect(result).toBeNull();
+    }
+
+    // Reset mock to track future calls
+    mockReportProgress.mockClear();
+
+    // Interval should be cleared - no more heartbeats
+    await vi.advanceTimersByTimeAsync(30000);
+    expect(mockReportProgress).not.toHaveBeenCalled();
+  });
+
+  it("does not start heartbeat when auto-creating root repo (no UI)", async () => {
+    vi.useFakeTimers();
+
+    // Root repo doesn't exist - auto-create (no UI)
+    mockCheckRepoExists.mockResolvedValue(false);
+    mockCreateRepository.mockResolvedValue({
+      name: "testuser.github.io",
+      fullName: "testuser/testuser.github.io",
+      sshUrl: "git@github.com:testuser/testuser.github.io.git",
+    });
+
+    // Execute
+    const result = await ensureGitHubRepo();
+
+    // Fast-forward time - should be no heartbeats
+    await vi.advanceTimersByTimeAsync(60000);
+
+    // openBrowserWithHtml should NOT be called (auto-create path)
+    expect(mockOpenBrowserWithHtml).not.toHaveBeenCalled();
+
+    // reportProgress should NOT be called (no heartbeat)
+    expect(mockReportProgress).not.toHaveBeenCalled();
+
+    // Should succeed
+    expect(result).toEqual({
+      name: "testuser.github.io",
+      sshUrl: "git@github.com:testuser/testuser.github.io.git",
+      fullName: "testuser/testuser.github.io",
+    });
+  });
+});