@gowelle/stint-agent 1.2.18 → 1.2.19

package/dist/chunk-SXPP272L.js

@@ -1,534 +0,0 @@
-import {
-  apiService
-} from "./chunk-XPZNWXB4.js";
-import {
-  gitService,
-  projectService
-} from "./chunk-A2CVSQ3K.js";
-import {
-  authService,
-  config,
-  logger
-} from "./chunk-WETVBZ6Z.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/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`);
-      }
-      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
-};