aimux-cli 0.1.1 → 0.1.2

package/dist/main.js

@@ -1,5 +1,5 @@
 import { Command } from "commander";
-import { existsSync, readFileSync, writeFileSync, readdirSync, copyFileSync, mkdirSync, chmodSync, statSync, } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, readdirSync, copyFileSync, mkdirSync, chmodSync } from "node:fs";
 import { join as pathJoin, resolve as pathResolve, dirname as pathDirname } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
@@ -21,6 +21,8 @@ import { acceptHandoff, approveReview, acceptTask, assignTask, blockTask, comple
 import { addNotification, clearNotifications, listNotifications, markNotificationsRead, unreadNotificationCount, } from "./notifications.js";
 import { parseClaudeHookPayload, summarizeClaudeNotification, summarizeClaudeStop } from "./claude-hooks.js";
 import { requestJson } from "./http-client.js";
+import { runTmuxSwitcher } from "./tmux-switcher.js";
+import { findLiveDashboardTarget, getDashboardCommandSpec, openDashboardTarget, pruneDashboardArtifacts, resolveDashboardTarget, } from "./dashboard-targets.js";
 const program = new Command();
 class ProjectServiceVersionError extends Error {
     projectRoot;
@@ -58,7 +60,7 @@ async function restartStaleControlPlane(projectRoot) {
     await ensureDaemonRunning();
     await ensureProjectService(projectRoot);
     const { dashboardBuildStamp } = getDashboardCommandSpec(projectRoot);
-    pruneDashboardArtifacts(projectRoot, dashboardBuildStamp);
+    pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, new TmuxRuntimeManager());
 }
 async function fetchProjectServiceHealth(endpoint) {
     const { status, json } = await requestJson(`http://${endpoint.host}:${endpoint.port}/health`);
@@ -217,7 +219,10 @@ async function ensureDaemonProjectReady(projectRoot, opts) {
         await waitForVerifiedProjectService(projectRoot);
     }
     catch (error) {
-        if (!(error instanceof ProjectServiceVersionError) || opts?.repairVersionDrift === false) {
+        if (opts?.repairVersionDrift === false) {
+            throw error;
+        }
+        if (!(error instanceof ProjectServiceVersionError) && !(error instanceof Error)) {
             throw error;
         }
         await restartStaleControlPlane(projectRoot);
@@ -242,203 +247,6 @@ function ensureTmuxAvailable(tmux) {
         process.exit(1);
     }
 }
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'"'"'`)}'`;
-}
-function getDashboardCommandSpec(projectRoot) {
-    const scriptPath = fileURLToPath(import.meta.url);
-    const wrappedDashboardCommand = [
-        "set -o pipefail",
-        ";",
-        shellQuote(process.execPath),
-        shellQuote(scriptPath),
-        "--tmux-dashboard-internal",
-        "2>&1",
-        "|",
-        "tee",
-        "-a",
-        shellQuote("/tmp/aimux-debug.log"),
-        ";",
-        "code=$?",
-        ";",
-        "if",
-        "[",
-        "$code",
-        "-ne",
-        "0",
-        "]",
-        ";",
-        "then",
-        "printf",
-        "'\\033[?1049l\\033[H\\033[2J'",
-        ";",
-        "printf",
-        "%s\\n%s\\n%s\\n%s\\n",
-        shellQuote(""),
-        shellQuote("aimux dashboard failed to start."),
-        shellQuote("The error above was captured from the dashboard process."),
-        shellQuote("Press q, Enter, or Ctrl+C to close this pane."),
-        ";",
-        "while",
-        "IFS= read -rsn1 key",
-        ";",
-        "do",
-        "if",
-        "[",
-        "-z",
-        '"$key"',
-        "]",
-        "||",
-        "[",
-        '"$key"',
-        "=",
-        shellQuote("q"),
-        "]",
-        ";",
-        "then",
-        "exit 0",
-        ";",
-        "fi",
-        ";",
-        "done",
-        ";",
-        "fi",
-    ].join(" ");
-    return {
-        scriptPath,
-        dashboardBuildStamp: String(statSync(scriptPath).mtimeMs),
-        dashboardCommand: {
-            cwd: projectRoot,
-            command: "bash",
-            args: ["-lc", wrappedDashboardCommand],
-        },
-    };
-}
-function ensureDashboardTarget(projectRoot, tmux = new TmuxRuntimeManager()) {
-    const { dashboardBuildStamp, dashboardCommand } = getDashboardCommandSpec(projectRoot);
-    pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, tmux);
-    const dashboardSession = tmux.ensureProjectSession(projectRoot, {
-        cwd: dashboardCommand.cwd,
-        command: dashboardCommand.command,
-        args: dashboardCommand.args,
-    });
-    const openSessionName = tmux.getOpenSessionName(dashboardSession.sessionName, tmux.isInsideTmux());
-    const dashboardTarget = tmux.ensureDashboardWindow(openSessionName, projectRoot, dashboardCommand);
-    const currentBuildStamp = tmux.getWindowOption(dashboardTarget, "@aimux-dashboard-build");
-    const shouldRespawnDashboard = !tmux.isWindowAlive(dashboardTarget) || currentBuildStamp !== dashboardBuildStamp;
-    if (shouldRespawnDashboard) {
-        tmux.respawnWindow(dashboardTarget, dashboardCommand);
-        tmux.setWindowOption(dashboardTarget, "@aimux-dashboard-build", dashboardBuildStamp);
-    }
-    return { dashboardSession, dashboardTarget };
-}
-function pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, tmux = new TmuxRuntimeManager()) {
-    const hostSession = tmux.getProjectSession(projectRoot).sessionName;
-    const sessions = tmux
-        .listSessionNames()
-        .filter((sessionName) => sessionName === hostSession || sessionName.startsWith(`${hostSession}-client-`));
-    for (const sessionName of sessions) {
-        const windows = tmux.listWindows(sessionName);
-        const dashboardWindows = windows.filter((window) => window.name.startsWith("dashboard"));
-        for (const window of dashboardWindows) {
-            const target = {
-                sessionName,
-                windowId: window.id,
-                windowIndex: window.index,
-                windowName: window.name,
-            };
-            const paneCommand = tmux.displayMessage("#{pane_current_command}", window.id);
-            const currentBuildStamp = tmux.getWindowOption(target, "@aimux-dashboard-build");
-            const invalid = !tmux.isWindowAlive(target) ||
-                paneCommand === "cat" ||
-                paneCommand === "tail" ||
-                !currentBuildStamp ||
-                currentBuildStamp !== dashboardBuildStamp;
-            if (!invalid)
-                continue;
-            try {
-                tmux.killWindow(target);
-            }
-            catch { }
-        }
-        if (sessionName === hostSession || !tmux.hasSession(sessionName))
-            continue;
-        const remaining = tmux.listWindows(sessionName);
-        const hasValidDashboard = remaining.some((window) => window.name.startsWith("dashboard"));
-        if (hasValidDashboard)
-            continue;
-        const hasNonDashboardWindows = remaining.some((window) => !window.name.startsWith("dashboard"));
-        if (hasNonDashboardWindows)
-            continue;
-        try {
-            tmux.killSession(sessionName);
-        }
-        catch { }
-    }
-}
-function getLiveDashboardTarget(projectRoot, tmux = new TmuxRuntimeManager()) {
-    const { dashboardBuildStamp } = getDashboardCommandSpec(projectRoot);
-    pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, tmux);
-    const dashboardSession = tmux.getProjectSession(projectRoot);
-    const isUsableDashboardTarget = (dashboardTarget) => {
-        const currentBuildStamp = tmux.getWindowOption(dashboardTarget, "@aimux-dashboard-build");
-        const paneCommand = tmux.displayMessage("#{pane_current_command}", dashboardTarget.windowId);
-        return tmux.isWindowAlive(dashboardTarget) && currentBuildStamp === dashboardBuildStamp && paneCommand !== "cat";
-    };
-    if (!tmux.hasSession(dashboardSession.sessionName)) {
-        return null;
-    }
-    const openSessionName = tmux.peekOpenSessionName(dashboardSession.sessionName, tmux.isInsideTmux());
-    if (!tmux.hasSession(openSessionName)) {
-        const candidateSessions = tmux
-            .listSessionNames()
-            .filter((sessionName) => sessionName === dashboardSession.sessionName ||
-            sessionName.startsWith(`${dashboardSession.sessionName}-client-`));
-        const candidates = candidateSessions
-            .flatMap((sessionName) => tmux
-            .listWindows(sessionName)
-            .filter((window) => window.name.startsWith("dashboard"))
-            .map((window) => ({
-            sessionName,
-            windowId: window.id,
-            windowIndex: window.index,
-            windowName: window.name,
-        })))
-            .filter(isUsableDashboardTarget);
-        if (candidates.length === 1) {
-            return { dashboardSession, dashboardTarget: candidates[0] };
-        }
-        return null;
-    }
-    const dashboardWindow = tmux.listWindows(openSessionName).find((window) => window.name.startsWith("dashboard"));
-    if (!dashboardWindow) {
-        return null;
-    }
-    const dashboardTarget = {
-        sessionName: openSessionName,
-        windowId: dashboardWindow.id,
-        windowIndex: dashboardWindow.index,
-        windowName: dashboardWindow.name,
-    };
-    if (!isUsableDashboardTarget(dashboardTarget)) {
-        return null;
-    }
-    return { dashboardSession, dashboardTarget };
-}
-function forceReloadDashboardTarget(projectRoot, tmux = new TmuxRuntimeManager()) {
-    const { dashboardBuildStamp, dashboardCommand } = getDashboardCommandSpec(projectRoot);
-    pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, tmux);
-    const dashboardSession = tmux.ensureProjectSession(projectRoot, {
-        cwd: dashboardCommand.cwd,
-        command: dashboardCommand.command,
-        args: dashboardCommand.args,
-    });
-    const openSessionName = tmux.getOpenSessionName(dashboardSession.sessionName, tmux.isInsideTmux());
-    const dashboardTarget = tmux.ensureDashboardWindow(openSessionName, projectRoot, dashboardCommand);
-    tmux.respawnWindow(dashboardTarget, dashboardCommand);
-    tmux.setWindowOption(dashboardTarget, "@aimux-dashboard-build", dashboardBuildStamp);
-    return { dashboardSession, dashboardTarget };
-}
 program
     .name("aimux")
     .description("Native CLI agent multiplexer")
@@ -479,7 +287,7 @@ program
         const tmux = new TmuxRuntimeManager();
         ensureTmuxAvailable(tmux);
         if (!tool && !opts.resume && !opts.restore) {
-            const liveDashboard = getLiveDashboardTarget(projectRoot, tmux);
+            const liveDashboard = findLiveDashboardTarget(projectRoot, tmux);
             if (liveDashboard) {
                 tmux.openTarget(liveDashboard.dashboardTarget, {
                     insideTmux: tmux.isInsideTmux(),
@@ -489,9 +297,8 @@ program
             }
         }
         await ensureDaemonProjectSpawned(projectRoot);
-        const { dashboardTarget } = ensureDashboardTarget(projectRoot, tmux);
         if (!tool && !opts.resume && !opts.restore) {
-            tmux.openTarget(dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
+            openDashboardTarget(projectRoot, tmux);
             return;
         }
     }
@@ -568,7 +375,7 @@ program
         await ensureDaemonProjectSpawned(projectRoot);
         const tmux = new TmuxRuntimeManager();
         ensureTmuxAvailable(tmux);
-        const { dashboardSession, dashboardTarget } = forceReloadDashboardTarget(projectRoot, tmux);
+        const { dashboardSession, dashboardTarget } = resolveDashboardTarget(projectRoot, tmux, { forceReload: true });
         if (opts.open) {
             tmux.openTarget(dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
             return;
@@ -690,7 +497,7 @@ hostCmd
     }
     const tmux = new TmuxRuntimeManager();
     ensureTmuxAvailable(tmux);
-    const { dashboardSession, dashboardTarget } = forceReloadDashboardTarget(projectRoot, tmux);
+    const { dashboardSession, dashboardTarget } = resolveDashboardTarget(projectRoot, tmux, { forceReload: true });
     if (opts.open) {
         tmux.openTarget(dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
         return;
@@ -1896,8 +1703,11 @@ program
     .action(async (sessionId, opts) => {
     try {
         const projectRoot = await prepareProjectContext(opts.project);
-        const mux = new Multiplexer();
-        const result = await mux.renameAgent(sessionId, opts.label);
+        await ensureDaemonProjectReady(projectRoot);
+        const result = await postLiveProjectServiceJsonOrLocal(projectRoot, "/agents/rename", { sessionId, label: opts.label }, () => {
+            const mux = new Multiplexer();
+            return mux.renameAgent(sessionId, opts.label);
+        });
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
@@ -1915,6 +1725,30 @@ program
         process.exit(1);
     }
 });
+program
+    .command("switcher")
+    .description("Internal tmux popup switcher")
+    .requiredOption("--project-root <path>", "Project root")
+    .requiredOption("--project-state-dir <path>", "Project state dir")
+    .option("--current-client-session <name>", "Current client session")
+    .option("--client-tty <tty>", "Client tty")
+    .option("--current-window <name>", "Current window name")
+    .option("--current-window-id <id>", "Current window id")
+    .option("--current-path <path>", "Current path")
+    .option("--pane-id <id>", "Current pane id")
+    .action(async (opts) => {
+    const code = await runTmuxSwitcher({
+        projectRoot: pathResolve(opts.projectRoot),
+        projectStateDir: pathResolve(opts.projectStateDir),
+        currentClientSession: opts.currentClientSession,
+        clientTty: opts.clientTty,
+        currentWindow: opts.currentWindow,
+        currentWindowId: opts.currentWindowId,
+        currentPath: opts.currentPath,
+        paneId: opts.paneId,
+    });
+    process.exit(code);
+});
 program
     .command("kill <sessionId>")
     .description("Send an agent to the graveyard from running or offline state")