@gowelle/stint-agent 1.1.0 → 1.2.0

package/dist/{chunk-IAERVP6F.js → chunk-W4JGOGR7.js}

@@ -1,277 +1,8 @@
-// src/utils/config.ts
-import Conf from "conf";
-import { randomUUID } from "crypto";
-import os from "os";
-var DEFAULT_CONFIG = {
-  apiUrl: "https://stint.codes",
-  wsUrl: "wss://stint.codes/reverb",
-  reverbAppKey: "wtn6tu6lirfv6yflujk7",
-  projects: {}
-};
-var ConfigManager = class {
-  conf;
-  constructor() {
-    this.conf = new Conf({
-      projectName: "stint",
-      defaults: {
-        ...DEFAULT_CONFIG,
-        machineId: randomUUID(),
-        machineName: os.hostname()
-      }
-    });
-  }
-  get(key) {
-    return this.conf.get(key);
-  }
-  set(key, value) {
-    this.conf.set(key, value);
-  }
-  getAll() {
-    return this.conf.store;
-  }
-  clear() {
-    this.conf.clear();
-  }
-  // Token management
-  getToken() {
-    return this.conf.get("token");
-  }
-  setToken(token) {
-    this.conf.set("token", token);
-  }
-  clearToken() {
-    this.conf.delete("token");
-  }
-  // Machine info
-  getMachineId() {
-    return this.conf.get("machineId");
-  }
-  getMachineName() {
-    return this.conf.get("machineName");
-  }
-  // Project management
-  getProjects() {
-    return this.conf.get("projects") || {};
-  }
-  getProject(path2) {
-    const projects = this.getProjects();
-    return projects[path2];
-  }
-  setProject(path2, project) {
-    const projects = this.getProjects();
-    projects[path2] = project;
-    this.conf.set("projects", projects);
-  }
-  removeProject(path2) {
-    const projects = this.getProjects();
-    delete projects[path2];
-    this.conf.set("projects", projects);
-  }
-  // API URLs
-  getApiUrl() {
-    return this.conf.get("apiUrl");
-  }
-  getWsUrl() {
-    const environment = this.getEnvironment();
-    const reverbAppKey = this.getReverbAppKey();
-    let baseUrl;
-    if (environment === "development") {
-      baseUrl = "ws://localhost:8080";
-    } else {
-      baseUrl = this.conf.get("wsUrl") || "wss://stint.codes/reverb";
-    }
-    if (reverbAppKey && reverbAppKey.trim() !== "") {
-      const cleanBaseUrl2 = baseUrl.replace(/\/$/, "");
-      const baseWithoutReverb = cleanBaseUrl2.replace(/\/reverb$/, "");
-      return `${baseWithoutReverb}/app/${reverbAppKey}`;
-    }
-    const cleanBaseUrl = baseUrl.replace(/\/$/, "");
-    if (!cleanBaseUrl.includes("/reverb")) {
-      return `${cleanBaseUrl}/reverb`;
-    }
-    return cleanBaseUrl;
-  }
-  // Environment management
-  getEnvironment() {
-    const configEnv = this.conf.get("environment");
-    if (configEnv === "development" || configEnv === "production") {
-      return configEnv;
-    }
-    const nodeEnv = process.env.NODE_ENV;
-    if (nodeEnv === "development" || nodeEnv === "dev") {
-      return "development";
-    }
-    return "production";
-  }
-  setEnvironment(environment) {
-    this.conf.set("environment", environment);
-  }
-  // Reverb App Key management
-  getReverbAppKey() {
-    return process.env.REVERB_APP_KEY || process.env.STINT_REVERB_APP_KEY || this.conf.get("reverbAppKey");
-  }
-  setReverbAppKey(reverbAppKey) {
-    this.conf.set("reverbAppKey", reverbAppKey);
-  }
-};
-var config = new ConfigManager();
-
-// src/utils/crypto.ts
-import crypto from "crypto";
-import os2 from "os";
-function getMachineKey() {
-  const machineInfo = `${os2.hostname()}-${os2.platform()}-${os2.arch()}`;
-  return crypto.createHash("sha256").update(machineInfo).digest();
-}
-var ALGORITHM = "aes-256-gcm";
-var IV_LENGTH = 16;
-var AUTH_TAG_LENGTH = 16;
-function encrypt(text) {
-  const key = getMachineKey();
-  const iv = crypto.randomBytes(IV_LENGTH);
-  const cipher = crypto.createCipheriv(ALGORITHM, key, iv);
-  let encrypted = cipher.update(text, "utf8", "hex");
-  encrypted += cipher.final("hex");
-  const authTag = cipher.getAuthTag();
-  return iv.toString("hex") + authTag.toString("hex") + encrypted;
-}
-function decrypt(encryptedText) {
-  const key = getMachineKey();
-  const iv = Buffer.from(encryptedText.slice(0, IV_LENGTH * 2), "hex");
-  const authTag = Buffer.from(
-    encryptedText.slice(IV_LENGTH * 2, (IV_LENGTH + AUTH_TAG_LENGTH) * 2),
-    "hex"
-  );
-  const encrypted = encryptedText.slice((IV_LENGTH + AUTH_TAG_LENGTH) * 2);
-  const decipher = crypto.createDecipheriv(ALGORITHM, key, iv);
-  decipher.setAuthTag(authTag);
-  let decrypted = decipher.update(encrypted, "hex", "utf8");
-  decrypted += decipher.final("utf8");
-  return decrypted;
-}
-
-// src/utils/logger.ts
-import fs from "fs";
-import path from "path";
-import os3 from "os";
-var LOG_DIR = path.join(os3.homedir(), ".config", "stint", "logs");
-var AGENT_LOG = path.join(LOG_DIR, "agent.log");
-var ERROR_LOG = path.join(LOG_DIR, "error.log");
-var MAX_LOG_SIZE = 10 * 1024 * 1024;
-var MAX_LOG_FILES = 7;
-var Logger = class {
-  ensureLogDir() {
-    if (!fs.existsSync(LOG_DIR)) {
-      fs.mkdirSync(LOG_DIR, { recursive: true });
-    }
-  }
-  rotateLog(logFile) {
-    if (!fs.existsSync(logFile)) return;
-    const stats = fs.statSync(logFile);
-    if (stats.size < MAX_LOG_SIZE) return;
-    for (let i = MAX_LOG_FILES - 1; i > 0; i--) {
-      const oldFile = `${logFile}.${i}`;
-      const newFile = `${logFile}.${i + 1}`;
-      if (fs.existsSync(oldFile)) {
-        if (i === MAX_LOG_FILES - 1) {
-          fs.unlinkSync(oldFile);
-        } else {
-          fs.renameSync(oldFile, newFile);
-        }
-      }
-    }
-    fs.renameSync(logFile, `${logFile}.1`);
-  }
-  writeLog(level, category, message, logFile) {
-    this.ensureLogDir();
-    this.rotateLog(logFile);
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const logLine = `[${timestamp}] ${level.padEnd(5)} [${category}] ${message}
-`;
-    fs.appendFileSync(logFile, logLine);
-  }
-  info(category, message) {
-    this.writeLog("INFO", category, message, AGENT_LOG);
-    console.log(`\u2139 [${category}] ${message}`);
-  }
-  warn(category, message) {
-    this.writeLog("WARN", category, message, AGENT_LOG);
-    console.warn(`\u26A0 [${category}] ${message}`);
-  }
-  error(category, message, error) {
-    const fullMessage = error ? `${message}: ${error.message}` : message;
-    this.writeLog("ERROR", category, fullMessage, ERROR_LOG);
-    this.writeLog("ERROR", category, fullMessage, AGENT_LOG);
-    console.error(`\u2716 [${category}] ${fullMessage}`);
-    if (error?.stack) {
-      this.writeLog("ERROR", category, error.stack, ERROR_LOG);
-    }
-  }
-  debug(category, message) {
-    if (process.env.DEBUG) {
-      this.writeLog("DEBUG", category, message, AGENT_LOG);
-      console.debug(`\u{1F41B} [${category}] ${message}`);
-    }
-  }
-  success(category, message) {
-    this.writeLog("INFO", category, message, AGENT_LOG);
-    console.log(`\u2713 [${category}] ${message}`);
-  }
-};
-var logger = new Logger();
-
-// src/services/auth.ts
-var AuthServiceImpl = class {
-  async saveToken(token) {
-    try {
-      const encryptedToken = encrypt(token);
-      config.setToken(encryptedToken);
-      logger.info("auth", "Token saved successfully");
-    } catch (error) {
-      logger.error("auth", "Failed to save token", error);
-      throw error;
-    }
-  }
-  async getToken() {
-    try {
-      const encryptedToken = config.getToken();
-      if (!encryptedToken) {
-        return null;
-      }
-      return decrypt(encryptedToken);
-    } catch (error) {
-      logger.error("auth", "Failed to decrypt token", error);
-      return null;
-    }
-  }
-  async clearToken() {
-    config.clearToken();
-    logger.info("auth", "Token cleared");
-  }
-  async validateToken() {
-    const token = await this.getToken();
-    if (!token) {
-      return null;
-    }
-    try {
-      const { apiService: apiService2 } = await import("./api-YI2HWZGL.js");
-      const user = await apiService2.getCurrentUser();
-      logger.info("auth", `Token validated for user: ${user.email}`);
-      return user;
-    } catch (error) {
-      logger.warn("auth", "Token validation failed");
-      logger.error("auth", "Failed to validate token", error);
-      return null;
-    }
-  }
-  getMachineId() {
-    return config.getMachineId();
-  }
-  getMachineName() {
-    return config.getMachineName();
-  }
-};
-var authService = new AuthServiceImpl();
+import {
+  authService,
+  config,
+  logger
+} from "./chunk-RHMTZK2J.js";
 
 // src/utils/circuit-breaker.ts
 var CircuitBreaker = class {
@@ -367,7 +98,7 @@ var CircuitBreaker = class {
 };
 
 // src/services/api.ts
-var AGENT_VERSION = "1.1.0";
+var AGENT_VERSION = "1.2.0";
 var ApiServiceImpl = class {
   sessionId = null;
   circuitBreaker = new CircuitBreaker({
@@ -459,14 +190,14 @@ var ApiServiceImpl = class {
    */
   async connect() {
     logger.info("api", "Connecting agent session...");
-    const os4 = `${process.platform}-${process.arch}`;
+    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: os4,
+          os,
           agent_version: AGENT_VERSION
         })
       });
@@ -523,13 +254,20 @@ var ApiServiceImpl = class {
     const response = await this.request(
       `/api/agent/pending-commits?project_id=${projectId}`
     );
-    const commits = response.data.map((item) => ({
-      id: item.id,
-      projectId: item.project_id || item.projectId,
-      message: item.message,
-      files: item.files,
-      createdAt: item.created_at || item.createdAt
-    }));
+    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;
   }
@@ -550,14 +288,20 @@ var ApiServiceImpl = class {
         }
       );
       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: data.project_id || data.projectId,
+        projectId,
         message: data.message,
         sha: data.sha,
         status: data.status,
-        createdAt: data.created_at || data.createdAt,
-        executedAt: data.executed_at || data.executedAt,
+        createdAt,
+        executedAt,
         error: data.error
       };
       logger.success("api", `Commit ${commitId} marked as executed`);
@@ -599,6 +343,16 @@ var ApiServiceImpl = class {
       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");
@@ -626,8 +380,5 @@ var ApiServiceImpl = class {
 var apiService = new ApiServiceImpl();
 
 export {
-  config,
-  logger,
-  apiService,
-  authService
+  apiService
 };

package/dist/daemon/runner.js

@@ -1,253 +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-OHOFKJL7.js";
+} from "../chunk-FBQA4K5J.js";
 import {
-  apiService,
   authService,
-  config,
   logger
-} from "../chunk-IAERVP6F.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 = [];
-  /**
-   * Connect to the WebSocket server
-   * @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 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 from the WebSocket server
-   * Prevents automatic reconnection
-   */
-  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");
-    }
-  }
-  /**
-   * Check if WebSocket is currently connected
-   * @returns True if connected and ready
-   */
-  isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-  }
-  /**
-   * Subscribe to user-specific channel for real-time updates
-   * @param userId - User ID to subscribe to
-   */
-  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
-      }
-    });
-  }
-  /**
-   * 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);
-  }
-  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");
-    }
-  }
-  /**
-   * 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();
-
 // src/daemon/watcher.ts
 import fs from "fs";
 var FileWatcher = class {