@echomem/mcp 1.4.7 → 1.4.8

package/dist/hud/electron-main.js

@@ -1,8 +1,10 @@
+import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { app, BrowserWindow, ipcMain, Menu, screen, shell } from "electron";
+import { app, BrowserWindow, dialog, ipcMain, Menu, nativeImage, screen, shell } from "electron";
+import { disableAutostart, enableAutostart, isAutostartEnabled } from "./autostart.js";
 import { createHudServer } from "./server.js";
 const flags = parseFlags(process.argv.slice(2));
 const mode = parseMode(flags.client);
@@ -10,8 +12,16 @@ const port = typeof flags.port === "string" ? Number(flags.port) || 17377 : 1737
 const COLLAPSED_WIDTH = 360;
 const COLLAPSED_HEIGHT = 112;
 const EXPANDED_HEIGHT = 460;
+// Mini mode: a small always-on pill (status dot + tokens) for users who find the full bubble too big.
+const MINI_WIDTH = 190;
+const MINI_HEIGHT = 48;
+const AGENT_VISIBILITY_POLL_MS = 900;
+let miniPref = false;
+let onlyShowWhenAgentOpen = false;
+let manuallyHidden = false;
 let hudServer = null;
 let mainWindow = null;
+let visibilityTimer = null;
 const dragState = new Map();
 // Single-instance: a second `echomem-hud app` brings the existing HUD back instead of opening another.
 const gotSingleInstanceLock = app.requestSingleInstanceLock();
@@ -28,8 +38,23 @@ app.whenReady().then(async () => {
         if (!win)
             return;
         const bounds = win.getBounds();
-        const height = open ? clampExpandedHeight(measured && measured > 200 ? measured : EXPANDED_HEIGHT) : COLLAPSED_HEIGHT;
-        win.setBounds({ ...bounds, height });
+        // Closing returns to the user's preferred resting size (mini pill or the full bubble).
+        const width = open ? COLLAPSED_WIDTH : miniPref ? MINI_WIDTH : COLLAPSED_WIDTH;
+        const height = open ? clampExpandedHeight(measured && measured > 200 ? measured : EXPANDED_HEIGHT) : miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT;
+        win.setBounds({ ...bounds, width, height });
+        writeBounds(win);
+    });
+    ipcMain.on("hud:set-mini", (event, payload) => {
+        miniPref = typeof payload === "object" ? Boolean(payload.mini) : Boolean(payload);
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (!win)
+            return;
+        const bounds = win.getBounds();
+        win.setBounds({
+            ...bounds,
+            width: miniPref ? MINI_WIDTH : COLLAPSED_WIDTH,
+            height: miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT,
+        });
         writeBounds(win);
     });
     ipcMain.on("hud:drag-start", (event, payload) => {
@@ -99,10 +124,12 @@ app.on("window-all-closed", async () => {
 });
 function createWindow(url) {
     const savedBounds = readBounds();
+    miniPref = Boolean(savedBounds?.mini);
+    onlyShowWhenAgentOpen = Boolean(savedBounds?.onlyShowWhenAgentOpen);
     const bounds = savedBounds ? normalizedBounds(savedBounds) : defaultBounds();
     const win = new BrowserWindow({
-        width: COLLAPSED_WIDTH,
-        height: COLLAPSED_HEIGHT,
+        width: miniPref ? MINI_WIDTH : COLLAPSED_WIDTH,
+        height: miniPref ? MINI_HEIGHT : COLLAPSED_HEIGHT,
         x: bounds.x,
         y: bounds.y,
         frame: false,
@@ -126,17 +153,30 @@ function createWindow(url) {
     }
     win.on("moved", () => writeBounds(win));
     mainWindow = win;
+    const webContentsId = win.webContents.id;
     win.on("closed", () => {
-        dragState.delete(win.webContents.id);
+        dragState.delete(webContentsId);
+        stopAgentVisibilityLoop();
         if (mainWindow === win)
             mainWindow = null;
     });
     win.webContents.on("context-menu", () => {
         const menu = Menu.buildFromTemplate([
-            { label: "Hide for now", click: () => { if (!win.isDestroyed())
-                    win.hide(); } },
+            { label: "Hide for now", click: () => { hideForNow(win); } },
+            {
+                label: "Only show when Codex/Claude is open",
+                type: "checkbox",
+                checked: onlyShowWhenAgentOpen,
+                click: (item) => { setOnlyShowWhenAgentOpen(item.checked, win); },
+            },
+            {
+                label: "Show after restart",
+                type: "checkbox",
+                checked: isAutostartEnabled(),
+                click: (item) => { setAutostart(item.checked); },
+            },
             { type: "separator" },
-            { label: "Quit EchoMem HUD", click: () => app.quit() },
+            { label: "Quit EchoMem HUD", click: () => quitWithAutostartPrompt(win) },
         ]);
         menu.popup({ window: win });
     });
@@ -145,10 +185,11 @@ function createWindow(url) {
         if (shown || win.isDestroyed())
             return;
         shown = true;
-        app.focus({ steal: true });
-        win.show();
-        win.moveTop();
-        win.focus();
+        if (onlyShowWhenAgentOpen)
+            syncAgentVisibility(win);
+        else
+            showHudWindow(win, true);
+        startAgentVisibilityLoop(win);
         writeBounds(win);
     };
     win.once("ready-to-show", reveal);
@@ -158,6 +199,31 @@ function createWindow(url) {
         win.webContents.openDevTools({ mode: "detach" });
     win.loadURL(url);
 }
+// Show-after-restart registration that runs THIS electron binary on electron-main.js directly — no node
+// PATH dependency. Mirrors what `echomem-hud autostart on` writes, so CLI and menu stay in sync.
+function setAutostart(on) {
+    if (on)
+        enableAutostart([process.execPath, fileURLPath("./electron-main.js"), "--client", String(mode), "--port", String(port)]);
+    else
+        disableAutostart();
+}
+// Quitting is the moment the HUD truly disappears (unlike "Hide for now"), so if it won't come back on
+// its own, that's exactly when to offer show-after-restart — per the user's "ask me when it goes away".
+function quitWithAutostartPrompt(win) {
+    if (process.platform !== "darwin" || isAutostartEnabled())
+        return void app.quit();
+    const choice = showRecoveryPrompt({
+        buttons: ["Show after restart & quit", "Just quit", "Cancel"],
+        cancelId: 2,
+        message: "Bring EchoMem back automatically?",
+        detail: "EchoMem has no app icon to relaunch from. Turn on Show after restart and it will be waiting after your computer restarts. You can also tell your coding agent to run `echomem-hud app`.",
+    });
+    if (choice === 2)
+        return;
+    if (choice === 0)
+        setAutostart(true);
+    app.quit();
+}
 function clampExpandedHeight(value) {
     const workArea = screen.getPrimaryDisplay().workArea;
     const max = Math.max(COLLAPSED_HEIGHT, workArea.height - 48);
@@ -166,11 +232,11 @@ function clampExpandedHeight(value) {
 function showExistingWindow() {
     if (!mainWindow || mainWindow.isDestroyed())
         return;
-    if (!mainWindow.isVisible())
-        mainWindow.show();
-    mainWindow.moveTop();
-    app.focus({ steal: true });
-    mainWindow.focus();
+    manuallyHidden = false;
+    if (onlyShowWhenAgentOpen)
+        syncAgentVisibility(mainWindow);
+    else
+        showHudWindow(mainWindow, true);
 }
 async function hasCompatibleHudState(baseUrl, requestedMode) {
     const signal = AbortSignal.timeout(750);
@@ -244,7 +310,104 @@ function clamp(value, min, max) {
 function writeBounds(win) {
     const b = win.getBounds();
     fs.mkdirSync(path.dirname(boundsPath()), { recursive: true });
-    fs.writeFileSync(boundsPath(), JSON.stringify(b, null, 2));
+    fs.writeFileSync(boundsPath(), JSON.stringify({ ...b, mini: miniPref, onlyShowWhenAgentOpen }, null, 2));
+}
+function hideForNow(win) {
+    if (win.isDestroyed())
+        return;
+    if (process.platform === "darwin" && !isAutostartEnabled()) {
+        const choice = showRecoveryPrompt({
+            buttons: ["Show after restart & hide", "Hide for now", "Cancel"],
+            cancelId: 2,
+            message: "Hide EchoMem for now?",
+            detail: "It will stay hidden until you restart it. Turn on Show after restart to bring it back after your computer restarts. Before then, you can ask your coding agent to run `echomem-hud app`.",
+        });
+        if (choice === 2)
+            return;
+        if (choice === 0)
+            setAutostart(true);
+    }
+    manuallyHidden = true;
+    win.hide();
+}
+function showRecoveryPrompt(options) {
+    app.focus({ steal: true });
+    const cancelId = typeof options.cancelId === "number" ? options.cancelId : options.buttons.length - 1;
+    const { cancelId: _cancelId, ...dialogOptions } = options;
+    return dialog.showMessageBoxSync({
+        type: "question",
+        defaultId: 0,
+        cancelId,
+        icon: nativeImage.createFromPath(fileURLPath("../../assets/hud/echo-face-cutout.png")),
+        ...dialogOptions,
+    });
+}
+function setOnlyShowWhenAgentOpen(next, win) {
+    onlyShowWhenAgentOpen = next;
+    manuallyHidden = false;
+    writeBounds(win);
+    if (next)
+        syncAgentVisibility(win);
+    else
+        showHudWindow(win, true);
+}
+function startAgentVisibilityLoop(win) {
+    stopAgentVisibilityLoop();
+    visibilityTimer = setInterval(() => syncAgentVisibility(win), AGENT_VISIBILITY_POLL_MS);
+}
+function stopAgentVisibilityLoop() {
+    if (!visibilityTimer)
+        return;
+    clearInterval(visibilityTimer);
+    visibilityTimer = null;
+}
+function syncAgentVisibility(win) {
+    if (win.isDestroyed() || !onlyShowWhenAgentOpen)
+        return;
+    const frontmost = frontmostAppKind();
+    if (frontmost === "agent") {
+        if (!manuallyHidden && !win.isVisible())
+            showHudWindow(win, false);
+        else if (!manuallyHidden)
+            win.moveTop();
+        return;
+    }
+    // Leave the HUD alone while the user is interacting with the HUD/menu itself, or when macOS does
+    // not report a frontmost process. The next concrete app detection will settle visibility.
+    if (frontmost === "self" || frontmost === "unknown")
+        return;
+    if (win.isVisible())
+        win.hide();
+}
+function showHudWindow(win, focus) {
+    if (win.isDestroyed())
+        return;
+    if (focus) {
+        app.focus({ steal: true });
+        win.show();
+        win.focus();
+    }
+    else {
+        win.showInactive();
+    }
+    win.moveTop();
+}
+function frontmostAppKind() {
+    if (process.platform !== "darwin")
+        return "unknown";
+    try {
+        const name = execFileSync("osascript", ["-e", 'tell application "System Events" to get name of first application process whose frontmost is true'], { encoding: "utf8", timeout: 500, stdio: ["ignore", "pipe", "ignore"] }).trim().toLowerCase();
+        if (!name)
+            return "unknown";
+        if (name.includes("codex") || name.includes("claude"))
+            return "agent";
+        if (name.includes("echomem") || name.includes("electron") || name === app.getName().toLowerCase())
+            return "self";
+        return "other";
+    }
+    catch {
+        return "unknown";
+    }
 }
 function dragPoint(payload) {
     const startX = typeof payload.screenX === "number" && Number.isFinite(payload.screenX) ? payload.screenX : null;

package/dist/hud/monitor.js

@@ -6,7 +6,6 @@ import { adapterList, adapters } from "./adapters.js";
 import { homePath, newestFile, walkFiles } from "./fs.js";
 const LIVE_WINDOW_MS = 45_000;
 const ONGOING_WINDOW_MS = 300_000; // a thread counts as "ongoing" if its log was written in the last 5 min
-const FOCUS_GRACE_MS = 8_000; // keep the last-known frontmost client this long when detection momentarily misses
 const RECENT_WINDOW_MS = 12 * 60 * 60 * 1000; // a session is a "recent tab" if its log was touched in the last 12h
 const RECENT_CAP = 16; // most-recent N sessions kept as switchable tabs
 export class HudMonitor extends EventEmitter {
@@ -19,7 +18,6 @@ export class HudMonitor extends EventEmitter {
     labelCache = new Map();
     missing = [];
     frontmostCheckedAt = 0;
-    frontmostSeenAt = 0;
     frontmostClient = null;
     lastActiveClient = null;
     threadCounts = {};
@@ -65,17 +63,13 @@ export class HudMonitor extends EventEmitter {
                 lastActiveMs,
             };
         });
-        // focused first, then live (most-recent first), then idle (most-recent first).
-        sessions.sort((a, b) => {
-            if (a.focused !== b.focused)
-                return a.focused ? -1 : 1;
-            if (a.live !== b.live)
-                return a.live ? -1 : 1;
-            return a.lastActiveMs - b.lastActiveMs;
-        });
+        // The user's foreground agent is the primary truth. Background agents can keep writing logs, but
+        // they should never steal the main HUD away from Codex/Claude while that app is what the user opened.
+        sessions.sort((a, b) => hudSelectionRank(a) - hudSelectionRank(b) || a.lastActiveMs - b.lastActiveMs);
         // A user-pinned tab overrides auto-selection: it becomes the primary and never flips away.
         const pinned = this.pinnedView(now);
         const ordered = pinned ? [pinned, ...sessions.filter((s) => s.sourcePath !== pinned.sourcePath)] : sessions;
+        const pinnedId = pinned ? this.pinnedId : null;
         return {
             mode: this.mode,
             active: ordered[0] || null,
@@ -83,6 +77,7 @@ export class HudMonitor extends EventEmitter {
             sessions: ordered,
             threadCounts: this.threadCounts,
             recentSessions: this.recentSessions,
+            pinnedId,
             missing: this.missing,
             updatedAt: new Date().toISOString(),
         };
@@ -139,13 +134,6 @@ export class HudMonitor extends EventEmitter {
             if (detected) {
                 // Positive detection wins immediately (real focus switch, e.g. Codex → Claude Desktop).
                 this.frontmostClient = detected;
-                this.frontmostSeenAt = now;
-            }
-            else if (now - this.frontmostSeenAt > FOCUS_GRACE_MS) {
-                // Detection missed (osascript timeout, or a non-agent app like a browser is front). Hold the
-                // last-known focus for a grace window so the active slot doesn't flip to a background client
-                // just because it's writing — then release once the grace expires.
-                this.frontmostClient = null;
             }
         }
         return this.frontmostClient && this.scores.has(this.frontmostClient) ? this.frontmostClient : null;
@@ -213,60 +201,15 @@ export class HudMonitor extends EventEmitter {
                 return title;
         }
         else {
-            const title = this.claudeTitle(file);
-            if (title)
-                return title;
+            const cached = this.claudeTitleCache.get(file);
+            if (cached !== undefined)
+                return cached;
+            const title = claudeDisplayTitle(file, client);
+            this.claudeTitleCache.set(file, title);
+            return title;
         }
         return sessionLabel(file, client); // repo/cwd basename fallback
     }
-    // Claude has no title index, so derive one from the thread's first real user message (cached per file
-    // — the first message never changes). Distinguishes two threads in the same repo.
-    claudeTitle(file) {
-        const cached = this.claudeTitleCache.get(file);
-        if (cached !== undefined)
-            return cached;
-        let title = "";
-        try {
-            const fd = fs.openSync(file, "r");
-            try {
-                const buf = Buffer.alloc(64 * 1024);
-                const bytes = fs.readSync(fd, buf, 0, buf.length, 0);
-                for (const line of buf.toString("utf8", 0, bytes).split("\n")) {
-                    if (!line.includes('"user"'))
-                        continue;
-                    let obj;
-                    try {
-                        obj = JSON.parse(line);
-                    }
-                    catch {
-                        continue; // partial/last line
-                    }
-                    if (!isRecord(obj) || obj.type !== "user")
-                        continue;
-                    const message = isRecord(obj.message) ? obj.message : null;
-                    const content = message ? message.content : undefined;
-                    let body = "";
-                    if (typeof content === "string")
-                        body = content;
-                    else if (Array.isArray(content))
-                        body = content.map((b) => (isRecord(b) && typeof b.text === "string" ? b.text : "")).join(" ");
-                    body = body.replace(/\s+/g, " ").trim();
-                    if (!body || body.startsWith("<") || /^#\s*claudeMd\b/i.test(body) || body.startsWith("Caveat:"))
-                        continue;
-                    title = body.length > 48 ? `${body.slice(0, 47)}…` : body;
-                    break;
-                }
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-        }
-        catch {
-            /* unreadable → falls back to repo label */
-        }
-        this.claudeTitleCache.set(file, title);
-        return title;
-    }
     // Codex writes a lightweight index of every thread (id + human title). Load it (mtime-cached) so tabs
     // show real titles like "Verify file state" instead of a UUID.
     loadCodexTitles() {
@@ -360,6 +303,18 @@ export class HudMonitor extends EventEmitter {
             this.emit("state", this.snapshot());
     }
 }
+export function hudSelectionRank(session) {
+    if (session.focused)
+        return 0;
+    if (session.live)
+        return 1;
+    return 2;
+}
+export function claudeDisplayTitle(file, client) {
+    const label = sessionLabel(file, client);
+    const stamp = sessionTimeLabel(resolveClaudeTranscript(file) ?? file);
+    return label === defaultLabel(client) ? stamp : `${label} · ${stamp}`;
+}
 function detectFrontmostClient() {
     if (process.platform !== "darwin")
         return null;
@@ -400,6 +355,19 @@ function sessionLabel(file, client) {
     const cwd = peekCwd(target);
     return cwd ? path.basename(cwd) : defaultLabel(client);
 }
+function sessionTimeLabel(file) {
+    try {
+        const date = new Date(fs.statSync(file).mtimeMs);
+        const month = String(date.getMonth() + 1).padStart(2, "0");
+        const day = String(date.getDate()).padStart(2, "0");
+        const hour = String(date.getHours()).padStart(2, "0");
+        const minute = String(date.getMinutes()).padStart(2, "0");
+        return `${month}/${day} ${hour}:${minute}`;
+    }
+    catch {
+        return sessionIdFromPath(file).slice(0, 8) || "session";
+    }
+}
 // The Claude Code active source is the echo-ctx cache (<sessionId>.json), whose mtime only bumps when
 // the statusline re-renders — stale during a long turn. The transcript grows every tool call, so it's
 // the true liveness signal. Take the fresher of the two. Cached per cache-file (paths are stable).

package/dist/hud/preload.cjs

@@ -7,6 +7,9 @@ electron_1.contextBridge.exposeInMainWorld("echomemHud", {
     setOpen(open, height) {
         electron_1.ipcRenderer.send("hud:set-open", { open, height });
     },
+    setMini(mini) {
+        electron_1.ipcRenderer.send("hud:set-mini", { mini });
+    },
     startDrag(screenX, screenY) {
         electron_1.ipcRenderer.send("hud:drag-start", { screenX, screenY });
     },