aimux-cli 0.1.2 → 0.1.4

package/dist/main.js

@@ -5,13 +5,13 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { Multiplexer } from "./multiplexer.js";
 import { llmCompact } from "./context/compactor.js";
-import { initProject } from "./config.js";
+import { initProject, loadConfig } from "./config.js";
 import { initPaths, getHistoryDir, getGraveyardPath, getStatePath, getContextDir } from "./paths.js";
 import { loadTeamConfig, saveTeamConfig, getDefaultTeamConfig } from "./team.js";
 import { createWorktree, findMainRepo, listWorktrees } from "./worktree.js";
 import { TmuxRuntimeManager } from "./tmux-runtime-manager.js";
-import { buildTmuxDoctorReport, renderTmuxDoctorReport } from "./tmux-doctor.js";
-import { loadMetadataEndpoint, resolveProjectServiceEndpoint as resolveStoredProjectServiceEndpoint, updateSessionMetadata, clearSessionLogs, removeMetadataEndpoint, } from "./metadata-store.js";
+import { buildTmuxDoctorReport, renderTmuxDoctorReport, renderTmuxRepairResult, repairTmuxRuntime, } from "./tmux-doctor.js";
+import { loadMetadataEndpoint, loadMetadataState, resolveProjectServiceEndpoint as resolveStoredProjectServiceEndpoint, updateSessionMetadata, clearSessionLogs, removeMetadataEndpoint, } from "./metadata-store.js";
 import { AgentTracker } from "./agent-tracker.js";
 import { AimuxDaemon, ensureDaemonRunning, ensureProjectService, loadDaemonInfo, loadDaemonState, projectServiceStatus, requestDaemonJson, stopDaemon, stopProjectService, } from "./daemon.js";
 import { getProjectServiceManifest, manifestsMatch } from "./project-service-manifest.js";
@@ -37,7 +37,6 @@ class ProjectServiceVersionError extends Error {
     }
 }
 function renderProjectServiceVersionHelp(error) {
-    const quotedProject = JSON.stringify(error.projectRoot);
     const lines = [
         "aimux: the running project service is from a different local build.",
         "",
@@ -45,11 +44,11 @@ function renderProjectServiceVersionHelp(error) {
         `Expected build: ${error.expected.buildStamp}`,
         `Running build: ${error.actual?.buildStamp ?? "unknown"}`,
         "",
-        "Restart the daemon-managed control plane, then retry:",
-        `  aimux daemon restart`,
-        `  aimux daemon project-ensure --project ${quotedProject}`,
+        "Restart the project runtime, then retry:",
+        "  aimux restart-runtime --open",
         "",
-        "Or just restart the daemon and rerun `aimux` if you only changed this local checkout.",
+        "If the mismatch persists, use the advanced daemon restart path:",
+        "  aimux daemon restart",
     ];
     return lines.join("\n");
 }
@@ -233,6 +232,51 @@ async function ensureDaemonProjectSpawned(projectRoot) {
     await ensureDaemonRunning();
     await ensureProjectService(projectRoot);
 }
+function listManagedProjectSessionNames(tmux, projectRoot) {
+    const hostSession = tmux.getProjectSession(projectRoot).sessionName;
+    return tmux
+        .listSessionNames()
+        .filter((sessionName) => sessionName === hostSession || sessionName.startsWith(`${hostSession}-client-`))
+        .sort((a, b) => {
+        const aIsHost = a === hostSession ? 1 : 0;
+        const bIsHost = b === hostSession ? 1 : 0;
+        return aIsHost - bIsHost;
+    });
+}
+function stopProjectTmuxRuntime(tmux, projectRoot) {
+    const killed = [];
+    for (const sessionName of listManagedProjectSessionNames(tmux, projectRoot)) {
+        if (!tmux.hasSession(sessionName))
+            continue;
+        tmux.killSession(sessionName);
+        killed.push(sessionName);
+    }
+    return killed;
+}
+async function stopProjectRuntime(projectRoot) {
+    const projectService = await stopProjectService(projectRoot);
+    removeMetadataEndpoint(projectRoot);
+    const tmux = new TmuxRuntimeManager();
+    const tmuxSessionsKilled = tmux.isAvailable() ? stopProjectTmuxRuntime(tmux, projectRoot) : [];
+    return {
+        projectServiceStopped: Boolean(projectService),
+        tmuxSessionsKilled,
+    };
+}
+async function restartProjectRuntime(projectRoot, opts = {}) {
+    await stopProjectRuntime(projectRoot);
+    await ensureDaemonProjectSpawned(projectRoot);
+    const tmux = new TmuxRuntimeManager();
+    ensureTmuxAvailable(tmux);
+    const resolved = resolveDashboardTarget(projectRoot, tmux, { forceReload: true });
+    if (opts.open) {
+        tmux.openTarget(resolved.dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
+    }
+    return {
+        dashboardSessionName: resolved.dashboardSession.sessionName,
+        dashboardTarget: resolved.dashboardTarget,
+    };
+}
 function resolveProjectRoot(cwd) {
     try {
         return findMainRepo(cwd);
@@ -366,7 +410,7 @@ program
 });
 program
     .command("dashboard-reload")
-    .description("Force reload the managed tmux dashboard for this project")
+    .description("Recreate and optionally reopen the dashboard window only")
     .option("--open", "Open the dashboard after reloading")
     .action(async (opts) => {
     try {
@@ -392,10 +436,93 @@ program
         process.exit(1);
     }
 });
-const hostCmd = program.command("host").description("Compatibility wrappers for daemon-managed project services");
+program
+    .command("stop [sessionId]")
+    .description("Stop the current project runtime, or stop a specific running agent by session ID")
+    .option("--project <path>", "Project path")
+    .option("--json", "Emit JSON")
+    .action(async (sessionId, opts) => {
+    try {
+        if (sessionId) {
+            const projectRoot = await prepareProjectContext(opts.project);
+            const mux = new Multiplexer();
+            const result = await mux.stopAgent(sessionId);
+            if (opts.json) {
+                console.log(JSON.stringify({
+                    ok: true,
+                    projectRoot,
+                    sessionId: result.sessionId,
+                    status: result.status,
+                }, null, 2));
+                return;
+            }
+            console.log(`stopped ${result.sessionId}`);
+            return;
+        }
+        const projectRoot = resolveProjectRoot(opts.project ?? process.cwd());
+        await initPaths(projectRoot);
+        const result = await stopProjectRuntime(projectRoot);
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                projectRoot,
+                projectServiceStopped: result.projectServiceStopped,
+                tmuxSessionsKilled: result.tmuxSessionsKilled,
+            }, null, 2));
+            return;
+        }
+        console.log(`Stopped project runtime for ${projectRoot}`);
+        if (result.tmuxSessionsKilled.length > 0) {
+            console.log(`Removed tmux sessions: ${result.tmuxSessionsKilled.join(", ")}`);
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+});
+program
+    .command("restart-runtime")
+    .description("Hard restart the current project runtime and rebuild its managed tmux topology")
+    .option("--project-root <path>", "Project root", process.cwd())
+    .option("--open", "Open the dashboard after restarting the runtime")
+    .option("--json", "Emit JSON")
+    .action(async (opts) => {
+    try {
+        const projectRoot = resolveProjectRoot(opts.projectRoot);
+        await initPaths(projectRoot);
+        const result = await restartProjectRuntime(projectRoot, { open: opts.open });
+        if (opts.open)
+            return;
+        if (opts.json) {
+            console.log(JSON.stringify({
+                ok: true,
+                projectRoot,
+                dashboardSession: result.dashboardSessionName,
+                dashboardTarget: result.dashboardTarget,
+            }, null, 2));
+            return;
+        }
+        console.log(`Restarted project runtime for ${projectRoot}`);
+        console.log(`Dashboard: ${result.dashboardSessionName}:${result.dashboardTarget.windowIndex}`);
+    }
+    catch (err) {
+        if (err instanceof ProjectServiceVersionError) {
+            console.error(renderProjectServiceVersionHelp(err));
+            process.exit(1);
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`Error: ${msg}`);
+        process.exit(1);
+    }
+});
+const hostCmd = program
+    .command("host")
+    .description("Advanced compatibility wrappers for legacy daemon-managed project services");
 program
     .command("serve")
-    .description("Ensure the daemon-backed project control service is running")
+    .description("Advanced: ensure the legacy daemon-backed project control service is running")
     .action(async () => {
     const projectRoot = resolveProjectRoot(process.cwd());
     if (projectRoot !== process.cwd()) {
@@ -639,7 +766,7 @@ hostCmd
 hostCmd.action(() => {
     console.log("`aimux host` is a compatibility alias for daemon-managed project services.");
 });
-const daemonCmd = program.command("daemon").description("Manage the global aimux control-plane daemon");
+const daemonCmd = program.command("daemon").description("Advanced: manage the global aimux control-plane daemon");
 daemonCmd
     .command("run")
     .description("Internal daemon entrypoint")
@@ -1667,33 +1794,6 @@ graveyardCmd
         process.exit(1);
     }
 });
-program
-    .command("stop <sessionId>")
-    .description("Stop a running agent and move it to offline state")
-    .option("--project <path>", "Project path")
-    .option("--json", "Emit JSON")
-    .action(async (sessionId, opts) => {
-    try {
-        const projectRoot = await prepareProjectContext(opts.project);
-        const mux = new Multiplexer();
-        const result = await mux.stopAgent(sessionId);
-        if (opts.json) {
-            console.log(JSON.stringify({
-                ok: true,
-                projectRoot,
-                sessionId: result.sessionId,
-                status: result.status,
-            }, null, 2));
-            return;
-        }
-        console.log(`stopped ${result.sessionId}`);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`Error: ${msg}`);
-        process.exit(1);
-    }
-});
 program
     .command("rename <sessionId>")
     .description("Rename an agent label in running or offline state")
@@ -1808,10 +1908,11 @@ program
 });
 // ── Statusline commands ────────────────────────────────────────────
 const statuslineCmd = program.command("statusline").description("Manage Claude Code statusline integration");
-const doctorCmd = program.command("doctor").description("Inspect aimux runtime compatibility");
+const doctorCmd = program.command("doctor").description("Inspect aimux runtime state");
+const repairCmd = program.command("repair").description("Repair the current project runtime in place");
 doctorCmd
     .command("tmux")
-    .description("Inspect managed tmux session compatibility state")
+    .description("Inspect managed tmux runtime state")
     .option("--project-root <path>", "Project root", process.cwd())
     .option("--session <name>", "Managed tmux session name override")
     .option("--window-id <id>", "Specific tmux window id to inspect")
@@ -1830,6 +1931,28 @@ doctorCmd
     }
     console.log(renderTmuxDoctorReport(report));
 });
+repairCmd
+    .option("--project-root <path>", "Project root", process.cwd())
+    .option("--open", "Open the repaired dashboard after fixing runtime state")
+    .option("--json", "Emit JSON")
+    .action(async (opts) => {
+    const projectRoot = resolveProjectRoot(opts.projectRoot);
+    await initPaths(projectRoot);
+    await ensureDaemonProjectSpawned(projectRoot);
+    const tmux = new TmuxRuntimeManager();
+    ensureTmuxAvailable(tmux);
+    const result = repairTmuxRuntime(tmux, { projectRoot });
+    if (opts.open) {
+        const { dashboardTarget } = resolveDashboardTarget(projectRoot, tmux);
+        tmux.openTarget(dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
+        return;
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(renderTmuxRepairResult(result));
+});
 const metadataCmd = program.command("metadata").description("Push metadata into aimux tmux status integration");
 const metadataTracker = new AgentTracker();
 metadataCmd
@@ -2006,6 +2129,69 @@ program
     }
     console.log("OK");
 });
+program
+    .command("shell-hook <state>")
+    .description("Internal generic shell-state adapter modeled after cmux")
+    .requiredOption("--session <sessionId>", "Aimux session id")
+    .requiredOption("--project <path>", "Project path")
+    .option("--tool <tool>", "Tool label", "shell")
+    .option("--json", "Emit JSON output")
+    .action(async (state, opts) => {
+    const projectRoot = resolveProjectRoot(pathResolve(opts.project));
+    await initPaths(projectRoot);
+    const sessionId = opts.session.trim();
+    const tool = opts.tool?.trim() || "shell";
+    const previous = loadMetadataState(projectRoot).sessions[sessionId]?.derived;
+    const previousActivity = previous?.activity;
+    const result = { ok: true, state, sessionId, tool };
+    const setActivity = async (activity) => postLiveProjectServiceJsonOrLocal(projectRoot, "/set-activity", { session: sessionId, activity }, () => metadataTracker.setActivity(sessionId, activity, projectRoot));
+    const setAttention = async (attention) => postLiveProjectServiceJsonOrLocal(projectRoot, "/set-attention", { session: sessionId, attention }, () => metadataTracker.setAttention(sessionId, attention, projectRoot));
+    const clearSessionNotifications = async () => postLiveProjectServiceJsonOrLocal(projectRoot, "/notifications/clear", { sessionId }, () => ({
+        ok: true,
+        cleared: clearNotifications({ sessionId }),
+    }));
+    if (state === "running" || state === "command" || state === "busy") {
+        if (previousActivity !== "running") {
+            await clearSessionNotifications();
+            await setActivity("running");
+            await setAttention("normal");
+            await postLiveProjectServiceJsonOrLocal(projectRoot, "/mark-seen", { session: sessionId }, () => metadataTracker.markSeen(sessionId, projectRoot));
+        }
+    }
+    else if (state === "prompt" || state === "idle") {
+        if (previousActivity !== "idle") {
+            await setActivity("idle");
+            await setAttention("normal");
+        }
+        const config = loadConfig().notifications;
+        if (config.enabled && config.onComplete && previousActivity === "running") {
+            await postLiveProjectServiceJsonOrLocal(projectRoot, "/notify", {
+                title: tool,
+                subtitle: "Command complete",
+                message: "Shell returned to a prompt.",
+                sessionId,
+                kind: "task_done",
+            }, () => ({
+                ok: true,
+                notification: addNotification({
+                    title: tool,
+                    subtitle: "Command complete",
+                    body: "Shell returned to a prompt.",
+                    sessionId,
+                    kind: "task_done",
+                }),
+            }));
+        }
+    }
+    else {
+        throw new Error(`Unsupported shell hook state: ${state}`);
+    }
+    if (opts.json) {
+        console.log(JSON.stringify(result));
+        return;
+    }
+    console.log("OK");
+});
 program
     .command("list-notifications")
     .description("List project notifications")