@gowelle/stint-agent 1.2.16 → 1.2.18

package/dist/{StatusDashboard-LCGOELR4.js → StatusDashboard-KCHNLVD7.js}

@@ -2,11 +2,10 @@ import {
   gitService,
   projectService,
   validatePidFile
-} from "./chunk-QQP6IASS.js";
+} from "./chunk-A2CVSQ3K.js";
 import {
   authService
-} from "./chunk-7TIF7QZL.js";
-import "./chunk-XHXSWLUC.js";
+} from "./chunk-WETVBZ6Z.js";
 
 // src/components/StatusDashboard.tsx
 import { useState, useEffect } from "react";

package/dist/api-6EGHLTCT.js

@@ -0,0 +1,7 @@
+import {
+  apiService
+} from "./chunk-XPZNWXB4.js";
+import "./chunk-WETVBZ6Z.js";
+export {
+  apiService
+};

package/dist/{chunk-QQP6IASS.js → chunk-A2CVSQ3K.js}

@@ -1,7 +1,7 @@
 import {
   config,
   logger
-} from "./chunk-XHXSWLUC.js";
+} from "./chunk-WETVBZ6Z.js";
 
 // src/services/git.ts
 import simpleGit from "simple-git";

package/dist/{chunk-Z44NPHXG.js → chunk-SXPP272L.js}

@@ -1,20 +1,47 @@
 import {
   apiService
-} from "./chunk-I6DTKIFX.js";
+} from "./chunk-XPZNWXB4.js";
 import {
   gitService,
   projectService
-} from "./chunk-QQP6IASS.js";
-import {
-  authService
-} from "./chunk-7TIF7QZL.js";
-import {
-  notify
-} from "./chunk-DCY3EXDX.js";
+} from "./chunk-A2CVSQ3K.js";
 import {
+  authService,
   config,
   logger
-} from "./chunk-XHXSWLUC.js";
+} 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 {
@@ -100,7 +127,7 @@ var CommitQueueProcessor = class {
           pushed = true;
           logger.success("queue", `Pushed commit ${sha} to remote`);
           notify({
-            title: "Commit Executed & Pushed",
+            title: `Commit Pushed - ${project.name}`,
             message: `Commit "${commit.message}" successfully pushed.`
           });
         } catch (error) {
@@ -109,14 +136,14 @@ var CommitQueueProcessor = class {
           if (isConflict) {
             logger.warn("queue", `Push failed due to remote conflict: ${pushError}`);
             notify({
-              title: "\u26A0\uFE0F Push Failed - Manual Action Required",
+              title: `Push Conflict - ${project.name}`,
               message: `Commit "${commit.message}" created but push failed.
-Run "git pull --rebase && git push" to resolve.`
+Run "git pull --rebase" to resolve.`
             });
           } else {
             logger.error("queue", `Push failed: ${pushError}`);
             notify({
-              title: "\u274C Push Failed",
+              title: `Push Failed - ${project.name}`,
               message: `Commit created but push failed: ${pushError}`
             });
           }
@@ -126,16 +153,16 @@ Run "git pull --rebase && git push" to resolve.`
       await this.reportSuccess(commit.id, sha, pushed, pushError);
       if (!pushed && !pushError) {
         notify({
-          title: "Commit Executed",
+          title: `Commit Created - ${project.name}`,
           message: `Commit "${commit.message}" created locally.`
         });
       }
       return sha;
     } catch (error) {
-      msg = error.message;
+      const msg = error.message;
       logger.error("queue", `Commit execution failed: ${msg}`);
       notify({
-        title: "Commit Failed",
+        title: `Commit Failed - ${project.name}`,
         message: `Failed to execute commit "${commit.message}": ${msg}`
       });
       await this.reportFailure(commit.id, msg);
@@ -174,9 +201,9 @@ Run "git pull --rebase && git push" to resolve.`
    */
   findProjectPath(projectId) {
     const allProjects = projectService.getAllLinkedProjects();
-    for (const [path, linkedProject] of Object.entries(allProjects)) {
+    for (const [path3, linkedProject] of Object.entries(allProjects)) {
       if (linkedProject.projectId === projectId) {
-        return path;
+        return path3;
       }
     }
     return null;
@@ -197,11 +224,33 @@ Run "git pull --rebase && git push" to resolve.`
 var commitQueue = new CommitQueueProcessor();
 
 // src/services/websocket.ts
-import WebSocket from "ws";
+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 {
-  ws = null;
+  echo = null;
   userId = null;
-  socketId = null;
   reconnectAttempts = 0;
   maxReconnectAttempts = 10;
   reconnectTimer = null;
@@ -215,7 +264,7 @@ var WebSocketServiceImpl = class {
   agentDisconnectedHandlers = [];
   syncRequestedHandlers = [];
   /**
-   * Connect to the WebSocket server
+   * Connect to the WebSocket server using Laravel Echo
    * @throws Error if connection fails or no auth token available
    */
   async connect() {
@@ -224,31 +273,117 @@ var WebSocketServiceImpl = class {
       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);
+      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.ws) {
-          reject(new Error("WebSocket not initialized"));
+        if (!this.echo) {
+          reject(new Error("Echo not initialized"));
           return;
         }
-        this.ws.on("open", () => {
-          logger.success("websocket", "WebSocket connected");
+        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.ws.on("message", (data) => {
-          this.handleMessage(data);
+        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.ws.on("close", () => {
+        this.echo.connector.pusher.connection.bind("disconnected", () => {
           logger.warn("websocket", "WebSocket disconnected");
+          writeStatus({ connected: false });
           this.handleDisconnect();
         });
-        this.ws.on("error", (error) => {
-          logger.error("websocket", "WebSocket error", error);
-          reject(error);
+        this.echo.connector.pusher.connection.bind("failed", () => {
+          clearTimeout(connectionTimeout);
+          logger.error("websocket", "WebSocket connection failed");
+          reject(new Error("WebSocket connection failed"));
         });
       });
     } catch (error) {
@@ -266,17 +401,12 @@ var WebSocketServiceImpl = class {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
     }
-    if (this.ws) {
+    if (this.echo) {
       if (this.userId) {
-        this.sendMessage({
-          event: "pusher:unsubscribe",
-          data: {
-            channel: `private-user.${this.userId}`
-          }
-        });
+        this.echo.leave(`user.${this.userId}`);
       }
-      this.ws.close();
-      this.ws = null;
+      this.echo.disconnect();
+      this.echo = null;
       logger.info("websocket", "WebSocket disconnected");
     }
   }
@@ -285,38 +415,55 @@ var WebSocketServiceImpl = class {
    * @returns True if connected and ready
    */
   isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+    return this.echo !== null && this.echo.connector.pusher.connection.state === "connected";
   }
   /**
-   * Subscribe to user-specific channel for real-time updates
+   * 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.userId) {
-      const channel = `user.${this.userId}`;
-      logger.info("websocket", `Subscribing to channel: ${channel}`);
-      this.sendMessage({
-        event: "pusher:subscribe",
-        data: {
-          channel
-        }
-      });
+    if (!this.echo) {
+      logger.warn("websocket", "Cannot subscribe: not connected");
+      return;
     }
-  }
-  /**
-   * Get authentication signature for private channel from Laravel backend
-   */
-  async getChannelAuth(channel, socketId) {
-    const { apiService: apiService2 } = await import("./api-IB5F32WJ.js");
-    const response = await apiService2.request("/api/broadcasting/auth", {
-      method: "POST",
-      body: JSON.stringify({
-        socket_id: socketId,
-        channel_name: channel
-      })
+    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));
     });
-    return response.auth;
+    logger.success("websocket", `Subscribed to private channel: ${channel}`);
   }
   /**
    * Register handler for commit approved events
@@ -343,98 +490,7 @@ var WebSocketServiceImpl = class {
   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));
-  }
-  async handleMessage(data) {
-    try {
-      const message = JSON.parse(data.toString());
-      logger.info("websocket", `Received message: ${message.event}`);
-      if (message.event === "pusher:connection_established") {
-        try {
-          const connectionData = typeof message.data === "string" ? JSON.parse(message.data) : message.data;
-          this.socketId = connectionData.socket_id;
-          logger.success("websocket", `Connection established (socket_id: ${this.socketId})`);
-          if (this.userId) {
-            this.subscribeToUserChannel(this.userId);
-          }
-        } catch (error) {
-          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 === "pusher:error") {
-        try {
-          const errorData = typeof message.data === "string" ? JSON.parse(message.data) : message.data;
-          const errorCode = errorData.code;
-          const errorMessage = errorData.message;
-          logger.error("websocket", `WebSocket error (${errorCode}): ${errorMessage}`);
-          if (errorCode === 4001) {
-            logger.error("websocket", "Application does not exist - check Reverb app key configuration");
-          } else if (errorCode === 4009) {
-            logger.error("websocket", "Connection is unauthorized - authentication token may be invalid or expired");
-            const { notify: notify2 } = await import("./notify-NXUEEO7M.js");
-            notify2({
-              title: "Stint Agent - Connection Issue",
-              message: "WebSocket authentication failed. Notifications may be delayed (falling back to polling)."
-            });
-          }
-        } catch (parseError) {
-          logger.error("websocket", `WebSocket error: ${JSON.stringify(message.data)}`);
-        }
-        return;
-      }
-      if (message.event === "commit.approved") {
-        const { pendingCommit } = message.data;
-        logger.info("websocket", `Commit approved: ${pendingCommit.id}`);
-        this.commitApprovedHandlers.forEach((handler) => handler(pendingCommit, pendingCommit.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 { project } = message.data;
-        logger.info("websocket", `Sync requested for project: ${project.id}`);
-        this.syncRequestedHandlers.forEach((handler) => handler(project.id));
-        return;
-      }
-      if (message.event === "agent.disconnected") {
-        const { reason } = message.data;
-        logger.warn("websocket", `Agent disconnected by server: ${reason ?? "Server requested disconnect"}`);
-        this.agentDisconnectedHandlers.forEach((handler) => handler(reason ?? "Server requested disconnect"));
-        return;
-      }
-      logger.info("websocket", `Unhandled event: ${message.event}, payload: ${JSON.stringify(message)}`);
-    } catch (error) {
-      logger.error("websocket", "Failed to parse message", error);
-    }
-  }
   handleDisconnect() {
-    this.ws = null;
     this.disconnectHandlers.forEach((handler) => handler());
     if (this.isManualDisconnect) {
       return;
@@ -472,6 +528,7 @@ var WebSocketServiceImpl = class {
 var websocketService = new WebSocketServiceImpl();
 
 export {
+  notify,
   commitQueue,
   websocketService
 };

package/dist/{chunk-XHXSWLUC.js → chunk-WETVBZ6Z.js}

@@ -214,7 +214,95 @@ var Logger = class {
 };
 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-6EGHLTCT.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
+  logger,
+  authService
 };

package/dist/{chunk-I6DTKIFX.js → chunk-XPZNWXB4.js}

@@ -1,10 +1,8 @@
 import {
-  authService
-} from "./chunk-7TIF7QZL.js";
-import {
+  authService,
   config,
   logger
-} from "./chunk-XHXSWLUC.js";
+} from "./chunk-WETVBZ6Z.js";
 
 // src/utils/circuit-breaker.ts
 var CircuitBreaker = class {
@@ -100,7 +98,7 @@ var CircuitBreaker = class {
 };
 
 // src/services/api.ts
-var AGENT_VERSION = "1.2.16";
+var AGENT_VERSION = "1.2.18";
 var ApiServiceImpl = class {
   sessionId = null;
   circuitBreaker = new CircuitBreaker({

package/dist/daemon/runner.js

@@ -1,149 +1,26 @@
 #!/usr/bin/env node
 import {
   commitQueue,
+  notify,
   websocketService
-} from "../chunk-Z44NPHXG.js";
+} from "../chunk-SXPP272L.js";
 import {
   apiService
-} from "../chunk-I6DTKIFX.js";
+} from "../chunk-XPZNWXB4.js";
 import {
   gitService,
   projectService,
   removePidFile,
   writePidFile
-} from "../chunk-QQP6IASS.js";
-import {
-  authService
-} from "../chunk-7TIF7QZL.js";
-import {
-  notify
-} from "../chunk-DCY3EXDX.js";
+} from "../chunk-A2CVSQ3K.js";
 import {
+  authService,
   logger
-} from "../chunk-XHXSWLUC.js";
+} from "../chunk-WETVBZ6Z.js";
 
 // src/daemon/runner.ts
 import "dotenv/config";
 
-// src/services/polling.ts
-var PollingServiceImpl = class {
-  interval = null;
-  knownCommitIds = /* @__PURE__ */ new Set();
-  knownProjects = /* @__PURE__ */ new Map();
-  commitApprovedHandlers = [];
-  projectUpdatedHandlers = [];
-  isFirstRun = true;
-  isPolling = false;
-  /**
-   * Start polling for pending commits
-   * @param intervalMs - Polling interval in milliseconds (default: 10000)
-   */
-  start(intervalMs = 1e4) {
-    if (this.interval) {
-      return;
-    }
-    logger.info("polling", `Starting polling service (interval: ${intervalMs}ms)`);
-    this.poll();
-    this.interval = setInterval(() => {
-      this.poll();
-    }, intervalMs);
-  }
-  /**
-   * Stop polling
-   */
-  stop() {
-    if (this.interval) {
-      clearInterval(this.interval);
-      this.interval = null;
-      logger.info("polling", "Stopping polling service");
-    }
-  }
-  /**
-   * Register handler for commit approved event
-   * @param handler - Function to call when a commit is approved where it was previously unknown
-   */
-  onCommitApproved(handler) {
-    this.commitApprovedHandlers.push(handler);
-  }
-  /**
-   * Register handler for project updated event
-   * @param handler - Function to call when a project is updated
-   */
-  onProjectUpdated(handler) {
-    this.projectUpdatedHandlers.push(handler);
-  }
-  /**
-   * Poll for updates
-   */
-  async poll() {
-    if (this.isPolling) {
-      return;
-    }
-    this.isPolling = true;
-    try {
-      const linkedProjects = projectService.getAllLinkedProjects();
-      const projectIds = Object.values(linkedProjects).map((p) => p.projectId);
-      if (projectIds.length === 0) {
-        this.isFirstRun = false;
-        this.isPolling = false;
-        return;
-      }
-      const apiProjects = await apiService.getLinkedProjects();
-      const projects = apiProjects.filter((p) => projectIds.includes(p.id));
-      for (const project of projects) {
-        const cachedProject = this.knownProjects.get(project.id);
-        if (cachedProject) {
-          if (cachedProject.updatedAt !== project.updatedAt) {
-            if (!this.isFirstRun) {
-              logger.info("polling", `Project update detected: ${project.id}`);
-              this.notifyProjectUpdated(project);
-            }
-          }
-        }
-        this.knownProjects.set(project.id, project);
-        try {
-          const commits = await apiService.getPendingCommits(project.id);
-          for (const commit of commits) {
-            if (!this.knownCommitIds.has(commit.id)) {
-              this.knownCommitIds.add(commit.id);
-              if (!this.isFirstRun) {
-                logger.info("polling", `New pending commit detected: ${commit.id}`);
-                this.notifyCommitApproved(commit, project);
-              }
-            }
-          }
-        } catch (error) {
-          logger.debug("polling", `Failed to poll project ${project.id}: ${error.message}`);
-        }
-      }
-      this.isFirstRun = false;
-    } catch (error) {
-      logger.error("polling", "Poll cycle failed", error);
-    } finally {
-      this.isPolling = false;
-    }
-  }
-  notifyCommitApproved(commit, project) {
-    this.commitApprovedHandlers.forEach((handler) => {
-      try {
-        handler(commit, project);
-      } catch (error) {
-        logger.error("polling", "Error in commit approved handler", error);
-      }
-    });
-  }
-  notifyProjectUpdated(project) {
-    this.projectUpdatedHandlers.forEach((handler) => {
-      try {
-        handler(project);
-      } catch (error) {
-        logger.error("polling", "Error in project updated handler", error);
-      }
-    });
-  }
-};
-var pollingService = new PollingServiceImpl();
-
 // src/daemon/watcher.ts
 import fs from "fs";
 var FileWatcher = class {
@@ -286,9 +163,16 @@ var FileWatcher = class {
       const repoInfo = await gitService.getRepoInfo(projectPath);
       await apiService.syncProject(projectId, repoInfo);
       logger.success("watcher", `Synced project ${projectId}`);
+      let projectName = projectId;
+      try {
+        const projects = await apiService.getLinkedProjects();
+        const p = projects.find((proj) => proj.id === projectId);
+        if (p) projectName = p.name;
+      } catch (_e) {
+      }
       notify({
         title: "Sync Complete",
-        message: `Project ${projectId} synced successfully.`
+        message: `Project "${projectName}" synced successfully.`
       });
     } catch (error) {
       logger.error("watcher", `Failed to sync project ${projectId}`, error);
@@ -384,19 +268,18 @@ Project: ${project.name}`
       });
       commitQueue.addToQueue(commit, project);
     });
-    pollingService.onCommitApproved((commit, project) => {
-      logger.info("daemon", `Commit approved (via polling): ${commit.id} for project ${project.name}`);
-      notify({
-        title: "Commit Approved",
-        message: `${commit.message}
-Project: ${project.name}`
-      });
-      commitQueue.addToQueue(commit, project);
-    });
-    websocketService.onCommitPending((commit) => {
+    websocketService.onCommitPending(async (data) => {
+      const commit = data;
       logger.info("daemon", `Commit pending: ${commit.id}`);
+      let projectName = commit.projectId;
+      try {
+        const projects = await apiService.getLinkedProjects();
+        const p = projects.find((proj) => proj.id === commit.projectId);
+        if (p) projectName = p.name;
+      } catch (_e) {
+      }
       notify({
-        title: "New Pending Commit",
+        title: `New Proposal - ${projectName}`,
         message: commit.message
       });
     });
@@ -407,13 +290,6 @@ Project: ${project.name}`
         message: project.name
       });
     });
-    pollingService.onProjectUpdated((project) => {
-      logger.info("daemon", `Project updated (via polling): ${project.id} - ${project.name}`);
-      notify({
-        title: "Project Updated",
-        message: project.name
-      });
-    });
     websocketService.onDisconnect(() => {
       logger.warn("daemon", "WebSocket disconnected, will attempt to reconnect");
     });
@@ -436,9 +312,18 @@ Priority: ${suggestion.priority}`,
     websocketService.onSyncRequested(async (projectId) => {
       logger.info("daemon", `Server requested sync for project: ${projectId}`);
       try {
+        let projectName = projectId;
+        try {
+          const projects = await apiService.getLinkedProjects();
+          const project = projects.find((p) => p.id === projectId);
+          if (project) {
+            projectName = project.name;
+          }
+        } catch (_e) {
+        }
         notify({
           title: "Sync Requested",
-          message: `Syncing project ${projectId}...`
+          message: `Syncing project "${projectName}"...`
         });
         await fileWatcher.syncProjectById(projectId);
       } catch (error) {
@@ -453,7 +338,6 @@ Priority: ${suggestion.priority}`,
       logger.info("daemon", `Linked project: ${project.projectId}`);
       fileWatcher.watchProject(project.projectId);
     });
-    pollingService.start();
     logger.info("daemon", "Daemon started successfully");
     const projectEntries = Object.entries(linkedProjects);
     if (projectEntries.length > 0) {

package/dist/index.js

@@ -2,10 +2,10 @@
 import {
   commitQueue,
   websocketService
-} from "./chunk-Z44NPHXG.js";
+} from "./chunk-SXPP272L.js";
 import {
   apiService
-} from "./chunk-I6DTKIFX.js";
+} from "./chunk-XPZNWXB4.js";
 import {
   getPidFilePath,
   gitService,
@@ -14,15 +14,12 @@ import {
   projectService,
   spawnDetached,
   validatePidFile
-} from "./chunk-QQP6IASS.js";
-import {
-  authService
-} from "./chunk-7TIF7QZL.js";
-import "./chunk-DCY3EXDX.js";
+} from "./chunk-A2CVSQ3K.js";
 import {
+  authService,
   config,
   logger
-} from "./chunk-XHXSWLUC.js";
+} from "./chunk-WETVBZ6Z.js";
 
 // src/index.ts
 import "dotenv/config";
@@ -623,7 +620,7 @@ function registerStatusCommand(program2) {
       try {
         const { render } = await import("ink");
         const { createElement } = await import("react");
-        const { StatusDashboard } = await import("./StatusDashboard-LCGOELR4.js");
+        const { StatusDashboard } = await import("./StatusDashboard-KCHNLVD7.js");
         render(createElement(StatusDashboard, { cwd }));
         return;
       } catch (error) {
@@ -784,9 +781,8 @@ function getProcessStats(pid) {
     } else if (platform === "win32") {
       return getWindowsStats(pid);
     }
-    throw new Error(`Unsupported platform: ${platform}`);
-  } catch (error) {
-    logger.error("monitor", `Failed to get process stats for PID ${pid}`, error);
+    return null;
+  } catch {
     return null;
   }
 }
@@ -1025,6 +1021,30 @@ function registerDaemonCommands(program2) {
           console.log(`${chalk8.bold("Threads:")}     ${stats.threads}`);
           console.log(`${chalk8.bold("Uptime:")}      ${formatUptime(stats.uptime)}`);
         }
+        const statusPath = path3.join(os3.homedir(), ".config", "stint", "daemon.status.json");
+        if (fs.existsSync(statusPath)) {
+          try {
+            const statusData = JSON.parse(fs.readFileSync(statusPath, "utf8"));
+            console.log(chalk8.blue("\n\u{1F4E1} WebSocket Status:"));
+            console.log(chalk8.gray("\u2500".repeat(50)));
+            if (statusData.websocket?.connected) {
+              console.log(`${chalk8.bold("Connected:")}   ${chalk8.green("\u2713 Yes")}`);
+              if (statusData.websocket.channel) {
+                console.log(`${chalk8.bold("Channel:")}     ${statusData.websocket.channel}`);
+              }
+            } else {
+              console.log(`${chalk8.bold("Connected:")}   ${chalk8.yellow("\u2717 No")}`);
+            }
+            if (statusData.websocket?.lastEvent) {
+              console.log(`${chalk8.bold("Last Event:")}  ${statusData.websocket.lastEvent}`);
+              if (statusData.websocket.lastEventTime) {
+                const ago = Math.floor((Date.now() - new Date(statusData.websocket.lastEventTime).getTime()) / 1e3);
+                console.log(`${chalk8.bold("Event Time:")}  ${formatUptime(ago)} ago`);
+              }
+            }
+          } catch {
+          }
+        }
       } else {
         console.log(`${chalk8.bold("Status:")}      ${chalk8.yellow("Not running")}`);
         console.log(chalk8.gray('Run "stint daemon start" to start the daemon.'));
@@ -2003,7 +2023,7 @@ function registerDoctorCommand(program2) {
 }
 
 // src/index.ts
-var AGENT_VERSION = "1.2.16";
+var AGENT_VERSION = "1.2.18";
 var program = new Command();
 program.name("stint").description("Stint Agent - Local daemon for Stint Project Assistant").version(AGENT_VERSION, "-v, --version", "output the current version").addHelpText("after", `
 ${chalk13.bold("Examples:")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gowelle/stint-agent",
-  "version": "1.2.16",
+  "version": "1.2.18",
   "description": "Local agent for Stint - Project Assistant",
   "author": "Gowelle John <gowelle.john@icloud.com>",
   "license": "MIT",
@@ -44,10 +44,12 @@
     "conf": "^12.0.0",
     "dotenv": "^17.2.3",
     "ink": "^5.2.1",
+    "laravel-echo": "^2.2.6",
     "node-fetch": "^3.3.2",
     "node-notifier": "^10.0.1",
     "open": "^10.0.0",
     "ora": "^8.0.1",
+    "pusher-js": "^8.4.0",
     "react": "^18.3.1",
     "simple-git": "^3.22.0",
     "ws": "^8.16.0"

package/dist/api-IB5F32WJ.js

@@ -1,8 +0,0 @@
-import {
-  apiService
-} from "./chunk-I6DTKIFX.js";
-import "./chunk-7TIF7QZL.js";
-import "./chunk-XHXSWLUC.js";
-export {
-  apiService
-};

package/dist/chunk-7TIF7QZL.js

@@ -1,95 +0,0 @@
-import {
-  config,
-  logger
-} from "./chunk-XHXSWLUC.js";
-
-// src/utils/crypto.ts
-import crypto from "crypto";
-import os from "os";
-function getMachineKey() {
-  const machineInfo = `${os.hostname()}-${os.platform()}-${os.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-IB5F32WJ.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 {
-  authService
-};

package/dist/chunk-DCY3EXDX.js

@@ -1,40 +0,0 @@
-import {
-  config,
-  logger
-} from "./chunk-XHXSWLUC.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);
-  }
-}
-
-export {
-  notify
-};

package/dist/notify-NXUEEO7M.js

@@ -1,7 +0,0 @@
-import {
-  notify
-} from "./chunk-DCY3EXDX.js";
-import "./chunk-XHXSWLUC.js";
-export {
-  notify
-};