@gowelle/stint-agent 1.1.0 → 1.2.0

package/dist/chunk-IJUJ6NEL.js

@@ -0,0 +1,369 @@
+import {
+  apiService
+} from "./chunk-W4JGOGR7.js";
+import {
+  gitService,
+  projectService
+} from "./chunk-FBQA4K5J.js";
+import {
+  authService,
+  config,
+  logger
+} from "./chunk-RHMTZK2J.js";
+
+// 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) {
+    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...");
+      const status = await gitService.getStatus(projectPath);
+      const hasStagedChanges = status.staged.length > 0;
+      if (!hasStagedChanges) {
+        throw new Error('No staged changes to commit. Please stage files using "git add" before committing.');
+      }
+      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}`);
+      onProgress?.("Reporting to server...");
+      await this.reportSuccess(commit.id, sha);
+      return sha;
+    } catch (error) {
+      const errorMessage = error.message;
+      logger.error("queue", `Commit execution failed: ${errorMessage}`);
+      await this.reportFailure(commit.id, errorMessage);
+      throw error;
+    }
+  }
+  /**
+   * Report successful execution to API
+   */
+  async reportSuccess(commitId, sha) {
+    try {
+      await apiService.markCommitExecuted(commitId, sha);
+      logger.success("queue", `Reported commit execution 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 [path, linkedProject] of Object.entries(allProjects)) {
+      if (linkedProject.projectId === projectId) {
+        return path;
+      }
+    }
+    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 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();
+
+export {
+  commitQueue,
+  websocketService
+};

package/dist/chunk-RHMTZK2J.js

@@ -0,0 +1,297 @@
+// src/utils/config.ts
+import Conf from "conf";
+import { createHash } from "crypto";
+import os from "os";
+function generateStableMachineId() {
+  const machineInfo = [
+    os.hostname(),
+    os.userInfo().username,
+    os.platform(),
+    os.arch()
+  ].join("-");
+  const hash = createHash("sha256").update(machineInfo).digest("hex");
+  return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`;
+}
+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: generateStableMachineId(),
+        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");
+  }
+  // Normalize path to use forward slashes for consistent storage/lookup
+  normalizePath(p) {
+    return p.replace(/\\/g, "/");
+  }
+  // Project management
+  getProjects() {
+    return this.conf.get("projects") || {};
+  }
+  getProject(path2) {
+    const projects = this.getProjects();
+    const normalizedPath = this.normalizePath(path2);
+    return projects[normalizedPath];
+  }
+  setProject(path2, project) {
+    const projects = this.getProjects();
+    const normalizedPath = this.normalizePath(path2);
+    projects[normalizedPath] = project;
+    this.conf.set("projects", projects);
+  }
+  removeProject(path2) {
+    const projects = this.getProjects();
+    const normalizedPath = this.normalizePath(path2);
+    delete projects[normalizedPath];
+    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/logger.ts
+import fs from "fs";
+import path from "path";
+import os2 from "os";
+var LOG_DIR = path.join(os2.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/utils/crypto.ts
+import crypto from "crypto";
+import os3 from "os";
+function getMachineKey() {
+  const machineInfo = `${os3.hostname()}-${os3.platform()}-${os3.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/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 } = await import("./api-HLTR2LTF.js");
+      const user = await apiService.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();
+
+export {
+  config,
+  logger,
+  authService
+};