@rajat-rastogi/maestro 0.2.5 → 0.3.0

package/app/out/main/main.js

@@ -488,6 +488,9 @@ function registerSessionsIpc(sessionManager2) {
   electron.ipcMain.handle("sessions:updateTags", async (_e, id, tags) => {
     sessionManager2.updateTags(id, tags);
   });
+  electron.ipcMain.handle("sessions:interrupt", async (_e, id) => {
+    sessionManager2.interrupt(id);
+  });
   electron.ipcMain.handle("sessions:sendInput", async (_e, id, data) => {
     sessionManager2.sendInput(id, data);
   });
@@ -507,56 +510,77 @@ class AgentConnectionPool {
     if (local) env.PATH = `${local}\\Microsoft\\WinGet\\Links;${env.PATH ?? ""}`;
     return env;
   }
-  /** Get a ready WebSocket for tunnelId, spawning devtunnel connect if needed. */
+  /**
+   * Discover the WSS URL for a tunnel by running `devtunnel show`.
+   * Parses the port line to find the HTTPS URL, converts to WSS.
+   */
+  discoverWssUrl(tunnelId) {
+    console.log(`[AgentPool] discovering WSS URL for "${tunnelId}"...`);
+    const output = child_process.execSync(`devtunnel show ${tunnelId}`, {
+      encoding: "utf8",
+      env: this.wingetEnv(),
+      timeout: 1e4
+    });
+    const portLine = output.split("\n").find((l) => l.includes("9741") && l.includes("https://"));
+    if (!portLine) {
+      throw new Error(`No port 9741 URL found in devtunnel show output for "${tunnelId}"`);
+    }
+    const match = portLine.match(/https:\/\/[^\s]+/);
+    if (!match) {
+      throw new Error(`Could not parse URL from: ${portLine.trim()}`);
+    }
+    const wssUrl = match[0].replace("https://", "wss://").replace(/\/$/, "");
+    console.log(`[AgentPool] discovered: ${wssUrl}`);
+    return wssUrl;
+  }
+  /** Get a ready WebSocket for tunnelId, connecting via WSS URL. */
   async getConnection(tunnelId) {
     const existing = this.pool.get(tunnelId);
     if (existing) {
-      if (existing.ready && existing.ws?.readyState === WebSocket.OPEN) {
+      if (existing.ready && existing.ws.readyState === WebSocket.OPEN) {
         return existing.ws;
       }
-      console.log(`[AgentPool] getConnection: "${tunnelId}" — queuing (connection in progress)`);
-      return new Promise((resolve) => existing.queue.push(resolve));
+      if (!existing.ready) {
+        console.log(`[AgentPool] getConnection: "${tunnelId}" — queuing (connection in progress)`);
+        return new Promise((resolve) => existing.queue.push(resolve));
+      }
+      this.pool.delete(tunnelId);
     }
-    const entry = { proc: null, ws: null, ready: false, queue: [] };
+    let wssUrl;
+    try {
+      wssUrl = this.discoverWssUrl(tunnelId);
+    } catch (err) {
+      console.log(`[AgentPool] getConnection failed: ${err instanceof Error ? err.message : String(err)}`);
+      throw err;
+    }
+    const entry = { ws: null, wssUrl, ready: false, queue: [] };
     this.pool.set(tunnelId, entry);
-    console.log(`[AgentPool] getConnection: spawning "devtunnel connect ${tunnelId}"...`);
-    entry.proc = child_process.spawn("devtunnel", ["connect", tunnelId], { shell: true, env: this.wingetEnv() });
-    entry.proc.stderr?.on("data", (data) => {
-      console.log(`[AgentPool] devtunnel stderr: ${data.toString().trim()}`);
-    });
-    entry.proc.on("error", (err) => {
-      console.log(`[AgentPool] devtunnel process error: ${err.message}`);
-      this.teardown(tunnelId);
-    });
-    entry.proc.on("exit", (code) => {
-      console.log(`[AgentPool] devtunnel exited with code ${code}`);
-      this.teardown(tunnelId);
-    });
-    console.log(`[AgentPool] getConnection: waiting 4s for devtunnel to establish port forwarding...`);
-    await new Promise((r) => setTimeout(r, 4e3));
-    console.log(`[AgentPool] getConnection: opening WebSocket to ws://127.0.0.1:9741...`);
-    const ws = new WebSocket("ws://127.0.0.1:9741");
+    console.log(`[AgentPool] getConnection: opening WebSocket to ${wssUrl}...`);
+    const ws = new WebSocket(wssUrl);
     entry.ws = ws;
     return new Promise((resolve, reject) => {
       ws.on("open", () => {
-        console.log(`[AgentPool] getConnection: WebSocket connected to agent`);
+        console.log(`[AgentPool] getConnection: connected to agent via ${wssUrl}`);
         entry.ready = true;
         entry.queue.forEach((cb) => cb(ws));
         entry.queue = [];
         resolve(ws);
       });
       ws.on("error", (err) => {
-        console.log(`[AgentPool] getConnection: WebSocket error: ${err.message}`);
+        console.log(`[AgentPool] WebSocket error for "${tunnelId}": ${err.message}`);
         this.teardown(tunnelId);
         reject(new Error(`Agent WebSocket error: ${err.message}`));
       });
-      ws.on("close", () => this.teardown(tunnelId));
+      ws.on("close", () => {
+        console.log(`[AgentPool] WebSocket closed for "${tunnelId}"`);
+        this.teardown(tunnelId);
+      });
     });
   }
   /** Ping the agent via WebSocket, return true if pong received within 5s. */
   async ping(tunnelId) {
     try {
-      console.log(`[AgentPool] ping: connecting to tunnel "${tunnelId}"...`);
+      console.log(`[AgentPool] ping: connecting to "${tunnelId}"...`);
       const ws = await this.getConnection(tunnelId);
       console.log(`[AgentPool] ping: connected, sending ping...`);
       return new Promise((resolve) => {
@@ -588,10 +612,6 @@ class AgentConnectionPool {
   teardown(tunnelId) {
     const entry = this.pool.get(tunnelId);
     if (entry) {
-      try {
-        entry.proc?.kill();
-      } catch {
-      }
       try {
         entry.ws?.close();
       } catch {
@@ -1656,7 +1676,7 @@ class SessionManager {
       stateEnteredAt: (/* @__PURE__ */ new Date()).toISOString(),
       tags: {
         ...opts.tags,
-        "machine": opts.machineId,
+        "machine": machine?.name ?? opts.machineId,
         "provider": opts.provider
       },
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -1723,6 +1743,13 @@ class SessionManager {
     const entry = this.entries.get(id);
     if (entry) entry.session.tags = tags;
   }
+  /** Send Ctrl+C to interrupt the running process, then clear the screen */
+  interrupt(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return;
+    entry.adapter.write("");
+    setTimeout(() => entry.adapter.write("\r"), 200);
+  }
   sendInput(id, data) {
     this.entries.get(id)?.adapter.write(data);
   }

package/app/out/preload/preload.js

@@ -79,6 +79,7 @@ electron.contextBridge.exposeInMainWorld("maestro", {
     rename: (id, name) => electron.ipcRenderer.invoke("sessions:rename", id, name),
     updateTags: (id, tags) => electron.ipcRenderer.invoke("sessions:updateTags", id, tags),
     getBuffer: (id) => electron.ipcRenderer.invoke("sessions:getBuffer", id),
+    interrupt: (id) => electron.ipcRenderer.invoke("sessions:interrupt", id),
     sendInput: (id, data) => electron.ipcRenderer.invoke("sessions:sendInput", id, data),
     resize: (id, cols, rows) => electron.ipcRenderer.invoke("sessions:resize", id, cols, rows),
     onData: (cb) => {