@gowelle/stint-agent 1.0.0

package/dist/daemon/runner.js

@@ -0,0 +1,484 @@
+#!/usr/bin/env node
+import {
+  commitQueue,
+  gitService,
+  projectService,
+  removePidFile,
+  writePidFile
+} from "../chunk-PPODHVVP.js";
+import {
+  apiService,
+  authService,
+  config,
+  logger
+} from "../chunk-5DWSNHS6.js";
+
+// src/daemon/runner.ts
+import "dotenv/config";
+
+// src/services/websocket.ts
+import WebSocket from "ws";
+var WebSocketServiceImpl = class {
+  ws = null;
+  userId = null;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectTimer = null;
+  isManualDisconnect = false;
+  // Event handlers
+  commitApprovedHandlers = [];
+  projectUpdatedHandlers = [];
+  disconnectHandlers = [];
+  async connect() {
+    try {
+      const token = await authService.getToken();
+      if (!token) {
+        throw new Error("No authentication token available");
+      }
+      const wsUrl = config.getWsUrl();
+      const url = `${wsUrl}?token=${encodeURIComponent(token)}`;
+      logger.info("websocket", `Connecting to ${wsUrl}...`);
+      this.ws = new WebSocket(url);
+      return new Promise((resolve, reject) => {
+        if (!this.ws) {
+          reject(new Error("WebSocket not initialized"));
+          return;
+        }
+        this.ws.on("open", () => {
+          logger.success("websocket", "WebSocket connected");
+          this.reconnectAttempts = 0;
+          this.isManualDisconnect = false;
+          resolve();
+        });
+        this.ws.on("message", (data) => {
+          this.handleMessage(data);
+        });
+        this.ws.on("close", () => {
+          logger.warn("websocket", "WebSocket disconnected");
+          this.handleDisconnect();
+        });
+        this.ws.on("error", (error) => {
+          logger.error("websocket", "WebSocket error", error);
+          reject(error);
+        });
+      });
+    } catch (error) {
+      logger.error("websocket", "Failed to connect", error);
+      throw error;
+    }
+  }
+  disconnect() {
+    this.isManualDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      if (this.userId) {
+        this.sendMessage({
+          event: "pusher:unsubscribe",
+          data: {
+            channel: `private-user.${this.userId}`
+          }
+        });
+      }
+      this.ws.close();
+      this.ws = null;
+      logger.info("websocket", "WebSocket disconnected");
+    }
+  }
+  isConnected() {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+  subscribeToUserChannel(userId) {
+    this.userId = userId;
+    if (!this.isConnected()) {
+      logger.warn("websocket", "Cannot subscribe: not connected");
+      return;
+    }
+    const channel = `private-user.${userId}`;
+    logger.info("websocket", `Subscribing to channel: ${channel}`);
+    this.sendMessage({
+      event: "pusher:subscribe",
+      data: {
+        channel
+      }
+    });
+  }
+  onCommitApproved(handler) {
+    this.commitApprovedHandlers.push(handler);
+  }
+  onProjectUpdated(handler) {
+    this.projectUpdatedHandlers.push(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  sendMessage(message) {
+    if (!this.isConnected()) {
+      logger.warn("websocket", "Cannot send message: not connected");
+      return;
+    }
+    this.ws.send(JSON.stringify(message));
+  }
+  handleMessage(data) {
+    try {
+      const message = JSON.parse(data.toString());
+      logger.debug("websocket", `Received message: ${message.event}`);
+      if (message.event === "pusher:connection_established") {
+        logger.success("websocket", "Connection established");
+        return;
+      }
+      if (message.event === "pusher_internal:subscription_succeeded") {
+        logger.success("websocket", `Subscribed to channel: ${message.channel}`);
+        return;
+      }
+      if (message.event === "commit.approved") {
+        const { commit, project } = message.data;
+        logger.info("websocket", `Commit approved: ${commit.id}`);
+        this.commitApprovedHandlers.forEach((handler) => handler(commit, project));
+        return;
+      }
+      if (message.event === "project.updated") {
+        const { project } = message.data;
+        logger.info("websocket", `Project updated: ${project.id}`);
+        this.projectUpdatedHandlers.forEach((handler) => handler(project));
+        return;
+      }
+      if (message.event === "sync.requested") {
+        const { projectId } = message.data;
+        logger.info("websocket", `Sync requested for project: ${projectId}`);
+        return;
+      }
+      logger.debug("websocket", `Unhandled event: ${message.event}`);
+    } catch (error) {
+      logger.error("websocket", "Failed to parse message", error);
+    }
+  }
+  handleDisconnect() {
+    this.ws = null;
+    this.disconnectHandlers.forEach((handler) => handler());
+    if (this.isManualDisconnect) {
+      return;
+    }
+    if (this.reconnectAttempts < this.maxReconnectAttempts) {
+      const delay = this.getReconnectDelay();
+      this.reconnectAttempts++;
+      logger.info("websocket", `Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+      this.reconnectTimer = setTimeout(async () => {
+        try {
+          await this.connect();
+          if (this.userId) {
+            this.subscribeToUserChannel(this.userId);
+          }
+        } catch (error) {
+          logger.error("websocket", "Reconnection failed", error);
+        }
+      }, delay);
+    } else {
+      logger.error("websocket", "Max reconnection attempts reached");
+    }
+  }
+  getReconnectDelay() {
+    const delays = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+    const index = Math.min(this.reconnectAttempts, delays.length - 1);
+    return delays[index];
+  }
+};
+var websocketService = new WebSocketServiceImpl();
+
+// src/daemon/watcher.ts
+import fs from "fs";
+var FileWatcher = class {
+  watchers = /* @__PURE__ */ new Map();
+  DEBOUNCE_DELAY = 3e3;
+  // 3 seconds
+  IGNORE_PATTERNS = [
+    ".git",
+    "node_modules",
+    "dist",
+    "build",
+    ".next",
+    ".cache",
+    ".turbo",
+    ".vscode",
+    ".idea",
+    "coverage",
+    ".nyc_output",
+    "*.log"
+  ];
+  /**
+   * Start watching all linked projects
+   */
+  start() {
+    logger.info("watcher", "Starting file watcher...");
+    const linkedProjects = projectService.getAllLinkedProjects();
+    if (Object.keys(linkedProjects).length === 0) {
+      logger.info("watcher", "No linked projects to watch");
+      return;
+    }
+    for (const [projectPath, linkedProject] of Object.entries(linkedProjects)) {
+      this.watchProject(projectPath, linkedProject.projectId);
+    }
+    logger.success("watcher", `Watching ${this.watchers.size} project(s)`);
+  }
+  /**
+   * Start watching a specific project path
+   */
+  watchProject(projectPath, projectId) {
+    if (this.watchers.has(projectPath)) {
+      logger.debug("watcher", `Already watching ${projectPath}`);
+      return;
+    }
+    try {
+      if (!fs.existsSync(projectPath)) {
+        logger.warn("watcher", `Project path does not exist: ${projectPath}`);
+        return;
+      }
+      const watcher = fs.watch(projectPath, { recursive: true }, (eventType, filename) => {
+        if (!filename) return;
+        const filenameStr = Buffer.isBuffer(filename) ? filename.toString("utf8") : filename;
+        if (this.shouldIgnore(filenameStr)) {
+          return;
+        }
+        logger.debug("watcher", `File change detected: ${filenameStr} (${eventType}) in ${projectPath}`);
+        this.debounceSync(projectPath, projectId);
+      });
+      watcher.on("error", (error) => {
+        logger.error("watcher", `Watcher error for ${projectPath}`, error);
+        const watcherInfo = this.watchers.get(projectPath);
+        if (watcherInfo) {
+          if (watcherInfo.debounceTimer) {
+            clearTimeout(watcherInfo.debounceTimer);
+          }
+          this.watchers.delete(projectPath);
+        }
+      });
+      this.watchers.set(projectPath, {
+        watcher,
+        debounceTimer: null,
+        projectId
+      });
+      logger.info("watcher", `Started watching: ${projectPath} (project: ${projectId})`);
+    } catch (error) {
+      logger.error("watcher", `Failed to watch ${projectPath}`, error);
+    }
+  }
+  /**
+   * Check if a file path should be ignored
+   */
+  shouldIgnore(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const filename = normalizedPath.split("/").pop() || normalizedPath;
+    for (const pattern of this.IGNORE_PATTERNS) {
+      if (pattern.includes("*")) {
+        let escapedPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+        escapedPattern = escapedPattern.replace(/\*/g, ".*");
+        let regexPattern;
+        if (pattern.startsWith("*") && pattern.endsWith("*")) {
+          regexPattern = `^${escapedPattern}$`;
+        } else if (pattern.startsWith("*")) {
+          regexPattern = `^${escapedPattern}$`;
+        } else if (pattern.endsWith("*")) {
+          regexPattern = `^${escapedPattern}$`;
+        } else {
+          regexPattern = `^${escapedPattern}$`;
+        }
+        const regex = new RegExp(regexPattern);
+        if (regex.test(filename)) {
+          return true;
+        }
+      } else {
+        if (normalizedPath.includes(pattern)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Debounce sync operation for a project
+   */
+  debounceSync(projectPath, projectId) {
+    const watcherInfo = this.watchers.get(projectPath);
+    if (!watcherInfo) return;
+    if (watcherInfo.debounceTimer) {
+      clearTimeout(watcherInfo.debounceTimer);
+    }
+    watcherInfo.debounceTimer = setTimeout(async () => {
+      try {
+        await this.performSync(projectPath, projectId);
+      } catch (error) {
+        logger.error("watcher", `Sync failed for ${projectPath}`, error);
+      } finally {
+        watcherInfo.debounceTimer = null;
+      }
+    }, this.DEBOUNCE_DELAY);
+  }
+  /**
+   * Perform sync operation for a project
+   */
+  async performSync(projectPath, projectId) {
+    logger.info("watcher", `Syncing project ${projectId} (${projectPath})`);
+    try {
+      const isRepo = await gitService.isRepo(projectPath);
+      if (!isRepo) {
+        logger.warn("watcher", `Project ${projectPath} is no longer a git repository`);
+        return;
+      }
+      const repoInfo = await gitService.getRepoInfo(projectPath);
+      await apiService.syncProject(projectId, repoInfo);
+      logger.success("watcher", `Synced project ${projectId}`);
+    } catch (error) {
+      logger.error("watcher", `Failed to sync project ${projectId}`, error);
+    }
+  }
+  /**
+   * Stop watching all projects
+   */
+  stop() {
+    logger.info("watcher", "Stopping file watcher...");
+    for (const [projectPath, watcherInfo] of this.watchers.entries()) {
+      try {
+        if (watcherInfo.debounceTimer) {
+          clearTimeout(watcherInfo.debounceTimer);
+        }
+        watcherInfo.watcher.close();
+        logger.debug("watcher", `Stopped watching: ${projectPath}`);
+      } catch (error) {
+        logger.error("watcher", `Error stopping watcher for ${projectPath}`, error);
+      }
+    }
+    this.watchers.clear();
+    logger.success("watcher", "File watcher stopped");
+  }
+  /**
+   * Add a new project to watch (called when a project is linked)
+   */
+  addProject(projectPath, projectId) {
+    this.watchProject(projectPath, projectId);
+  }
+  /**
+   * Remove a project from watching (called when a project is unlinked)
+   */
+  removeProject(projectPath) {
+    const watcherInfo = this.watchers.get(projectPath);
+    if (!watcherInfo) return;
+    try {
+      if (watcherInfo.debounceTimer) {
+        clearTimeout(watcherInfo.debounceTimer);
+      }
+      watcherInfo.watcher.close();
+      this.watchers.delete(projectPath);
+      logger.info("watcher", `Stopped watching: ${projectPath}`);
+    } catch (error) {
+      logger.error("watcher", `Error removing watcher for ${projectPath}`, error);
+    }
+  }
+};
+
+// src/daemon/index.ts
+var heartbeatInterval = null;
+var isShuttingDown = false;
+var fileWatcher = new FileWatcher();
+async function startDaemon() {
+  logger.info("daemon", "Starting daemon...");
+  try {
+    const user = await authService.validateToken();
+    if (!user) {
+      throw new Error('Not authenticated. Please run "stint login" first.');
+    }
+    logger.info("daemon", `Authenticated as ${user.email}`);
+    logger.info("daemon", "Connecting to API...");
+    const session = await apiService.connect();
+    logger.success("daemon", `Agent session connected: ${session.id}`);
+    logger.info("daemon", "Connecting to WebSocket...");
+    await websocketService.connect();
+    logger.success("daemon", "WebSocket connected");
+    websocketService.subscribeToUserChannel(user.id);
+    websocketService.onCommitApproved((commit, project) => {
+      logger.info("daemon", `Commit approved: ${commit.id} for project ${project.name}`);
+      commitQueue.addToQueue(commit, project);
+    });
+    websocketService.onProjectUpdated((project) => {
+      logger.info("daemon", `Project updated: ${project.id} - ${project.name}`);
+    });
+    websocketService.onDisconnect(() => {
+      logger.warn("daemon", "WebSocket disconnected, will attempt to reconnect");
+    });
+    setupSignalHandlers();
+    startHeartbeat();
+    fileWatcher.start();
+    logger.success("daemon", "Daemon started successfully");
+    await new Promise(() => {
+    });
+  } catch (error) {
+    logger.error("daemon", "Failed to start daemon", error);
+    await shutdown();
+    throw error;
+  }
+}
+function startHeartbeat() {
+  const HEARTBEAT_INTERVAL = 3e4;
+  logger.info("daemon", "Starting heartbeat loop (30s interval)");
+  heartbeatInterval = setInterval(async () => {
+    if (isShuttingDown) return;
+    try {
+      await apiService.heartbeat();
+      logger.debug("daemon", "Heartbeat sent successfully");
+    } catch (error) {
+      logger.error("daemon", "Heartbeat failed", error);
+    }
+  }, HEARTBEAT_INTERVAL);
+}
+function stopHeartbeat() {
+  if (heartbeatInterval) {
+    clearInterval(heartbeatInterval);
+    heartbeatInterval = null;
+    logger.info("daemon", "Heartbeat loop stopped");
+  }
+}
+function setupSignalHandlers() {
+  const signals = ["SIGTERM", "SIGINT"];
+  signals.forEach((signal) => {
+    process.on(signal, async () => {
+      logger.info("daemon", `Received ${signal}, shutting down...`);
+      await shutdown();
+      process.exit(0);
+    });
+  });
+  logger.info("daemon", "Signal handlers registered");
+}
+async function shutdown() {
+  if (isShuttingDown) return;
+  isShuttingDown = true;
+  logger.info("daemon", "Shutting down daemon...");
+  stopHeartbeat();
+  try {
+    fileWatcher.stop();
+    logger.info("daemon", "File watcher stopped");
+  } catch (error) {
+    logger.error("daemon", "Failed to stop file watcher", error);
+  }
+  try {
+    websocketService.disconnect();
+    logger.info("daemon", "Disconnected from WebSocket");
+  } catch (error) {
+    logger.error("daemon", "Failed to disconnect from WebSocket", error);
+  }
+  try {
+    await apiService.disconnect();
+    logger.info("daemon", "Disconnected from API");
+  } catch (error) {
+    logger.error("daemon", "Failed to disconnect from API", error);
+  }
+  removePidFile();
+  logger.success("daemon", "Daemon shutdown complete");
+}
+
+// src/daemon/runner.ts
+writePidFile(process.pid);
+startDaemon().catch((error) => {
+  logger.error("daemon-runner", "Daemon crashed", error);
+  process.exit(1);
+});