@gowelle/stint-agent 1.2.20 → 1.2.22

package/dist/chunk-ZNBNEPPK.js

@@ -0,0 +1,648 @@
+import {
+  apiService
+} from "./chunk-KMYPMLEH.js";
+import {
+  gitService,
+  projectService
+} from "./chunk-TQHWJWBZ.js";
+import {
+  authService,
+  config,
+  logger
+} from "./chunk-7H6J2KCA.js";
+
+// src/utils/notify.ts
+import notifier from "node-notifier";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var DEFAULT_ICON = path.resolve(__dirname, "../assets/logo.png");
+function notify(options) {
+  if (!config.areNotificationsEnabled()) {
+    logger.debug("notify", "Notifications disabled, skipping notification");
+    return;
+  }
+  try {
+    notifier.notify({
+      title: options.title,
+      message: options.message,
+      open: options.open,
+      icon: options.icon || DEFAULT_ICON,
+      sound: true,
+      wait: false,
+      appID: "Stint Agent"
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }, (error) => {
+      if (error) {
+        logger.error("notify", "Failed to send notification", error);
+      }
+    });
+  } catch (error) {
+    logger.error("notify", "Failed to send notification", error);
+  }
+}
+
+// src/services/hook.ts
+import { exec } from "child_process";
+var HookService = class {
+  /**
+   * Execute a list of hooks sequentially
+   * @param hooks List of hooks to execute
+   * @param cwd Current working directory (project root)
+   * @returns List of results
+   */
+  async executeHooks(hooks, cwd) {
+    const results = [];
+    const enabledHooks = hooks.filter((h) => h.enabled);
+    if (enabledHooks.length === 0) {
+      return results;
+    }
+    logger.info("hooks", `Running ${enabledHooks.length} pre-commit hooks...`);
+    for (const hook of enabledHooks) {
+      try {
+        const result = await this.executeSingleHook(hook, cwd);
+        results.push(result);
+        if (!result.success && hook.blockOnFailure) {
+          logger.warn("hooks", `Hook "${hook.name}" failed and is blocking. Stopping execution.`);
+          break;
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("hooks", `Unexpected error running hook "${hook.name}"`, error);
+        results.push({
+          hookId: hook.id,
+          hookName: hook.name,
+          success: false,
+          output: "",
+          error: `Internal error: ${errorMessage}`,
+          duration: 0
+        });
+        if (hook.blockOnFailure) {
+          break;
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Execute a single hook with timeout
+   */
+  executeSingleHook(hook, cwd) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      logger.debug("hooks", `Executing hook: ${hook.name} (${hook.command})`);
+      const timeout = hook.timeout || 3e4;
+      exec(hook.command, {
+        cwd,
+        timeout,
+        maxBuffer: 10 * 1024 * 1024
+        // 10MB output buffer
+      }, (error, stdout, stderr) => {
+        const duration = Date.now() - startTime;
+        const combinedOutput = (stdout + "\n" + stderr).trim();
+        if (error) {
+          if (error.signal === "SIGTERM" && duration >= timeout) {
+            resolve({
+              hookId: hook.id,
+              hookName: hook.name,
+              success: false,
+              output: combinedOutput,
+              error: `Timed out after ${timeout}ms`,
+              duration
+            });
+            return;
+          }
+          resolve({
+            hookId: hook.id,
+            hookName: hook.name,
+            success: false,
+            output: combinedOutput,
+            error: error.message,
+            duration
+          });
+        } else {
+          resolve({
+            hookId: hook.id,
+            hookName: hook.name,
+            success: true,
+            output: combinedOutput,
+            duration
+          });
+        }
+      });
+    });
+  }
+};
+var hookService = new HookService();
+
+// src/daemon/queue.ts
+var CommitQueueProcessor = class {
+  queue = [];
+  isProcessing = false;
+  /**
+   * Add commit to processing queue
+   */
+  addToQueue(commit, project) {
+    this.queue.push({ commit, project });
+    logger.info("queue", `Added commit ${commit.id} to queue (position: ${this.queue.length})`);
+    if (!this.isProcessing) {
+      this.processQueue();
+    }
+  }
+  /**
+   * Process commits sequentially
+   */
+  async processQueue() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+    while (this.queue.length > 0) {
+      const item = this.queue.shift();
+      if (!item) break;
+      try {
+        await this.executeCommit(item.commit, item.project);
+      } catch (error) {
+        logger.error("queue", `Failed to execute commit ${item.commit.id}`, error);
+      }
+    }
+    this.isProcessing = false;
+  }
+  /**
+   * Execute a single commit
+   */
+  async executeCommit(commit, project, onProgress, options) {
+    logger.info("queue", `Processing commit: ${commit.id} - ${commit.message}`);
+    try {
+      onProgress?.("Finding project directory...");
+      const projectPath = this.findProjectPath(project.id);
+      if (!projectPath) {
+        throw new Error(`Project ${project.id} is not linked to any local directory`);
+      }
+      logger.info("queue", `Executing in directory: ${projectPath}`);
+      onProgress?.("Validating repository...");
+      const isRepo = await gitService.isRepo(projectPath);
+      if (!isRepo) {
+        throw new Error(`Directory ${projectPath} is not a git repository`);
+      }
+      if (project.commitSettings?.hooks?.length) {
+        onProgress?.("Running pre-commit hooks...");
+        logger.info("queue", "Executing pre-commit hooks...");
+        const hookResults = await hookService.executeHooks(project.commitSettings.hooks, projectPath);
+        const failedBlockingHook = hookResults.find(
+          (r) => !r.success && project.commitSettings?.hooks.find((h) => h.id === r.hookId)?.blockOnFailure
+        );
+        if (failedBlockingHook) {
+          const errorMsg = failedBlockingHook.error || "Unknown error";
+          logger.error("queue", `Blocking hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`);
+          if (failedBlockingHook.output) {
+            logger.warn("queue", `Hook output:
+${failedBlockingHook.output}`);
+          }
+          throw new Error(`Pre-commit hook "${failedBlockingHook.hookName}" failed: ${errorMsg}`);
+        }
+        const failedNonBlockingHooks = hookResults.filter((r) => !r.success);
+        if (failedNonBlockingHooks.length > 0) {
+          logger.warn("queue", `${failedNonBlockingHooks.length} hooks failed but were not blocking: ${failedNonBlockingHooks.map((h) => h.hookName).join(", ")}`);
+        }
+      }
+      onProgress?.("Checking repository status...");
+      let status = await gitService.getStatus(projectPath);
+      if (commit.files && commit.files.length > 0) {
+        onProgress?.(`Staging ${commit.files.length} specified files...`);
+        await gitService.stageFiles(projectPath, commit.files);
+        status = await gitService.getStatus(projectPath);
+        logger.info("queue", `Auto-staged files: ${commit.files.join(", ")}`);
+      } else if (status.staged.length === 0) {
+        const hasChanges = status.unstaged.length > 0 || status.untracked.length > 0;
+        if (hasChanges) {
+          onProgress?.("Staging all changes...");
+          await gitService.stageAll(projectPath);
+          status = await gitService.getStatus(projectPath);
+          logger.info("queue", `Auto-staged all changes`);
+        }
+      }
+      if (status.staged.length === 0) {
+        throw new Error("No changes to commit. The working directory is clean.");
+      }
+      logger.info("queue", `Committing ${status.staged.length} staged files.`);
+      onProgress?.("Creating commit...");
+      logger.info("queue", `Creating commit with message: "${commit.message}"`);
+      const sha = await gitService.commit(projectPath, commit.message);
+      logger.success("queue", `Commit created successfully: ${sha}`);
+      let pushed = false;
+      let pushError;
+      const shouldPush = options?.push !== false;
+      if (shouldPush) {
+        try {
+          onProgress?.("Pushing to remote...");
+          await gitService.push(projectPath);
+          pushed = true;
+          logger.success("queue", `Pushed commit ${sha} to remote`);
+          notify({
+            title: `Commit Pushed - ${project.name}`,
+            message: `Commit "${commit.message}" successfully pushed.`
+          });
+        } catch (error) {
+          pushError = error.message;
+          const isConflict = pushError.includes("rejected") || pushError.includes("non-fast-forward") || pushError.includes("failed to push") || pushError.includes("Updates were rejected");
+          if (isConflict) {
+            logger.warn("queue", `Push failed due to remote conflict: ${pushError}`);
+            notify({
+              title: `Push Conflict - ${project.name}`,
+              message: `Commit "${commit.message}" created but push failed.
+Run "git pull --rebase" to resolve.`
+            });
+          } else {
+            logger.error("queue", `Push failed: ${pushError}`);
+            notify({
+              title: `Push Failed - ${project.name}`,
+              message: `Commit created but push failed: ${pushError}`
+            });
+          }
+        }
+      }
+      onProgress?.("Reporting to server...");
+      await this.reportSuccess(commit.id, sha, pushed, pushError);
+      if (!pushed && !pushError) {
+        notify({
+          title: `Commit Created - ${project.name}`,
+          message: `Commit "${commit.message}" created locally.`
+        });
+      }
+      return sha;
+    } catch (error) {
+      const msg = error.message;
+      logger.error("queue", `Commit execution failed: ${msg}`);
+      notify({
+        title: `Commit Failed - ${project.name}`,
+        message: `Failed to execute commit "${commit.message}": ${msg}`
+      });
+      await this.reportFailure(commit.id, msg);
+      throw error;
+    }
+  }
+  /**
+   * Report successful execution to API
+   * @param commitId - Commit ID
+   * @param sha - Git commit SHA
+   * @param pushed - Whether the commit was pushed to remote
+   * @param pushError - Error message if push failed
+   */
+  async reportSuccess(commitId, sha, pushed = true, pushError) {
+    try {
+      await apiService.markCommitExecuted(commitId, sha, pushed, pushError);
+      const status = pushed ? "executed" : "committed (push failed)";
+      logger.success("queue", `Reported commit ${status} to API: ${commitId} -> ${sha}`);
+    } catch (error) {
+      logger.error("queue", "Failed to report commit success to API", error);
+    }
+  }
+  /**
+   * Report failed execution to API
+   */
+  async reportFailure(commitId, error) {
+    try {
+      await apiService.markCommitFailed(commitId, error);
+      logger.info("queue", `Reported commit failure to API: ${commitId}`);
+    } catch (apiError) {
+      logger.error("queue", "Failed to report commit failure to API", apiError);
+    }
+  }
+  /**
+   * Find local path for a project ID
+   */
+  findProjectPath(projectId) {
+    const allProjects = projectService.getAllLinkedProjects();
+    for (const [path3, linkedProject] of Object.entries(allProjects)) {
+      if (linkedProject.projectId === projectId) {
+        return path3;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if queue is currently processing
+   */
+  isCurrentlyProcessing() {
+    return this.isProcessing;
+  }
+  /**
+   * Get queue length
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+};
+var commitQueue = new CommitQueueProcessor();
+
+// src/services/websocket.ts
+import Echo from "laravel-echo";
+import Pusher from "pusher-js";
+import fs from "fs";
+import os from "os";
+import path2 from "path";
+var STATUS_FILE_PATH = path2.join(os.homedir(), ".config", "stint", "daemon.status.json");
+function writeStatus(update) {
+  try {
+    const dir = path2.dirname(STATUS_FILE_PATH);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    let status = { websocket: { connected: false } };
+    if (fs.existsSync(STATUS_FILE_PATH)) {
+      try {
+        status = JSON.parse(fs.readFileSync(STATUS_FILE_PATH, "utf8"));
+      } catch {
+      }
+    }
+    status.websocket = { ...status.websocket, ...update };
+    fs.writeFileSync(STATUS_FILE_PATH, JSON.stringify(status, null, 2));
+  } catch {
+  }
+}
+var WebSocketServiceImpl = class {
+  echo = null;
+  userId = null;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  reconnectTimer = null;
+  isManualDisconnect = false;
+  // Event handlers
+  commitApprovedHandlers = [];
+  commitPendingHandlers = [];
+  suggestionCreatedHandlers = [];
+  projectUpdatedHandlers = [];
+  disconnectHandlers = [];
+  agentDisconnectedHandlers = [];
+  syncRequestedHandlers = [];
+  /**
+   * Connect to the WebSocket server using Laravel Echo
+   * @throws Error if connection fails or no auth token available
+   */
+  async connect() {
+    try {
+      const token = await authService.getToken();
+      if (!token) {
+        throw new Error("No authentication token available");
+      }
+      const reverbAppKey = config.getReverbAppKey();
+      if (!reverbAppKey) {
+        throw new Error("Reverb app key not configured");
+      }
+      const apiUrl = config.getApiUrl();
+      const environment = config.getEnvironment();
+      let wsHost;
+      let wsPort;
+      let forceTLS;
+      if (environment === "development") {
+        wsHost = "localhost";
+        wsPort = 8080;
+        forceTLS = false;
+      } else {
+        wsHost = "stint.codes";
+        wsPort = 443;
+        forceTLS = true;
+      }
+      logger.info("websocket", `Connecting to ${wsHost}:${wsPort} with key ${reverbAppKey}...`);
+      const pusherClient = new Pusher(reverbAppKey, {
+        wsHost,
+        wsPort,
+        forceTLS,
+        enabledTransports: ["ws", "wss"],
+        disableStats: true,
+        cluster: "",
+        // Required but unused for Reverb
+        authorizer: (channel) => ({
+          authorize: async (socketId, callback) => {
+            try {
+              const response = await fetch(`${apiUrl}/api/broadcasting/auth`, {
+                method: "POST",
+                headers: {
+                  "Authorization": `Bearer ${token}`,
+                  "Accept": "application/json",
+                  "Content-Type": "application/json"
+                },
+                body: JSON.stringify({
+                  socket_id: socketId,
+                  channel_name: channel.name
+                })
+              });
+              if (!response.ok) {
+                const errorText = await response.text();
+                logger.error("websocket", `Auth failed (${response.status}): ${errorText}`);
+                callback(new Error(`Auth failed: ${response.status}`));
+                return;
+              }
+              const data = await response.json();
+              callback(null, data);
+            } catch (error) {
+              logger.error("websocket", "Channel auth error", error);
+              callback(error);
+            }
+          }
+        })
+      });
+      this.echo = new Echo({
+        broadcaster: "reverb",
+        key: reverbAppKey,
+        wsHost,
+        wsPort,
+        forceTLS,
+        disableStats: true,
+        enabledTransports: ["ws", "wss"],
+        authEndpoint: `${apiUrl}/api/broadcasting/auth`,
+        auth: {
+          headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/json"
+          }
+        },
+        client: pusherClient
+      });
+      logger.info("websocket", "Echo instance created, setting up connection handlers...");
+      return new Promise((resolve, reject) => {
+        if (!this.echo) {
+          reject(new Error("Echo not initialized"));
+          return;
+        }
+        const connectionTimeout = setTimeout(() => {
+          const state = this.echo?.connector.pusher.connection.state || "unknown";
+          logger.error("websocket", `Connection timeout after 15s (state: ${state})`);
+          reject(new Error(`Connection timeout - stuck in state: ${state}`));
+        }, 15e3);
+        this.echo.connector.pusher.connection.bind("state_change", (states) => {
+          logger.info("websocket", `Connection state: ${states.previous} -> ${states.current}`);
+        });
+        this.echo.connector.pusher.connection.bind("connected", () => {
+          clearTimeout(connectionTimeout);
+          logger.success("websocket", "\u2705 Connected to Broadcaster via Sanctum");
+          writeStatus({ connected: true });
+          this.reconnectAttempts = 0;
+          this.isManualDisconnect = false;
+          resolve();
+        });
+        this.echo.connector.pusher.connection.bind("error", (error) => {
+          clearTimeout(connectionTimeout);
+          const errorMessage = error instanceof Error ? error.message : JSON.stringify(error) || "Unknown connection error";
+          logger.error("websocket", `WebSocket error: ${errorMessage}`);
+          reject(new Error(errorMessage));
+        });
+        this.echo.connector.pusher.connection.bind("disconnected", () => {
+          logger.warn("websocket", "WebSocket disconnected");
+          writeStatus({ connected: false });
+          this.handleDisconnect();
+        });
+        this.echo.connector.pusher.connection.bind("failed", () => {
+          clearTimeout(connectionTimeout);
+          logger.error("websocket", "WebSocket connection failed");
+          reject(new Error("WebSocket connection failed"));
+        });
+      });
+    } catch (error) {
+      logger.error("websocket", "Failed to connect", error);
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from the WebSocket server
+   * Prevents automatic reconnection
+   */
+  disconnect() {
+    this.isManualDisconnect = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.echo) {
+      if (this.userId) {
+        this.echo.leave(`user.${this.userId}`);
+      }
+      this.echo.disconnect();
+      this.echo = null;
+      logger.info("websocket", "WebSocket disconnected");
+    }
+  }
+  /**
+   * Check if WebSocket is currently connected
+   * @returns True if connected and ready
+   */
+  isConnected() {
+    return this.echo !== null && this.echo.connector.pusher.connection.state === "connected";
+  }
+  /**
+   * Subscribe to user-specific private channel for real-time updates
+   * @param userId - User ID to subscribe to
+   */
+  async subscribeToUserChannel(userId) {
+    this.userId = userId;
+    if (!this.echo) {
+      logger.warn("websocket", "Cannot subscribe: not connected");
+      return;
+    }
+    if (!this.isConnected()) {
+      logger.warn("websocket", "Cannot subscribe: not connected");
+      return;
+    }
+    const channel = `user.${userId}`;
+    logger.info("websocket", `Subscribing to private channel: ${channel}`);
+    const privateChannel = this.echo.private(channel);
+    writeStatus({ channel });
+    privateChannel.listen(".commit.approved", (data) => {
+      logger.info("websocket", `Commit approved: ${data.pendingCommit.id}`);
+      writeStatus({ lastEvent: "commit.approved", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.commitApprovedHandlers.forEach(
+        (handler) => handler(data.pendingCommit, data.pendingCommit.project)
+      );
+    }).listen(".commit.pending", (data) => {
+      logger.info("websocket", `Commit pending: ${data.pendingCommit.id}`);
+      writeStatus({ lastEvent: "commit.pending", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.commitPendingHandlers.forEach((handler) => handler(data.pendingCommit));
+    }).listen(".suggestion.created", (data) => {
+      logger.info("websocket", `Suggestion created: ${data.suggestion.id}`);
+      writeStatus({ lastEvent: "suggestion.created", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.suggestionCreatedHandlers.forEach((handler) => handler(data.suggestion));
+    }).listen(".project.updated", (data) => {
+      logger.info("websocket", `Project updated: ${data.project.id}`);
+      writeStatus({ lastEvent: "project.updated", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.projectUpdatedHandlers.forEach((handler) => handler(data.project));
+    }).listen(".sync.requested", (data) => {
+      logger.info("websocket", `Sync requested for project: ${data.project.id}`);
+      writeStatus({ lastEvent: "sync.requested", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.syncRequestedHandlers.forEach((handler) => handler(data.project.id));
+    }).listen(".agent.disconnected", (data) => {
+      const reason = data.reason ?? "Server requested disconnect";
+      logger.warn("websocket", `Agent disconnected by server: ${reason}`);
+      writeStatus({ lastEvent: "agent.disconnected", lastEventTime: (/* @__PURE__ */ new Date()).toISOString() });
+      this.agentDisconnectedHandlers.forEach((handler) => handler(reason));
+    });
+    logger.success("websocket", `Subscribed to private channel: ${channel}`);
+  }
+  /**
+   * Register handler for commit approved events
+   * @param handler - Callback function
+   */
+  onCommitApproved(handler) {
+    this.commitApprovedHandlers.push(handler);
+  }
+  onCommitPending(handler) {
+    this.commitPendingHandlers.push(handler);
+  }
+  onSuggestionCreated(handler) {
+    this.suggestionCreatedHandlers.push(handler);
+  }
+  onProjectUpdated(handler) {
+    this.projectUpdatedHandlers.push(handler);
+  }
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  onAgentDisconnected(handler) {
+    this.agentDisconnectedHandlers.push(handler);
+  }
+  onSyncRequested(handler) {
+    this.syncRequestedHandlers.push(handler);
+  }
+  handleDisconnect() {
+    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) {
+            await this.subscribeToUserChannel(this.userId);
+          }
+        } catch (error) {
+          logger.error("websocket", "Reconnection failed", error);
+        }
+      }, delay);
+    } else {
+      logger.error("websocket", "Max reconnection attempts reached");
+    }
+  }
+  /**
+   * Get reconnect delay with exponential backoff and jitter
+   * Jitter prevents thundering herd problem when many clients reconnect simultaneously
+   */
+  getReconnectDelay() {
+    const delays = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+    const index = Math.min(this.reconnectAttempts, delays.length - 1);
+    const baseDelay = delays[index];
+    const jitter = baseDelay * (Math.random() * 0.3);
+    return Math.floor(baseDelay + jitter);
+  }
+};
+var websocketService = new WebSocketServiceImpl();
+
+export {
+  notify,
+  commitQueue,
+  websocketService
+};