@wrongstack/desktop 0.284.0 → 0.285.0

package/dist/main/main.js

@@ -1,10 +1,6 @@
-import {
-  DesktopAgentBridge
-} from "./chunk-AMPSW3AD.js";
-
 // src/main/main.ts
-import * as path3 from "path";
-import * as fs3 from "fs/promises";
+import * as path3 from "node:path";
+import * as fs3 from "node:fs/promises";
 import { wstackGlobalRoot as wstackGlobalRoot3 } from "@wrongstack/core/utils";
 import {
   app,
@@ -16,6 +12,359 @@ import {
   WebContentsView
 } from "electron";
 
+// src/main/agent-bridge.ts
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import WebSocket from "ws";
+var MAX_MESSAGES = 300;
+var RECONNECT_CONFIG = {
+  /** Maximum number of reconnection attempts (0 = disabled) */
+  maxAttempts: 5,
+  /** Initial delay in ms before first reconnection */
+  initialDelayMs: 1e3,
+  /** Maximum delay in ms between reconnection attempts */
+  maxDelayMs: 3e4,
+  /** Multiplier for exponential backoff */
+  backoffMultiplier: 2,
+  /** Jitter factor (0-1) to add randomness to delays */
+  jitterFactor: 0.1
+};
+var DesktopAgentBridge = class extends EventEmitter {
+  conversations = /* @__PURE__ */ new Map();
+  snapshot(runtimeId) {
+    return publicConversation(this.getOrCreate(runtimeId));
+  }
+  /**
+   * Get reconnection status for a runtime.
+   */
+  getReconnectStatus(runtimeId) {
+    const conversation = this.conversations.get(runtimeId);
+    if (!conversation) return null;
+    return {
+      attempt: conversation.reconnectAttempt,
+      maxAttempts: RECONNECT_CONFIG.maxAttempts
+    };
+  }
+  /**
+   * Force reconnection for a runtime (resets reconnection state).
+   */
+  forceReconnect(runtimeId, wsUrl) {
+    const conversation = this.getOrCreate(runtimeId);
+    this.cancelReconnect(conversation);
+    conversation.reconnectAttempt = 0;
+    void this.ensureConnected(runtimeId, wsUrl);
+  }
+  async ensureConnected(runtimeId, wsUrl) {
+    const conversation = this.getOrCreate(runtimeId);
+    if (conversation.ws?.readyState === WebSocket.OPEN) return publicConversation(conversation);
+    if (conversation.connectPromise) {
+      await conversation.connectPromise;
+      return publicConversation(conversation);
+    }
+    if (conversation.reconnectTimer) {
+      return publicConversation(conversation);
+    }
+    conversation.reconnectUrl = wsUrl;
+    conversation.reconnectAttempt = 0;
+    await this.connect(runtimeId, wsUrl);
+    return publicConversation(conversation);
+  }
+  /**
+   * Internal connect method that actually establishes the WebSocket.
+   */
+  async connect(runtimeId, wsUrl) {
+    const conversation = this.getOrCreate(runtimeId);
+    this.cancelReconnect(conversation);
+    conversation.status = "connecting";
+    conversation.error = void 0;
+    this.emitChanged(conversation);
+    this.emitReconnectEvent(conversation, "connecting");
+    return new Promise((resolve2, reject) => {
+      const ws = new WebSocket(wsUrl);
+      conversation.ws = ws;
+      const timeout = setTimeout(() => {
+        if (conversation.ws === ws) {
+          ws.close();
+          reject(new Error("Connection timeout"));
+        }
+      }, 1e4);
+      ws.once("open", () => {
+        clearTimeout(timeout);
+        conversation.status = "connected";
+        conversation.error = void 0;
+        conversation.connectPromise = null;
+        conversation.reconnectAttempt = 0;
+        conversation.reconnectUrl = null;
+        this.emitChanged(conversation);
+        this.emitReconnectEvent(conversation, "connected");
+        resolve2();
+      });
+      ws.on("message", (data) => {
+        this.handleServerMessage(conversation, data.toString());
+      });
+      ws.once("error", (err) => {
+        clearTimeout(timeout);
+        conversation.status = "error";
+        conversation.error = err instanceof Error ? err.message : String(err);
+        conversation.connectPromise = null;
+        this.appendMessage(conversation, {
+          role: "system",
+          text: `Connection error: ${conversation.error}`
+        });
+        this.emitChanged(conversation);
+        this.emitReconnectEvent(conversation, "error");
+        reject(err);
+      });
+      ws.once("close", () => {
+        clearTimeout(timeout);
+        if (conversation.ws === ws) conversation.ws = null;
+        conversation.connectPromise = null;
+        if (conversation.status !== "error") {
+          conversation.status = "disconnected";
+        }
+        conversation.activeAssistantMessageId = null;
+        this.emitChanged(conversation);
+        if (conversation.reconnectUrl && conversation.status === "disconnected") {
+          this.scheduleReconnect(conversation);
+        }
+      });
+    });
+  }
+  /**
+   * Schedule a reconnection attempt with exponential backoff.
+   */
+  scheduleReconnect(conversation) {
+    if (RECONNECT_CONFIG.maxAttempts === 0) return;
+    if (conversation.reconnectAttempt >= RECONNECT_CONFIG.maxAttempts) {
+      this.emitReconnectEvent(conversation, "exhausted");
+      return;
+    }
+    const baseDelay = Math.min(
+      RECONNECT_CONFIG.initialDelayMs * Math.pow(RECONNECT_CONFIG.backoffMultiplier, conversation.reconnectAttempt),
+      RECONNECT_CONFIG.maxDelayMs
+    );
+    const jitter = baseDelay * RECONNECT_CONFIG.jitterFactor * Math.random();
+    const delay = Math.floor(baseDelay + jitter);
+    conversation.reconnectAttempt++;
+    this.emitReconnectEvent(conversation, "scheduled", { delay, attempt: conversation.reconnectAttempt });
+    conversation.reconnectTimer = setTimeout(() => {
+      conversation.reconnectTimer = null;
+      if (!conversation.reconnectUrl) return;
+      if (conversation.ws?.readyState !== WebSocket.OPEN) {
+        void this.connect(conversation.runtimeId, conversation.reconnectUrl);
+      }
+    }, delay);
+  }
+  /**
+   * Cancel pending reconnection.
+   */
+  cancelReconnect(conversation) {
+    if (conversation.reconnectTimer) {
+      clearTimeout(conversation.reconnectTimer);
+      conversation.reconnectTimer = null;
+    }
+  }
+  /**
+   * Emit reconnection event for UI feedback.
+   */
+  emitReconnectEvent(conversation, status, data) {
+    this.emit("reconnect", {
+      runtimeId: conversation.runtimeId,
+      status,
+      attempt: conversation.reconnectAttempt,
+      maxAttempts: RECONNECT_CONFIG.maxAttempts,
+      ...data
+    });
+  }
+  async sendMessage(runtimeId, wsUrl, content) {
+    const trimmed = content.trim();
+    if (!trimmed) return this.snapshot(runtimeId);
+    const conversation = this.getOrCreate(runtimeId);
+    conversation.reconnectAttempt = 0;
+    await this.ensureConnected(runtimeId, wsUrl);
+    const conv = this.getOrCreate(runtimeId);
+    this.appendMessage(conv, {
+      id: `user_${randomUUID()}`,
+      role: "user",
+      text: trimmed
+    });
+    conv.status = "running";
+    conv.activeAssistantMessageId = null;
+    this.emitChanged(conv);
+    this.send(conv, {
+      type: "user_message",
+      payload: {
+        id: `msg_${Date.now()}_${randomUUID().slice(0, 8)}`,
+        content: trimmed,
+        timestamp: Date.now(),
+        ...conv.sessionId ? { sessionId: conv.sessionId } : {}
+      }
+    });
+    return publicConversation(conv);
+  }
+  async abort(runtimeId, wsUrl) {
+    const conversation = this.getOrCreate(runtimeId);
+    conversation.reconnectAttempt = 0;
+    await this.ensureConnected(runtimeId, wsUrl);
+    const conv = this.getOrCreate(runtimeId);
+    this.send(conv, {
+      type: "abort",
+      payload: conv.sessionId ? { sessionId: conv.sessionId } : {}
+    });
+    conv.status = "connected";
+    this.appendMessage(conv, { role: "system", text: "Abort requested." });
+    return publicConversation(conv);
+  }
+  close(runtimeId) {
+    const conversation = this.conversations.get(runtimeId);
+    if (!conversation) return;
+    this.cancelReconnect(conversation);
+    conversation.reconnectAttempt = 0;
+    conversation.reconnectUrl = null;
+    conversation.ws?.close();
+    conversation.ws = null;
+    conversation.connectPromise = null;
+    conversation.status = "disconnected";
+    conversation.activeAssistantMessageId = null;
+    this.emitChanged(conversation);
+  }
+  closeAll() {
+    for (const runtimeId of this.conversations.keys()) {
+      this.close(runtimeId);
+    }
+  }
+  handleServerMessage(conversation, raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    const payload = message.payload ?? {};
+    switch (message.type) {
+      case "session.start": {
+        const sessionId = stringValue(payload["sessionId"]);
+        if (sessionId) conversation.sessionId = sessionId;
+        conversation.status = conversation.status === "running" ? "running" : "connected";
+        this.emitChanged(conversation);
+        break;
+      }
+      case "provider.text_delta": {
+        conversation.status = "running";
+        this.appendAssistantDelta(conversation, stringValue(payload["text"]) ?? "");
+        break;
+      }
+      case "tool.started": {
+        conversation.status = "running";
+        const name = stringValue(payload["name"]) ?? "tool";
+        this.appendMessage(conversation, { role: "tool", text: `Started ${name}` });
+        break;
+      }
+      case "tool.executed": {
+        const name = stringValue(payload["name"]) ?? "tool";
+        const ok = payload["ok"] === true;
+        this.appendMessage(conversation, {
+          role: "tool",
+          text: `${name} ${ok ? "completed" : "failed"}`
+        });
+        break;
+      }
+      case "provider.error":
+      case "provider.stream_error":
+      case "error": {
+        const text = stringValue(payload["message"]) ?? stringValue(payload["description"]) ?? `${message.type} received`;
+        conversation.status = "error";
+        conversation.error = text;
+        this.appendMessage(conversation, { role: "system", text });
+        break;
+      }
+      case "run.result": {
+        const finalText = stringValue(payload["finalText"]);
+        if (finalText && !this.lastAssistantHasText(conversation)) {
+          this.appendMessage(conversation, { role: "assistant", text: finalText });
+        }
+        conversation.status = payload["status"] === "failed" ? "error" : "connected";
+        conversation.activeAssistantMessageId = null;
+        this.emitChanged(conversation);
+        break;
+      }
+    }
+  }
+  send(conversation, message) {
+    if (conversation.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Runtime socket is not connected");
+    }
+    conversation.ws.send(JSON.stringify(message));
+  }
+  appendAssistantDelta(conversation, text) {
+    if (!text) return;
+    let message = conversation.messages.find((m) => m.id === conversation.activeAssistantMessageId);
+    if (!message) {
+      message = {
+        id: `assistant_${randomUUID()}`,
+        role: "assistant",
+        text: "",
+        timestamp: Date.now()
+      };
+      conversation.activeAssistantMessageId = message.id;
+      conversation.messages.push(message);
+    }
+    message.text += text;
+    this.trimMessages(conversation);
+    this.emitChanged(conversation);
+  }
+  appendMessage(conversation, input) {
+    conversation.messages.push({
+      id: input.id ?? `${input.role}_${randomUUID()}`,
+      role: input.role,
+      text: input.text,
+      timestamp: input.timestamp ?? Date.now()
+    });
+    this.trimMessages(conversation);
+    this.emitChanged(conversation);
+  }
+  lastAssistantHasText(conversation) {
+    const lastAssistant = [...conversation.messages].reverse().find((m) => m.role === "assistant");
+    return Boolean(lastAssistant?.text.trim());
+  }
+  trimMessages(conversation) {
+    if (conversation.messages.length <= MAX_MESSAGES) return;
+    conversation.messages.splice(0, conversation.messages.length - MAX_MESSAGES);
+  }
+  getOrCreate(runtimeId) {
+    let conversation = this.conversations.get(runtimeId);
+    if (conversation) return conversation;
+    conversation = {
+      runtimeId,
+      status: "disconnected",
+      messages: [],
+      ws: null,
+      connectPromise: null,
+      activeAssistantMessageId: null,
+      reconnectAttempt: 0,
+      reconnectTimer: null,
+      reconnectUrl: null
+    };
+    this.conversations.set(runtimeId, conversation);
+    return conversation;
+  }
+  emitChanged(conversation) {
+    this.emit("changed", publicConversation(conversation));
+  }
+};
+function publicConversation(conversation) {
+  return {
+    runtimeId: conversation.runtimeId,
+    status: conversation.status,
+    sessionId: conversation.sessionId,
+    error: conversation.error,
+    messages: conversation.messages.map((message) => ({ ...message }))
+  };
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+
 // src/main/ipc.ts
 var IPC = {
   getState: "desktop:get-state",
@@ -352,8 +701,8 @@ function tMain(key) {
 }
 
 // src/main/desktop-config-io.ts
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { DefaultSecretVault } from "@wrongstack/core";
 import { decryptConfigSecrets, encryptConfigSecrets } from "@wrongstack/core/security";
 import { atomicWrite, wstackGlobalRoot } from "@wrongstack/core/utils";
@@ -400,24 +749,24 @@ async function writeUiLocale(code) {
 }
 
 // src/main/runtime-manager.ts
-import { spawn } from "child_process";
-import { randomBytes } from "crypto";
-import { EventEmitter } from "events";
-import * as fs2 from "fs/promises";
-import { existsSync } from "fs";
-import * as http from "http";
-import { createRequire } from "module";
-import * as net from "net";
-import * as os from "os";
-import * as path2 from "path";
-import { fileURLToPath } from "url";
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import * as fs2 from "node:fs/promises";
+import { existsSync } from "node:fs";
+import * as http from "node:http";
+import { createRequire } from "node:module";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path2 from "node:path";
+import { fileURLToPath } from "node:url";
 import { atomicWrite as atomicWrite2, projectSlug, toErrorMessage, wstackGlobalRoot as wstackGlobalRoot2 } from "@wrongstack/core/utils";
 var HTTP_PORT_START = 34560;
 var WS_PORT_START = 34660;
 var START_TIMEOUT_MS = 3e4;
 var MIN_WINDOW_WIDTH = 760;
 var MIN_WINDOW_HEIGHT = 520;
-var DesktopRuntimeManager = class extends EventEmitter {
+var DesktopRuntimeManager = class extends EventEmitter2 {
   runtimes = /* @__PURE__ */ new Map();
   stateFile = path2.join(wstackGlobalRoot2(), "desktop.json");
   recentProjects = [];
@@ -1331,7 +1680,7 @@ function getSidebarWidth(windowWidth, collapsed) {
 import { Menu } from "electron";
 
 // src/main/menu/projects-menu.ts
-var posix = (await import("path")).posix;
+var posix = (await import("node:path")).posix;
 function buildProjectsMenu(runtimes, actions, t) {
   const projectGroups = groupProjectRuntimesForMenu(runtimes);
   const menu = [
@@ -2454,4 +2803,4 @@ app.on("activate", () => {
   mainWindow.show();
   shellView?.webContents.focus();
 });
-//# sourceMappingURL=main.js.map
+//# sourceMappingURL=main.js.map