mtech-ai-local-runner 0.1.107 → 0.1.108

package/README.md

@@ -1,3 +1,9 @@
+## 0.1.108: the menu bar app reconnects to a new runner
+
+After the daemon opens the menu bar app it waits up to 10 s for it to connect; if it does not (an app already
+running keeps the socket it was first given), the daemon quits it and opens it once more. Nothing else changes from
+0.1.107.
+
 ## 0.1.107: the AI Gateway menu bar app
 
 `setup` installs `~/Applications/AI Gateway.app` and the daemon opens it (Gateway Work Item b9218937). A bell in the

package/dist/src/menubar/channel.js

@@ -21,6 +21,7 @@ export class MenubarChannel {
     state;
     waiting = new Map();
     listeners = { refresh: [], quit: [] };
+    appWaiters = new Set();
     constructor(options) {
         this.options = options;
         this.state = { ...options.initial };
@@ -31,6 +32,22 @@ export class MenubarChannel {
     on(event, listener) {
         this.listeners[event].push(listener);
     }
+    /** True once an app is connected, at once when one already is; false when none connects within timeoutMs. */
+    waitForApp(timeoutMs) {
+        if (this.connected)
+            return Promise.resolve(true);
+        return new Promise(resolve => {
+            const settle = (connected) => {
+                clearTimeout(timer);
+                this.appWaiters.delete(onConnect);
+                resolve(connected);
+            };
+            const onConnect = () => settle(true);
+            const timer = setTimeout(() => settle(this.connected), timeoutMs);
+            timer.unref?.();
+            this.appWaiters.add(onConnect);
+        });
+    }
     async start() {
         if (this.server !== null)
             throw new Error("MENUBAR_CHANNEL_ALREADY_LISTENING");
@@ -128,6 +145,8 @@ export class MenubarChannel {
         socket.once("close", () => { if (this.app === socket)
             this.app = null; });
         socket.write(stateLine(this.state));
+        for (const waiter of [...this.appWaiters])
+            waiter();
     }
     handle(message) {
         if (message === null)

package/dist/src/menubar/launcher.js

@@ -1,5 +1,5 @@
 import { stat } from "node:fs/promises";
-import { installedAppPath, menubarRemovedByPerson, runFile } from "./install.js";
+import { MENUBAR_EXECUTABLE, installedAppPath, menubarRemovedByPerson, runFile } from "./install.js";
 /**
  * Opens the installed app in the background (Gateway Work Item b9218937), unless the person removed it. An app that
  * already runs stays as it is. Never throws.
@@ -20,3 +20,24 @@ export async function launchMenubarApp(input) {
         return "skipped";
     }
 }
+/**
+ * Quits a running app and waits, up to 3 s, until it is gone, so a following `open` starts a new instance that
+ * receives its arguments instead of bringing the old one forward. Never throws.
+ */
+export async function quitMenubarApp(input = {}) {
+    if ((input.platform ?? process.platform) !== "darwin")
+        return;
+    const run = input.run ?? runFile;
+    try {
+        await run("/usr/bin/pkill", ["-x", MENUBAR_EXECUTABLE]);
+        for (let i = 0; i < 15; i++) {
+            // pgrep exits 1 once no process has the name.
+            if ((await run("/usr/bin/pgrep", ["-x", MENUBAR_EXECUTABLE])).code !== 0)
+                return;
+            await new Promise(resolve => setTimeout(resolve, 200));
+        }
+    }
+    catch {
+        /* Quitting is best effort; the launch that follows still runs. */
+    }
+}

package/dist/src/menubar/wiring.js

@@ -1,7 +1,9 @@
 import { packageVersion } from "../package-version.js";
 import { MenubarChannel, menubarSocketPath } from "./channel.js";
-import { launchMenubarApp } from "./launcher.js";
+import { launchMenubarApp, quitMenubarApp } from "./launcher.js";
 import { MenubarRuntime } from "./runtime.js";
+/** How long the daemon waits for the app it opened to connect before it reopens it once. */
+export const APP_CONNECT_TIMEOUT_MS = 10_000;
 /**
  * The menu bar parts of one daemon (Gateway Work Item b9218937). A channel that cannot start is logged and left off:
  * the daemon and its osascript notices run as before.
@@ -13,6 +15,30 @@ export function buildMenubar(input) {
     const runtime = new MenubarRuntime({ channel, gatewayMcpUrl: input.gatewayMcpUrl, runnerVersion: packageVersion(),
         readInbox: input.readInbox, rescanRooms: input.rescanRooms, log: input.log });
     channel.on("quit", () => input.log({ event: "menubar_app_quit" }));
+    const launch = input.launch ?? (() => launchMenubarApp({ home: input.home, stateRoot: input.stateRoot, socketPath }));
+    const quit = input.quit ?? (() => quitMenubarApp());
+    const timeoutMs = input.connectTimeoutMs ?? APP_CONNECT_TIMEOUT_MS;
+    let closed = false;
+    // An app that already runs keeps the socket it was first given, and `open` passes no new arguments to it. One that
+    // was opened but does not connect is therefore quit and opened again, once.
+    const ensureApp = async () => {
+        const status = await launch();
+        if (status !== "launched") {
+            input.log({ event: "menubar_app", status });
+            return;
+        }
+        if (await channel.waitForApp(timeoutMs)) {
+            input.log({ event: "menubar_app", status, connected: true });
+            return;
+        }
+        if (closed)
+            return;
+        await quit();
+        if (closed)
+            return;
+        const again = await launch();
+        input.log({ event: "menubar_app_relaunched", status: again, connected: again === "launched" && await channel.waitForApp(timeoutMs) });
+    };
     return {
         runtime,
         channel,
@@ -25,9 +51,11 @@ export function buildMenubar(input) {
                 return;
             }
             runtime.start();
-            input.log({ event: "menubar_app", status: await launchMenubarApp({ home: input.home, stateRoot: input.stateRoot, socketPath }) });
+            // In the background: the daemon's loops never wait for the app.
+            void ensureApp().catch(() => input.log({ event: "menubar_app_failed" }));
         },
         close: async () => {
+            closed = true;
             runtime.stop();
             await channel.stop();
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.107",
+  "version": "0.1.108",
   "private": false,
   "license": "UNLICENSED",
   "bin": {