aimux-cli 0.1.13 → 0.1.14

package/dist/metadata-server.js

@@ -1,7 +1,8 @@
 import { createServer } from "node:http";
 import { createHash } from "node:crypto";
 import { readFileSync, writeFileSync } from "node:fs";
-import { getDashboardUiStatePath, getProjectId, getProjectStateDir } from "./paths.js";
+import { basename } from "node:path";
+import { getDashboardClientUiStatePath, getProjectId, getProjectStateDir } from "./paths.js";
 import { updateSessionMetadata, clearSessionLogs, saveMetadataEndpoint, loadMetadataState, } from "./metadata-store.js";
 import { notifyAlert } from "./notify.js";
 import { clearNotifications, listNotifications, markNotificationsRead, unreadNotificationCount, } from "./notifications.js";
@@ -21,17 +22,129 @@ import { listSwitchableAgentItems, resolveAttentionAgent, resolveNextAgent, reso
 import { TmuxRuntimeManager } from "./tmux/runtime-manager.js";
 import { openTargetForClient } from "./tmux/window-open.js";
 import { getDashboardCommandSpec } from "./dashboard/command-spec.js";
-function persistDashboardScreenPreference(screen) {
+function compactSessionId(sessionId) {
+    const compact = sessionId.replace(/-[a-z0-9]{4,}$/i, "");
+    return compact || sessionId;
+}
+function metadataDisplayContext(metadata) {
+    return {
+        label: metadata?.label,
+        worktreePath: metadata?.context?.worktreePath,
+        worktreeName: metadata?.context?.worktreeName,
+        branch: metadata?.context?.branch,
+    };
+}
+function mergeDisplayContext(base, override) {
+    return {
+        label: override.label ?? base.label,
+        command: override.command ?? base.command,
+        worktreePath: override.worktreePath ?? base.worktreePath,
+        worktreeName: override.worktreeName ?? base.worktreeName,
+        branch: override.branch ?? base.branch,
+    };
+}
+function displayWorktreeLabel(context) {
+    const worktreeName = context.worktreeName?.trim();
+    const branch = context.branch?.trim();
+    if (worktreeName)
+        return worktreeName;
+    if (branch)
+        return branch;
+    const path = context.worktreePath?.trim();
+    return path ? basename(path) : undefined;
+}
+function sessionAlertSubject(sessionId, context) {
+    if (!sessionId)
+        return undefined;
+    const label = context?.label?.trim() || context?.command?.trim() || compactSessionId(sessionId);
+    const worktree = context ? displayWorktreeLabel(context) : undefined;
+    return worktree ? `${label} @ ${worktree}` : label;
+}
+function sessionAlertTitle(kind, sessionId, fallback, context) {
+    const title = fallback?.trim();
+    const subject = sessionAlertSubject(sessionId, context);
+    if (!subject)
+        return title || "aimux";
+    if (kind === "needs_input")
+        return `${subject} needs input`;
+    if (kind === "blocked") {
+        if (!title || (sessionId && title === `${sessionId} is blocked`))
+            return `${subject} is blocked`;
+        return title;
+    }
+    if (kind === "task_failed") {
+        if (!title || (sessionId && title === `${sessionId} errored`))
+            return `${subject} errored`;
+        return title;
+    }
+    if (kind === "task_done") {
+        if (!title || (sessionId && title === `${sessionId} finished`))
+            return `${subject} finished`;
+        return title;
+    }
+    if (!title)
+        return subject;
+    if (title.includes(subject))
+        return title;
+    if (sessionId && title.includes(sessionId))
+        return title.replace(sessionId, subject);
+    return `${subject}: ${title}`;
+}
+function dashboardClientKeyFromSession(sessionName) {
+    return sessionName.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function persistDashboardClientPreference(clientSession, update) {
+    const path = getDashboardClientUiStatePath(dashboardClientKeyFromSession(clientSession));
+    let snapshot = {};
     try {
-        const path = getDashboardUiStatePath();
-        const raw = readFileSync(path, "utf-8");
-        const snapshot = JSON.parse(raw);
-        snapshot.screen = screen;
-        writeFileSync(path, JSON.stringify(snapshot, null, 2) + "\n");
+        snapshot = JSON.parse(readFileSync(path, "utf-8"));
     }
-    catch {
-        writeFileSync(getDashboardUiStatePath(), JSON.stringify({ screen }, null, 2) + "\n");
+    catch { }
+    update(snapshot);
+    writeFileSync(path, JSON.stringify(snapshot, null, 2) + "\n");
+}
+function persistDashboardReturnSelection(tmux, projectRoot, currentClientSession, currentWindowId) {
+    persistDashboardClientPreference(currentClientSession, (snapshot) => {
+        snapshot.screen = "dashboard";
+        if (!currentWindowId)
+            return;
+        const match = tmux
+            .listProjectManagedWindows(projectRoot)
+            .find((entry) => entry.target.windowId === currentWindowId);
+        if (!match)
+            return;
+        snapshot.focusedWorktreePath = match.metadata.worktreePath;
+        snapshot.level = "sessions";
+        snapshot.selectedEntryKind = match.metadata.kind === "service" ? "service" : "session";
+        snapshot.selectedEntryId = match.metadata.sessionId;
+    });
+}
+function markActiveWindowFocused(tmux, projectRoot, currentClientSession, currentWindow, currentWindowId, tracker) {
+    if (currentWindow && /^dashboard/.test(currentWindow)) {
+        updateNotificationContext("tui", {
+            focused: true,
+            screen: "dashboard",
+            panelOpen: false,
+            sessionId: undefined,
+        });
+        return true;
     }
+    if (!currentWindowId)
+        return false;
+    const match = tmux.listProjectManagedWindows(projectRoot).find((entry) => entry.target.windowId === currentWindowId);
+    if (!match)
+        return false;
+    updateNotificationContext("tui", {
+        focused: true,
+        sessionId: match.metadata.sessionId,
+        panelOpen: false,
+    });
+    if (match.metadata.kind === "agent") {
+        tracker.markSeen(match.metadata.sessionId);
+        markNotificationsRead({ sessionId: match.metadata.sessionId });
+    }
+    markTargetUsed(tmux, projectRoot, match.target, currentClientSession, match.metadata.sessionId);
+    return true;
 }
 function markTargetUsed(tmux, projectRoot, target, currentClientSession, itemId) {
     const resolvedItemId = itemId ||
@@ -144,7 +257,26 @@ export class MetadataServer {
         });
     }
     emitAlert(input) {
-        this.eventBus.publishAlert(input);
+        const displayContext = this.resolveSessionAlertDisplayContext(input.sessionId, input.worktreePath);
+        this.eventBus.publishAlert({
+            ...input,
+            title: sessionAlertTitle(input.kind, input.sessionId, input.title, displayContext),
+            worktreePath: input.worktreePath ?? displayContext?.worktreePath,
+        });
+    }
+    resolveSessionAlertDisplayContext(sessionId, worktreePath) {
+        if (!sessionId)
+            return worktreePath ? { worktreePath } : undefined;
+        let context = {};
+        try {
+            context = metadataDisplayContext(loadMetadataState().sessions[sessionId]);
+        }
+        catch { }
+        const liveContext = this.options.desktop?.getSessionDisplayContext?.(sessionId);
+        context = mergeDisplayContext(context, liveContext ?? {});
+        if (worktreePath)
+            context.worktreePath = worktreePath;
+        return Object.values(context).some((value) => value !== undefined) ? context : undefined;
     }
     emitThreadWaitingAlert(input) {
         for (const recipient of [...new Set((input.recipients ?? []).map((value) => value?.trim()).filter(Boolean))]) {
@@ -371,7 +503,11 @@ export class MetadataServer {
                 send(res, 501, { ok: false, error: "graveyard listing not supported by this service" });
                 return;
             }
-            send(res, 200, { ok: true, entries: this.options.desktop.listGraveyard() });
+            send(res, 200, {
+                ok: true,
+                entries: this.options.desktop.listGraveyard(),
+                worktrees: this.options.desktop.listWorktreeGraveyard?.() ?? [],
+            });
             return;
         }
         if (req.method === "GET" && url.pathname === "/threads") {
@@ -525,10 +661,12 @@ export class MetadataServer {
                     : {};
                 const currentClientSession = body.currentClientSession?.trim() || url.searchParams.get("currentClientSession")?.trim() || undefined;
                 const clientTty = body.clientTty?.trim() || url.searchParams.get("clientTty")?.trim() || undefined;
+                const currentWindowId = body.currentWindowId?.trim() || url.searchParams.get("currentWindowId")?.trim() || undefined;
                 if (!currentClientSession) {
                     send(res, 400, { ok: false, error: "currentClientSession is required" });
                     return;
                 }
+                persistDashboardReturnSelection(new TmuxRuntimeManager(), process.cwd(), currentClientSession, currentWindowId);
                 const tmux = new TmuxRuntimeManager();
                 const { dashboardCommand, dashboardBuildStamp } = getDashboardCommandSpec(process.cwd());
                 const dashboardSession = tmux.ensureProjectSession(process.cwd(), dashboardCommand);
@@ -555,7 +693,9 @@ export class MetadataServer {
                     send(res, 400, { ok: false, error: "currentClientSession is required" });
                     return;
                 }
-                persistDashboardScreenPreference("notifications");
+                persistDashboardClientPreference(currentClientSession, (snapshot) => {
+                    snapshot.screen = "notifications";
+                });
                 const tmux = new TmuxRuntimeManager();
                 const { dashboardCommand, dashboardBuildStamp } = getDashboardCommandSpec(process.cwd());
                 const dashboardSession = tmux.ensureProjectSession(process.cwd(), dashboardCommand);
@@ -674,6 +814,23 @@ export class MetadataServer {
                 send(res, 200, { ok: true });
                 return;
             }
+            if ((req.method === "GET" || req.method === "POST") && url.pathname === "/control/active-window") {
+                const body = req.method === "POST"
+                    ? (await readJson(req))
+                    : {};
+                const currentClientSession = body.currentClientSession?.trim() || url.searchParams.get("currentClientSession")?.trim() || undefined;
+                const currentWindow = body.currentWindow?.trim() || url.searchParams.get("currentWindow")?.trim() || undefined;
+                const currentWindowId = body.currentWindowId?.trim() || url.searchParams.get("currentWindowId")?.trim() || undefined;
+                const tmux = new TmuxRuntimeManager();
+                const ok = markActiveWindowFocused(tmux, process.cwd(), currentClientSession, currentWindow, currentWindowId, this.tracker);
+                if (!ok) {
+                    send(res, 404, { ok: false, error: "window not found" });
+                    return;
+                }
+                this.options.onChange?.();
+                send(res, 200, { ok: true });
+                return;
+            }
             if ((req.method === "GET" || req.method === "POST") && url.pathname === "/control/switch-next") {
                 const body = req.method === "POST"
                     ? (await readJson(req))
@@ -798,6 +955,46 @@ export class MetadataServer {
             if (req.method === "POST" && url.pathname === "/event") {
                 const body = (await readJson(req));
                 this.tracker.emit(body.session, body.event);
+                if (body.event.kind === "needs_input") {
+                    this.emitAlert({
+                        kind: "needs_input",
+                        sessionId: body.session,
+                        title: `${body.session} needs input`,
+                        message: body.event.message || "Agent is waiting for input.",
+                        dedupeKey: `needs_input:${body.session}`,
+                        cooldownMs: 15_000,
+                    });
+                }
+                else if (body.event.kind === "blocked") {
+                    this.emitAlert({
+                        kind: "blocked",
+                        sessionId: body.session,
+                        title: `${body.session} is blocked`,
+                        message: body.event.message || "Agent reported a blocked state.",
+                        dedupeKey: `blocked:${body.session}`,
+                        cooldownMs: 15_000,
+                    });
+                }
+                else if (body.event.kind === "task_failed" || body.event.tone === "error") {
+                    this.emitAlert({
+                        kind: "task_failed",
+                        sessionId: body.session,
+                        title: `${body.session} errored`,
+                        message: body.event.message || "Agent reported an error state.",
+                        dedupeKey: `error:${body.session}`,
+                        cooldownMs: 15_000,
+                    });
+                }
+                else if (body.event.kind === "notify") {
+                    this.emitAlert({
+                        kind: "notification",
+                        sessionId: body.session,
+                        title: sessionAlertTitle("notification", body.session, body.event.source),
+                        message: body.event.message || "Agent notification.",
+                        dedupeKey: body.event.message ? `notify:${body.session}:${body.event.message}` : undefined,
+                        cooldownMs: 15_000,
+                    });
+                }
                 this.options.onChange?.();
                 send(res, 200, { ok: true });
                 return;
@@ -880,14 +1077,26 @@ export class MetadataServer {
                                             : requestedKind === "review_waiting"
                                                 ? "review_waiting"
                                                 : "needs_input";
+                const sessionId = body.sessionId?.trim() || undefined;
+                const dedupeKey = body.force
+                    ? undefined
+                    : kind === "needs_input" && sessionId
+                        ? `needs_input:${sessionId}`
+                        : kind === "blocked" && sessionId
+                            ? `blocked:${sessionId}`
+                            : kind === "task_failed" && sessionId
+                                ? `error:${sessionId}`
+                                : kind === "task_done"
+                                    ? `notify:complete:${body.title ?? body.message ?? "aimux"}`
+                                    : undefined;
                 this.emitAlert({
                     kind,
-                    sessionId: body.sessionId?.trim() || undefined,
-                    title: body.title?.trim() || "aimux",
+                    sessionId,
+                    title: sessionAlertTitle(kind, sessionId, body.title),
                     message: [body.subtitle?.trim(), body.message?.trim() || body.title?.trim() || "aimux"]
                         .filter(Boolean)
                         .join(" — "),
-                    dedupeKey: kind === "task_done" ? `notify:complete:${body.title ?? body.message ?? "aimux"}` : undefined,
+                    dedupeKey,
                     forceNotify: Boolean(body.force),
                 });
                 send(res, 200, { ok: true });
@@ -1186,6 +1395,17 @@ export class MetadataServer {
                 send(res, 200, { ok: true, ...result });
                 return;
             }
+            if (req.method === "POST" && url.pathname === "/agents/resume") {
+                const body = (await readJson(req));
+                if (!this.options.desktop?.resumeAgent) {
+                    send(res, 501, { ok: false, error: "agent resume not supported by this service" });
+                    return;
+                }
+                const result = await this.options.desktop.resumeAgent(body);
+                this.options.onChange?.();
+                send(res, 200, { ok: true, ...result });
+                return;
+            }
             if (req.method === "POST" && url.pathname === "/agents/interrupt") {
                 const body = (await readJson(req));
                 if (!this.options.lifecycle?.interruptAgent) {
@@ -1204,6 +1424,10 @@ export class MetadataServer {
                     return;
                 }
                 const result = await this.options.lifecycle.renameAgent(body);
+                updateSessionMetadata(body.sessionId, (current) => ({
+                    ...current,
+                    label: body.label?.trim() || undefined,
+                }));
                 this.options.onChange?.();
                 send(res, 200, { ok: true, ...result });
                 return;
@@ -1382,6 +1606,17 @@ export class MetadataServer {
                 send(res, 202, { ok: true, path: body.path, status: "removing" });
                 return;
             }
+            if (req.method === "POST" && url.pathname === "/worktrees/graveyard") {
+                const body = (await readJson(req));
+                if (!this.options.desktop?.graveyardWorktree) {
+                    send(res, 501, { ok: false, error: "worktree graveyard not supported by this service" });
+                    return;
+                }
+                const result = await this.options.desktop.graveyardWorktree(body);
+                this.options.onChange?.();
+                send(res, 200, { ok: true, ...result });
+                return;
+            }
             if (req.method === "POST" && url.pathname === "/services/create") {
                 const body = (await readJson(req));
                 if (!this.options.desktop?.createService) {
@@ -1437,6 +1672,28 @@ export class MetadataServer {
                 send(res, 200, { ok: true, ...result });
                 return;
             }
+            if (req.method === "POST" && url.pathname === "/graveyard/worktrees/resurrect") {
+                const body = (await readJson(req));
+                if (!this.options.desktop?.resurrectGraveyardWorktree) {
+                    send(res, 501, { ok: false, error: "worktree graveyard resurrect not supported by this service" });
+                    return;
+                }
+                const result = await this.options.desktop.resurrectGraveyardWorktree(body);
+                this.options.onChange?.();
+                send(res, 200, { ok: true, ...result });
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/graveyard/worktrees/delete") {
+                const body = (await readJson(req));
+                if (!this.options.desktop?.deleteGraveyardWorktree) {
+                    send(res, 501, { ok: false, error: "worktree graveyard delete not supported by this service" });
+                    return;
+                }
+                const result = await this.options.desktop.deleteGraveyardWorktree(body);
+                this.options.onChange?.();
+                send(res, 200, { ok: true, ...result });
+                return;
+            }
             if (req.method === "POST" && url.pathname === "/reviews/approve") {
                 const body = (await readJson(req));
                 const result = this.options.actions?.approveReview