@gowelle/stint-agent 1.0.8 → 1.2.0

package/dist/chunk-W4JGOGR7.js

@@ -0,0 +1,384 @@
+import {
+  authService,
+  config,
+  logger
+} from "./chunk-RHMTZK2J.js";
+
+// src/utils/circuit-breaker.ts
+var CircuitBreaker = class {
+  constructor(options) {
+    this.options = options;
+    this.options.windowSize = options.windowSize || 6e4;
+  }
+  state = "CLOSED";
+  failures = 0;
+  successes = 0;
+  lastFailureTime = 0;
+  openedAt = 0;
+  failureTimestamps = [];
+  /**
+   * Execute an operation through the circuit breaker
+   */
+  async execute(operation, fallback) {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.openedAt >= this.options.timeout) {
+        this.state = "HALF_OPEN";
+        this.successes = 0;
+      } else {
+        if (fallback) {
+          return fallback();
+        }
+        throw new Error("Circuit breaker is OPEN - service unavailable");
+      }
+    }
+    try {
+      const result = await operation();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+  /**
+   * Handle successful operation
+   */
+  onSuccess() {
+    this.failures = 0;
+    if (this.state === "HALF_OPEN") {
+      this.successes++;
+      if (this.successes >= this.options.successThreshold) {
+        this.state = "CLOSED";
+        this.successes = 0;
+        this.failureTimestamps = [];
+      }
+    }
+  }
+  /**
+   * Handle failed operation
+   */
+  onFailure() {
+    this.lastFailureTime = Date.now();
+    this.failureTimestamps.push(this.lastFailureTime);
+    const windowStart = this.lastFailureTime - this.options.windowSize;
+    this.failureTimestamps = this.failureTimestamps.filter((ts) => ts > windowStart);
+    this.failures = this.failureTimestamps.length;
+    if (this.state === "HALF_OPEN") {
+      this.state = "OPEN";
+      this.openedAt = Date.now();
+      this.successes = 0;
+    } else if (this.state === "CLOSED") {
+      if (this.failures >= this.options.failureThreshold) {
+        this.state = "OPEN";
+        this.openedAt = Date.now();
+      }
+    }
+  }
+  /**
+   * Get current state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get failure count in current window
+   */
+  getFailureCount() {
+    return this.failures;
+  }
+  /**
+   * Reset the circuit breaker to CLOSED state
+   */
+  reset() {
+    this.state = "CLOSED";
+    this.failures = 0;
+    this.successes = 0;
+    this.failureTimestamps = [];
+  }
+};
+
+// src/services/api.ts
+var AGENT_VERSION = "1.2.0";
+var ApiServiceImpl = class {
+  sessionId = null;
+  circuitBreaker = new CircuitBreaker({
+    failureThreshold: 5,
+    successThreshold: 2,
+    timeout: 3e4,
+    // 30s before trying half-open
+    windowSize: 6e4
+    // 60s failure window
+  });
+  /**
+   * Get authentication headers for API requests
+   * @returns Headers object with Authorization and Content-Type
+   * @throws Error if no authentication token is found
+   */
+  async getHeaders() {
+    const token = await authService.getToken();
+    if (!token) {
+      throw new Error('No authentication token found. Please run "stint login" first.');
+    }
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Make an HTTP request to the API with circuit breaker protection
+   * @param endpoint - API endpoint path (e.g., '/api/user')
+   * @param options - Fetch options (method, body, headers, etc.)
+   * @returns Parsed JSON response
+   * @throws Error if request fails or circuit breaker is open
+   */
+  async request(endpoint, options = {}) {
+    const url = `${config.getApiUrl()}${endpoint}`;
+    const headers = await this.getHeaders();
+    return this.circuitBreaker.execute(async () => {
+      try {
+        const response = await fetch(url, {
+          ...options,
+          headers: {
+            ...headers,
+            ...options.headers
+          }
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          throw new Error(`API request failed: ${response.status} ${errorText}`);
+        }
+        return await response.json();
+      } catch (error) {
+        logger.error("api", `Request to ${endpoint} failed`, error);
+        throw error;
+      }
+    });
+  }
+  /**
+   * Retry wrapper with exponential backoff
+   * @param operation - Async operation to retry
+   * @param operationName - Name for logging
+   * @param maxRetries - Maximum number of retry attempts (default: 3)
+   * @returns Result of the operation
+   * @throws Last error if all retries fail
+   */
+  async withRetry(operation, operationName, maxRetries = 3) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+        if (lastError.message.includes("401") || lastError.message.includes("403")) {
+          throw lastError;
+        }
+        if (attempt < maxRetries) {
+          const delay = Math.min(1e3 * Math.pow(2, attempt - 1), 5e3);
+          logger.warn("api", `${operationName} failed, retrying in ${delay}ms (attempt ${attempt}/${maxRetries})`);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          logger.error("api", `${operationName} failed after ${maxRetries} attempts`);
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Connect agent session to the API
+   * @returns Agent session data including session ID
+   * @throws Error if connection fails
+   */
+  async connect() {
+    logger.info("api", "Connecting agent session...");
+    const os = `${process.platform}-${process.arch}`;
+    return this.withRetry(async () => {
+      const response = await this.request("/api/agent/connect", {
+        method: "POST",
+        body: JSON.stringify({
+          machine_id: authService.getMachineId(),
+          machine_name: authService.getMachineName(),
+          os,
+          agent_version: AGENT_VERSION
+        })
+      });
+      const session = response.data;
+      this.sessionId = session.id;
+      logger.success("api", `Agent session connected: ${session.id}`);
+      return session;
+    }, "Connect");
+  }
+  /**
+   * Disconnect agent session from the API
+   * @param reason - Optional reason for disconnection
+   */
+  async disconnect(reason) {
+    if (!this.sessionId) {
+      return;
+    }
+    logger.info("api", "Disconnecting agent session...");
+    await this.request("/api/agent/disconnect", {
+      method: "POST",
+      body: JSON.stringify({
+        session_id: this.sessionId,
+        reason: reason || "Agent disconnected"
+      })
+    });
+    this.sessionId = null;
+    logger.success("api", "Agent session disconnected");
+  }
+  /**
+   * Send heartbeat to keep session alive
+   * @throws Error if no active session
+   */
+  async heartbeat() {
+    if (!this.sessionId) {
+      throw new Error("No active session");
+    }
+    await this.withRetry(async () => {
+      await this.request("/api/agent/heartbeat", {
+        method: "POST",
+        body: JSON.stringify({
+          session_id: this.sessionId
+        })
+      });
+      logger.debug("api", "Heartbeat sent");
+    }, "Heartbeat");
+  }
+  /**
+   * Get pending commits for a project
+   * @param projectId - Project ID
+   * @returns Array of pending commits
+   */
+  async getPendingCommits(projectId) {
+    logger.info("api", `Fetching pending commits for project ${projectId}`);
+    const response = await this.request(
+      `/api/agent/pending-commits?project_id=${projectId}`
+    );
+    const commits = response.data.map((item) => {
+      const projectId2 = item.project_id || item.projectId;
+      const createdAt = item.created_at || item.createdAt;
+      if (!projectId2 || !createdAt) {
+        throw new Error(`Invalid commit data received from API: ${JSON.stringify(item)}`);
+      }
+      return {
+        id: item.id,
+        projectId: projectId2,
+        message: item.message,
+        files: item.files,
+        createdAt
+      };
+    });
+    logger.info("api", `Found ${commits.length} pending commits`);
+    return commits;
+  }
+  /**
+   * Mark a commit as successfully executed
+   * @param commitId - Commit ID
+   * @param sha - Git commit SHA
+   * @returns Updated commit data
+   */
+  async markCommitExecuted(commitId, sha) {
+    logger.info("api", `Marking commit ${commitId} as executed (SHA: ${sha})`);
+    return this.withRetry(async () => {
+      const response = await this.request(
+        `/api/agent/commits/${commitId}/executed`,
+        {
+          method: "POST",
+          body: JSON.stringify({ sha })
+        }
+      );
+      const data = response.data;
+      const projectId = data.project_id || data.projectId;
+      const createdAt = data.created_at || data.createdAt;
+      const executedAt = data.executed_at || data.executedAt;
+      if (!projectId || !createdAt) {
+        throw new Error(`Invalid commit data received from API: ${JSON.stringify(data)}`);
+      }
+      const commit = {
+        id: data.id,
+        projectId,
+        message: data.message,
+        sha: data.sha,
+        status: data.status,
+        createdAt,
+        executedAt,
+        error: data.error
+      };
+      logger.success("api", `Commit ${commitId} marked as executed`);
+      return commit;
+    }, "Mark commit executed");
+  }
+  /**
+   * Mark a commit as failed
+   * @param commitId - Commit ID
+   * @param error - Error message
+   */
+  async markCommitFailed(commitId, error) {
+    logger.error("api", `Marking commit ${commitId} as failed: ${error}`);
+    await this.withRetry(async () => {
+      await this.request(`/api/agent/commits/${commitId}/failed`, {
+        method: "POST",
+        body: JSON.stringify({ error })
+      });
+    }, "Mark commit failed");
+  }
+  /**
+   * Sync project repository information with the API
+   * @param projectId - Project ID
+   * @param data - Repository information (path, remote URL, branches)
+   */
+  async syncProject(projectId, data) {
+    logger.info("api", `Syncing project ${projectId}`);
+    await this.withRetry(async () => {
+      const payload = {
+        repo_path: data.repoPath,
+        remote_url: data.remoteUrl,
+        default_branch: data.defaultBranch,
+        current_branch: data.currentBranch
+      };
+      await this.request(`/api/agent/projects/${projectId}/sync`, {
+        method: "POST",
+        body: JSON.stringify(payload)
+      });
+      logger.success("api", `Project ${projectId} synced`);
+    }, "Sync project");
+  }
+  /**
+   * Test API connectivity
+   */
+  async ping() {
+    try {
+      await this.request("/api/agent/ping");
+    } catch (error) {
+      throw new Error(`Failed to connect to API: ${error.message}`);
+    }
+  }
+  async getLinkedProjects() {
+    logger.info("api", "Fetching linked projects");
+    const response = await this.request("/api/agent/projects");
+    const projects = response.data;
+    logger.info("api", `Found ${projects.length} linked projects`);
+    return projects;
+  }
+  async getCurrentUser() {
+    logger.info("api", "Fetching current user");
+    const user = await this.request("/api/user");
+    logger.info("api", `Fetched user: ${user.email}`);
+    return user;
+  }
+  async createProject(data) {
+    logger.info("api", `Creating project: ${data.name}`);
+    const response = await this.request("/api/agent/projects", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    const project = response.data;
+    logger.success("api", `Created project: ${project.name} (${project.id})`);
+    return project;
+  }
+};
+var apiService = new ApiServiceImpl();
+
+export {
+  apiService
+};

package/dist/daemon/runner.js

@@ -1,227 +1,25 @@
 #!/usr/bin/env node
 import {
   commitQueue,
+  websocketService
+} from "../chunk-IJUJ6NEL.js";
+import {
+  apiService
+} from "../chunk-W4JGOGR7.js";
+import {
   gitService,
   projectService,
   removePidFile,
   writePidFile
-} from "../chunk-56UZEICO.js";
+} from "../chunk-FBQA4K5J.js";
 import {
-  apiService,
   authService,
-  config,
   logger
-} from "../chunk-5OKRSNU4.js";
+} from "../chunk-RHMTZK2J.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 = [];
-  commitPendingHandlers = [];
-  suggestionCreatedHandlers = [];
-  projectUpdatedHandlers = [];
-  disconnectHandlers = [];
-  agentDisconnectedHandlers = [];
-  syncRequestedHandlers = [];
-  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);
-  }
-  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);
-  }
-  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 === "commit.pending") {
-        const { pendingCommit } = message.data;
-        logger.info("websocket", `Commit pending: ${pendingCommit.id}`);
-        this.commitPendingHandlers.forEach((handler) => handler(pendingCommit));
-        return;
-      }
-      if (message.event === "suggestion.created") {
-        const { suggestion } = message.data;
-        logger.info("websocket", `Suggestion created: ${suggestion.id}`);
-        this.suggestionCreatedHandlers.forEach((handler) => handler(suggestion));
-        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}`);
-        this.syncRequestedHandlers.forEach((handler) => handler(projectId));
-        return;
-      }
-      if (message.event === "agent.disconnected") {
-        const reason = message.data?.reason || "Server requested disconnect";
-        logger.warn("websocket", `Agent disconnected by server: ${reason}`);
-        this.agentDisconnectedHandlers.forEach((handler) => handler(reason));
-        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 {