@gowelle/stint-agent 1.2.37 → 1.2.39

package/dist/{chunk-NODAAPCO.js → chunk-IFPIIRU3.js}

@@ -1,15 +1,15 @@
 import {
   apiService
-} from "./chunk-IBGWKTT7.js";
+} from "./chunk-4WAUHGFS.js";
 import {
   gitService,
   projectService
-} from "./chunk-XRNTJYCQ.js";
+} from "./chunk-LU6CQVSL.js";
 import {
   authService,
   config,
   logger
-} from "./chunk-HPHXBSGB.js";
+} from "./chunk-PWOHR6IZ.js";
 
 // src/utils/notify.ts
 import notifier from "node-notifier";
@@ -263,10 +263,25 @@ var hookService = new HookService();
 var CommitQueueProcessor = class {
   queue = [];
   isProcessing = false;
+  currentCommitId = null;
+  /**
+   * Check if commit is already in queue or processing
+   */
+  hasCommit(commitId) {
+    if (this.currentCommitId === commitId) return true;
+    return this.queue.some((item) => item.commit.id === commitId);
+  }
   /**
    * Add commit to processing queue
    */
   addToQueue(commit, project) {
+    if (this.hasCommit(commit.id)) {
+      logger.info(
+        "queue",
+        `Commit ${commit.id} is already in the queue or being processed. Skipping.`
+      );
+      return;
+    }
     this.queue.push({ commit, project });
     logger.info(
       "queue",
@@ -287,6 +302,7 @@ var CommitQueueProcessor = class {
     while (this.queue.length > 0) {
       const item = this.queue.shift();
       if (!item) break;
+      this.currentCommitId = item.commit.id;
       try {
         await this.executeCommit(item.commit, item.project);
       } catch (error) {
@@ -295,6 +311,8 @@ var CommitQueueProcessor = class {
           `Failed to execute commit ${item.commit.id}`,
           error
         );
+      } finally {
+        this.currentCommitId = null;
       }
     }
     this.isProcessing = false;
@@ -595,10 +613,12 @@ var WebSocketServiceImpl = class {
   echo = null;
   userId = null;
   reconnectAttempts = 0;
-  maxReconnectAttempts = 10;
+  maxReconnectAttempts = -1;
+  // -1 = infinite reconnection
   reconnectTimer = null;
   isManualDisconnect = false;
   currentPusherClient = null;
+  lastSuccessfulConnection = null;
   // Event handlers
   commitApprovedHandlers = [];
   commitPendingHandlers = [];
@@ -775,6 +795,7 @@ var WebSocketServiceImpl = class {
             "\u2705 Connected to Broadcaster via Sanctum"
           );
           writeStatus({ connected: true });
+          this.lastSuccessfulConnection = /* @__PURE__ */ new Date();
           this.reconnectAttempts = 0;
           this.isManualDisconnect = false;
           safeResolve();
@@ -890,7 +911,7 @@ var WebSocketServiceImpl = class {
               "websocket",
               `Commit ${commit.id} marked as large, fetching full details...`
             );
-            const { apiService: apiService2 } = await import("./api-AFSILC7K.js");
+            const { apiService: apiService2 } = await import("./api-JGCDZSG6.js");
             const fullCommit = await apiService2.getCommit(commit.id);
             commit = {
               ...commit,
@@ -934,7 +955,7 @@ var WebSocketServiceImpl = class {
         (handler) => handler(data.suggestion)
       );
     }).listen(".project.updated", (data) => {
-      logger.info("websocket", `Project updated: ${data.project.id}`);
+      logger.debug("websocket", `Project updated: ${data.project.id}`);
       writeStatus({
         lastEvent: "project.updated",
         lastEventTime: (/* @__PURE__ */ new Date()).toISOString()
@@ -997,19 +1018,30 @@ var WebSocketServiceImpl = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
-    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+    if (this.maxReconnectAttempts === -1 || this.reconnectAttempts < this.maxReconnectAttempts) {
       const delay = this.getReconnectDelay();
       this.reconnectAttempts++;
-      logger.info(
-        "websocket",
-        `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
-      );
+      const attemptInfo = this.maxReconnectAttempts === -1 ? `attempt ${this.reconnectAttempts}` : `attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts}`;
+      logger.info("websocket", `Reconnecting in ${delay}ms (${attemptInfo})`);
       this.reconnectTimer = setTimeout(async () => {
         try {
+          const token = await authService.getToken();
+          if (!token) {
+            logger.error(
+              "websocket",
+              "Cannot reconnect: authentication token expired or missing"
+            );
+            this.handleDisconnect();
+            return;
+          }
           await this.connect();
           if (this.userId) {
             await this.subscribeToUserChannel(this.userId);
           }
+          logger.success(
+            "websocket",
+            `Reconnected successfully after ${this.reconnectAttempts} attempts`
+          );
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
           if (errorMessage.includes("disconnected during connection")) {
@@ -1026,12 +1058,56 @@ var WebSocketServiceImpl = class {
       logger.error("websocket", "Max reconnection attempts reached");
     }
   }
+  /**
+   * Force a reconnection attempt - used by health monitor
+   * Resets attempt counter and triggers immediate reconnection
+   */
+  async forceReconnect() {
+    logger.info("websocket", "Force reconnect requested by health monitor");
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.echo) {
+      this.currentPusherClient = null;
+      this.echo.disconnect();
+      this.echo = null;
+    }
+    try {
+      await this.connect();
+      if (this.userId) {
+        await this.subscribeToUserChannel(this.userId);
+      }
+    } catch (error) {
+      logger.error("websocket", "Force reconnect failed", error);
+      this.handleDisconnect();
+    }
+  }
+  /**
+   * Get the timestamp of last successful connection
+   * Used by health monitor to detect stale connections
+   */
+  getLastSuccessfulConnection() {
+    return this.lastSuccessfulConnection;
+  }
   /**
    * Get reconnect delay with exponential backoff and jitter
    * Jitter prevents thundering herd problem when many clients reconnect simultaneously
+   * Caps at 5 minutes for long-running daemon resilience
    */
   getReconnectDelay() {
-    const delays = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+    const delays = [
+      1e3,
+      2e3,
+      4e3,
+      8e3,
+      16e3,
+      3e4,
+      6e4,
+      12e4,
+      3e5
+    ];
     const index = Math.min(this.reconnectAttempts, delays.length - 1);
     const baseDelay = delays[index];
     const jitter = baseDelay * (Math.random() * 0.3);

package/dist/{chunk-XRNTJYCQ.js → chunk-LU6CQVSL.js}

@@ -1,7 +1,7 @@
 import {
   config,
   logger
-} from "./chunk-HPHXBSGB.js";
+} from "./chunk-PWOHR6IZ.js";
 
 // src/services/git.ts
 import simpleGit from "simple-git";

package/dist/{chunk-HPHXBSGB.js → chunk-PWOHR6IZ.js}

@@ -346,7 +346,7 @@ var AuthServiceImpl = class {
       return null;
     }
     try {
-      const { apiService } = await import("./api-AFSILC7K.js");
+      const { apiService } = await import("./api-JGCDZSG6.js");
       const user = await apiService.getCurrentUser();
       logger.info("auth", `Token validated for user: ${user.email}`);
       return user;

package/dist/daemon/runner.js

@@ -3,20 +3,20 @@ import {
   commitQueue,
   notify,
   websocketService
-} from "../chunk-NODAAPCO.js";
+} from "../chunk-IFPIIRU3.js";
 import {
   apiService
-} from "../chunk-IBGWKTT7.js";
+} from "../chunk-4WAUHGFS.js";
 import {
   gitService,
   projectService,
   removePidFile,
   writePidFile
-} from "../chunk-XRNTJYCQ.js";
+} from "../chunk-LU6CQVSL.js";
 import {
   authService,
   logger
-} from "../chunk-HPHXBSGB.js";
+} from "../chunk-PWOHR6IZ.js";
 
 // src/daemon/runner.ts
 import "dotenv/config";
@@ -310,31 +310,173 @@ async function syncPendingCommits() {
       "sync",
       `Checking ${relevantProjects.length} projects for pending commits...`
     );
-    for (const project of relevantProjects) {
-      try {
-        const pendingCommits = await apiService.getPendingCommits(project.id);
-        if (pendingCommits.length > 0) {
-          logger.info(
+    await Promise.all(
+      relevantProjects.map(async (project) => {
+        try {
+          const pendingCommits = await apiService.getPendingCommits(project.id);
+          if (pendingCommits.length > 0) {
+            logger.info(
+              "sync",
+              `Found ${pendingCommits.length} pending commits for project ${project.name}`
+            );
+            for (const commit of pendingCommits) {
+              commitQueue.addToQueue(commit, project);
+            }
+          }
+        } catch (error) {
+          logger.error(
             "sync",
-            `Found ${pendingCommits.length} pending commits for project ${project.name}`
+            `Failed to sync commits for project ${project.name}`,
+            error
           );
-          for (const commit of pendingCommits) {
-            commitQueue.addToQueue(commit, project);
-          }
         }
+      })
+    );
+    logger.success("sync", "Pending commit sync complete");
+  } catch (error) {
+    logger.error("sync", "Failed to sync pending commits", error);
+  }
+}
+
+// src/daemon/health.ts
+var HealthMonitor = class {
+  checkInterval = null;
+  startTime = null;
+  lastSuccessfulHeartbeat = null;
+  consecutiveFailures = 0;
+  maxConsecutiveFailures = 3;
+  checkIntervalMs = 9e4;
+  // 90 seconds
+  /**
+   * Start the health monitor
+   */
+  start() {
+    if (this.checkInterval) {
+      logger.warn("health", "Health monitor already running");
+      return;
+    }
+    this.startTime = /* @__PURE__ */ new Date();
+    this.consecutiveFailures = 0;
+    logger.info("health", "Starting health monitor (90s interval)");
+    this.checkInterval = setInterval(() => {
+      this.performHealthCheck().catch((error) => {
+        logger.error("health", "Health check error", error);
+      });
+    }, this.checkIntervalMs);
+  }
+  /**
+   * Stop the health monitor
+   */
+  stop() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+      logger.info("health", "Health monitor stopped");
+    }
+  }
+  /**
+   * Record a successful heartbeat
+   * Called by the daemon after each successful API heartbeat
+   */
+  recordHeartbeat() {
+    this.lastSuccessfulHeartbeat = /* @__PURE__ */ new Date();
+    if (this.consecutiveFailures > 0) {
+      logger.info(
+        "health",
+        `Health restored after ${this.consecutiveFailures} consecutive failures`
+      );
+      this.consecutiveFailures = 0;
+    }
+  }
+  /**
+   * Get current health status
+   */
+  getStatus() {
+    const websocketConnected = websocketService.isConnected();
+    const lastSuccessfulConnection = websocketService.getLastSuccessfulConnection();
+    const heartbeatStale = this.isHeartbeatStale();
+    const healthy = websocketConnected && !heartbeatStale;
+    return {
+      healthy,
+      websocketConnected,
+      lastSuccessfulHeartbeat: this.lastSuccessfulHeartbeat,
+      lastSuccessfulConnection,
+      consecutiveFailures: this.consecutiveFailures,
+      uptime: this.startTime ? Math.floor((Date.now() - this.startTime.getTime()) / 1e3) : 0
+    };
+  }
+  /**
+   * Perform a health check and trigger recovery if needed
+   */
+  async performHealthCheck() {
+    const status = this.getStatus();
+    logger.debug(
+      "health",
+      `Health check: connected=${status.websocketConnected}, heartbeat_stale=${this.isHeartbeatStale()}, failures=${this.consecutiveFailures}`
+    );
+    if (!status.healthy) {
+      this.consecutiveFailures++;
+      logger.warn(
+        "health",
+        `Unhealthy state detected (${this.consecutiveFailures}/${this.maxConsecutiveFailures})`
+      );
+      if (this.consecutiveFailures >= this.maxConsecutiveFailures) {
+        await this.triggerRecovery();
+      }
+    } else {
+      if (this.consecutiveFailures > 0) {
+        logger.info("health", "Health restored");
+        this.consecutiveFailures = 0;
+      }
+    }
+  }
+  /**
+   * Check if heartbeat is stale (no successful heartbeat in 3 minutes)
+   */
+  isHeartbeatStale() {
+    if (!this.lastSuccessfulHeartbeat) {
+      if (this.startTime) {
+        const sinceSart = Date.now() - this.startTime.getTime();
+        return sinceSart > 12e4;
+      }
+      return false;
+    }
+    const staleThreshold = 18e4;
+    const timeSinceHeartbeat = Date.now() - this.lastSuccessfulHeartbeat.getTime();
+    return timeSinceHeartbeat > staleThreshold;
+  }
+  /**
+   * Trigger recovery actions
+   */
+  async triggerRecovery() {
+    logger.warn(
+      "health",
+      "Triggering recovery due to persistent unhealthy state"
+    );
+    this.consecutiveFailures = 0;
+    if (!websocketService.isConnected()) {
+      logger.info("health", "Forcing WebSocket reconnection...");
+      try {
+        await websocketService.forceReconnect();
+        logger.success("health", "WebSocket reconnection initiated");
       } catch (error) {
         logger.error(
-          "sync",
-          `Failed to sync commits for project ${project.name}`,
+          "health",
+          "Failed to force WebSocket reconnection",
           error
         );
       }
     }
-    logger.success("sync", "Pending commit sync complete");
-  } catch (error) {
-    logger.error("sync", "Failed to sync pending commits", error);
+    try {
+      await apiService.heartbeat();
+      this.recordHeartbeat();
+      logger.success("health", "API session verified");
+    } catch (error) {
+      logger.error("health", "API session check failed", error);
+    }
   }
-}
+};
+var healthMonitor = new HealthMonitor();
 
 // src/daemon/index.ts
 var heartbeatInterval = null;
@@ -390,18 +532,16 @@ Project: ${project.name}`,
       });
     });
     websocketService.onProjectUpdated((project) => {
-      logger.info("daemon", `Project updated: ${project.id} - ${project.name}`);
+      logger.debug(
+        "daemon",
+        `Project updated: ${project.id} - ${project.name}`
+      );
       if (project.settings?.auto_sync) {
         fileWatcher.updateProjectSettings(
           project.id,
           project.settings.auto_sync
         );
       }
-      notify({
-        title: "Project Updated",
-        message: project.name,
-        category: "sync"
-      });
     });
     websocketService.onDisconnect(() => {
       logger.warn(
@@ -456,6 +596,7 @@ Priority: ${suggestion.priority}`,
     });
     setupSignalHandlers();
     startHeartbeat();
+    healthMonitor.start();
     logger.info("daemon", "Starting file watcher...");
     fileWatcher.start();
     logger.info("daemon", "Daemon started successfully");
@@ -466,17 +607,19 @@ Priority: ${suggestion.priority}`,
         "daemon",
         `Syncing ${projectEntries.length} linked project(s) on startup...`
       );
-      for (const [, linkedProject] of projectEntries) {
-        try {
-          await fileWatcher.syncProjectById(linkedProject.projectId);
-        } catch (error) {
-          logger.error(
-            "daemon",
-            `Failed to sync project ${linkedProject.projectId} on startup`,
-            error
-          );
-        }
-      }
+      await Promise.all(
+        projectEntries.map(async ([, linkedProject]) => {
+          try {
+            await fileWatcher.syncProjectById(linkedProject.projectId);
+          } catch (error) {
+            logger.error(
+              "daemon",
+              `Failed to sync project ${linkedProject.projectId} on startup`,
+              error
+            );
+          }
+        })
+      );
       logger.success("daemon", "Initial project sync complete");
     }
     await syncPendingCommits();
@@ -496,6 +639,7 @@ function startHeartbeat() {
     if (isShuttingDown) return;
     try {
       await apiService.heartbeat();
+      healthMonitor.recordHeartbeat();
       logger.debug("daemon", "Heartbeat sent successfully");
     } catch (error) {
       logger.error("daemon", "Heartbeat failed", error);
@@ -525,6 +669,7 @@ async function shutdown(reason) {
   isShuttingDown = true;
   shutdownReason = reason;
   logger.info("daemon", "Shutting down daemon...");
+  healthMonitor.stop();
   stopHeartbeat();
   try {
     fileWatcher.stop();
@@ -554,7 +699,35 @@ async function shutdown(reason) {
 
 // src/daemon/runner.ts
 writePidFile(process.pid);
-startDaemon().catch((error) => {
-  logger.error("daemon-runner", "Daemon crashed", error);
-  process.exit(1);
+var startupAttempts = 0;
+var maxStartupAttempts = 5;
+async function startWithRetry() {
+  while (startupAttempts < maxStartupAttempts) {
+    try {
+      startupAttempts++;
+      await startDaemon();
+      logger.warn("daemon-runner", "Daemon exited unexpectedly, restarting...");
+    } catch (error) {
+      logger.error(
+        "daemon-runner",
+        `Daemon startup failed (attempt ${startupAttempts}/${maxStartupAttempts})`,
+        error
+      );
+      if (startupAttempts >= maxStartupAttempts) {
+        logger.error("daemon-runner", "Max startup attempts reached, exiting");
+        process.exit(1);
+      }
+      const delay = Math.min(5e3 * Math.pow(2, startupAttempts - 1), 6e4);
+      logger.info("daemon-runner", `Retrying in ${delay}ms...`);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+}
+process.on("uncaughtException", (error) => {
+  logger.error("daemon-runner", "Uncaught exception", error);
+});
+process.on("unhandledRejection", (reason) => {
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  logger.error("daemon-runner", "Unhandled rejection", error);
 });
+startWithRetry();

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   commitQueue,
   websocketService
-} from "./chunk-NODAAPCO.js";
+} from "./chunk-IFPIIRU3.js";
 import {
   apiService
-} from "./chunk-IBGWKTT7.js";
+} from "./chunk-4WAUHGFS.js";
 import {
   getPidFilePath,
   gitService,
@@ -14,14 +14,14 @@ import {
   projectService,
   spawnDetached,
   validatePidFile
-} from "./chunk-XRNTJYCQ.js";
+} from "./chunk-LU6CQVSL.js";
 import {
   __commonJS,
   __toESM,
   authService,
   config,
   logger
-} from "./chunk-HPHXBSGB.js";
+} from "./chunk-PWOHR6IZ.js";
 
 // node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
@@ -1274,7 +1274,7 @@ var require_range = __commonJS({
 var require_comparator = __commonJS({
   "node_modules/semver/classes/comparator.js"(exports, module) {
     "use strict";
-    var ANY = /* @__PURE__ */ Symbol("SemVer ANY");
+    var ANY = Symbol("SemVer ANY");
     var Comparator = class _Comparator {
       static get ANY() {
         return ANY;
@@ -2657,7 +2657,7 @@ function registerStatusCommand(program2) {
       try {
         const { render } = await import("ink");
         const { createElement } = await import("react");
-        const { StatusDashboard } = await import("./StatusDashboard-AMDPK7EQ.js");
+        const { StatusDashboard } = await import("./StatusDashboard-ROFBT73W.js");
         render(createElement(StatusDashboard, { cwd }));
         return;
       } catch (error) {
@@ -4846,7 +4846,7 @@ ${chalk14.bold("Config file:")} ${chalk14.cyan(configPath)}
 }
 
 // src/index.ts
-var AGENT_VERSION = "1.2.37";
+var AGENT_VERSION = "1.2.39";
 var program = new Command();
 program.name("stint").description("Stint Agent - Local daemon for Stint Project Assistant").version(AGENT_VERSION, "-v, --version", "output the current version").addHelpText(
   "after",