aimux-cli 0.1.9 → 0.1.11

package/dist/main.js

@@ -1,17 +1,17 @@
 import { Command } from "commander";
-import { existsSync, readFileSync, writeFileSync, readdirSync, copyFileSync, mkdirSync, chmodSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, readdirSync, copyFileSync, mkdirSync, chmodSync, renameSync, } 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";
 import { Multiplexer } from "./multiplexer/index.js";
 import { llmCompact } from "./context/compactor.js";
-import { initProject, loadConfig } from "./config.js";
-import { initPaths, getHistoryDir, getGraveyardPath, getStatePath, getContextDir, getProjectId } from "./paths.js";
+import { initProject } from "./config.js";
+import { initPaths, getHistoryDir, getGraveyardPath, getStatePath, getContextDir, getProjectId, getProjectStateDirFor, } 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, renderTmuxRepairResult, repairTmuxRuntime, } from "./tmux/doctor.js";
-import { loadMetadataEndpoint, loadMetadataState, resolveProjectServiceEndpoint as resolveStoredProjectServiceEndpoint, updateSessionMetadata, clearSessionLogs, removeMetadataEndpoint, } from "./metadata-store.js";
+import { loadMetadataEndpoint, 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";
@@ -26,6 +26,7 @@ import { runTmuxSwitcher } from "./tmux/switcher.js";
 import { getDashboardCommandSpec } from "./dashboard/command-spec.js";
 import { findLiveDashboardTarget, openDashboardTarget, pruneDashboardArtifacts, resolveDashboardTarget, } from "./dashboard/targets.js";
 import { invalidateTmuxStatuslineArtifacts } from "./tmux/statusline-cache.js";
+import { loadStatusline, renderTmuxStatuslineFromData } from "./tmux/statusline.js";
 const program = new Command();
 class ProjectServiceVersionError extends Error {
     projectRoot;
@@ -65,7 +66,9 @@ async function restartStaleControlPlane(projectRoot) {
     pruneDashboardArtifacts(projectRoot, dashboardBuildStamp, new TmuxRuntimeManager());
 }
 async function fetchProjectServiceHealth(endpoint) {
-    const { status, json } = await requestJson(`http://${endpoint.host}:${endpoint.port}/health`);
+    const { status, json } = await requestJson(`http://${endpoint.host}:${endpoint.port}/health`, {
+        timeoutMs: 1000,
+    });
     if (status < 200 || status >= 300 || json?.ok === false) {
         throw new Error(json?.error || `health request failed: ${status}`);
     }
@@ -73,7 +76,9 @@ async function fetchProjectServiceHealth(endpoint) {
 }
 async function waitForVerifiedProjectService(projectRoot, opts) {
     const expected = getProjectServiceManifest();
-    const deadline = Date.now() + (opts?.timeoutMs ?? 8000);
+    const timeoutMs = opts?.timeoutMs ?? 8000;
+    const startedAt = Date.now();
+    const deadline = startedAt + timeoutMs;
     let lastError = "project service did not become reachable";
     let lastServiceInfo = null;
     let respawnAttempted = false;
@@ -122,12 +127,53 @@ async function waitForVerifiedProjectService(projectRoot, opts) {
         typeof lastServiceInfo === "object") {
         throw new ProjectServiceVersionError(lastError, projectRoot, expected, lastServiceInfo);
     }
-    throw new Error(`${lastError}${lastServiceInfo ? `; last serviceInfo=${JSON.stringify(lastServiceInfo)}` : ""}`);
+    const elapsedMs = Date.now() - startedAt;
+    const elapsedSeconds = (elapsedMs / 1000).toFixed(1);
+    throw new Error(`project service did not become ready after ${elapsedSeconds}s (budget ${timeoutMs}ms); last error: ${lastError}${lastServiceInfo ? `; last serviceInfo=${JSON.stringify(lastServiceInfo)}` : ""}`);
+}
+function rewriteLocalStatuslineArtifacts(projectRoot, tmux, dashboardSessionName) {
+    const data = loadStatusline(projectRoot);
+    if (!data)
+        return;
+    const statusDir = pathJoin(getProjectStateDirFor(projectRoot), "tmux-statusline");
+    mkdirSync(statusDir, { recursive: true });
+    const writeStatusFile = (name, content) => {
+        const filePath = pathJoin(statusDir, name);
+        const tmpPath = `${filePath}.tmp`;
+        writeFileSync(tmpPath, `${content}\n`);
+        renameSync(tmpPath, filePath);
+    };
+    const dashboardTop = renderTmuxStatuslineFromData(data, projectRoot, "top", {
+        currentWindow: "dashboard",
+        currentPath: projectRoot,
+    });
+    const dashboardBottom = renderTmuxStatuslineFromData(data, projectRoot, "bottom", {
+        currentWindow: "dashboard",
+        currentPath: projectRoot,
+        currentSession: dashboardSessionName,
+    });
+    writeStatusFile("top-dashboard.txt", dashboardTop);
+    writeStatusFile("bottom-dashboard.txt", dashboardBottom);
+    if (dashboardSessionName) {
+        writeStatusFile(`bottom-dashboard-${dashboardSessionName}.txt`, dashboardBottom);
+    }
+    for (const entry of data.sessions ?? []) {
+        if (!entry.tmuxWindowId)
+            continue;
+        const renderOptions = {
+            currentWindow: entry.windowName,
+            currentWindowId: entry.tmuxWindowId,
+            currentPath: entry.worktreePath ?? projectRoot,
+        };
+        writeStatusFile(`top-${entry.tmuxWindowId}.txt`, renderTmuxStatuslineFromData(data, projectRoot, "top", renderOptions));
+        writeStatusFile(`bottom-${entry.tmuxWindowId}.txt`, renderTmuxStatuslineFromData(data, projectRoot, "bottom", renderOptions));
+    }
+    tmux.refreshStatus();
 }
-async function postProjectServiceJson(path, body) {
+async function postProjectServiceJson(path, body, options) {
     let endpoint = await resolveProjectServiceEndpoint();
     if (!endpoint) {
-        await ensureProjectService(resolveProjectRoot(process.cwd()));
+        await ensureDaemonProjectReady(resolveProjectRoot(process.cwd()));
         endpoint = await resolveProjectServiceEndpoint();
     }
     if (!endpoint) {
@@ -137,6 +183,7 @@ async function postProjectServiceJson(path, body) {
         method: "POST",
         headers: { "content-type": "application/json" },
         body,
+        timeoutMs: options?.timeoutMs,
     });
     if (status < 200 || status >= 300 || json?.ok === false) {
         throw new Error(json?.error || `request failed: ${status}`);
@@ -146,7 +193,7 @@ async function postProjectServiceJson(path, body) {
 async function getProjectServiceJson(path) {
     let endpoint = await resolveProjectServiceEndpoint();
     if (!endpoint) {
-        await ensureProjectService(resolveProjectRoot(process.cwd()));
+        await ensureDaemonProjectReady(resolveProjectRoot(process.cwd()));
         endpoint = await resolveProjectServiceEndpoint();
     }
     if (!endpoint) {
@@ -166,6 +213,9 @@ async function postProjectServiceJsonOrLocal(path, body, fallback) {
         return fallback();
     }
 }
+function exitAfterOpen() {
+    process.exit(0);
+}
 async function postLiveProjectServiceJsonOrLocal(projectRoot, path, body, fallback) {
     try {
         const endpoint = await resolveProjectServiceEndpoint(projectRoot);
@@ -228,7 +278,13 @@ async function ensureDaemonProjectReady(projectRoot, opts) {
             throw error;
         }
         await restartStaleControlPlane(projectRoot);
-        await waitForVerifiedProjectService(projectRoot);
+        try {
+            await waitForVerifiedProjectService(projectRoot, { timeoutMs: 15_000 });
+        }
+        catch {
+            await ensureProjectService(projectRoot);
+            await waitForVerifiedProjectService(projectRoot, { timeoutMs: 15_000 });
+        }
     }
 }
 async function ensureDaemonProjectSpawned(projectRoot) {
@@ -340,13 +396,13 @@ program
                     insideTmux: tmux.isInsideTmux(),
                     alreadyResolved: true,
                 });
-                return;
+                exitAfterOpen();
             }
         }
-        await ensureDaemonProjectSpawned(projectRoot);
+        await ensureDaemonProjectReady(projectRoot);
         if (!tool && !opts.resume && !opts.restore) {
             openDashboardTarget(projectRoot, tmux);
-            return;
+            exitAfterOpen();
         }
     }
     const mux = new Multiplexer();
@@ -419,15 +475,19 @@ program
     try {
         const originalCwd = process.cwd();
         const projectRoot = resolveProjectRoot(originalCwd);
-        await ensureDaemonProjectSpawned(projectRoot);
+        await ensureDaemonProjectReady(projectRoot);
         invalidateTmuxStatuslineArtifacts(projectRoot);
         const tmux = new TmuxRuntimeManager();
         ensureTmuxAvailable(tmux);
         const { dashboardSession, dashboardTarget } = resolveDashboardTarget(projectRoot, tmux, { forceReload: true });
-        await postProjectServiceJson("/statusline/refresh", { force: true });
+        try {
+            await postProjectServiceJson("/statusline/refresh", { force: true }, { timeoutMs: 1500 });
+        }
+        catch { }
+        rewriteLocalStatuslineArtifacts(projectRoot, tmux, dashboardSession.sessionName);
         if (opts.open) {
             tmux.openTarget(dashboardTarget, { insideTmux: tmux.isInsideTmux(), alreadyResolved: true });
-            return;
+            exitAfterOpen();
         }
         console.log(`Reloaded dashboard for ${dashboardSession.sessionName}`);
     }
@@ -499,7 +559,7 @@ program
         await initPaths(projectRoot);
         const result = await restartProjectRuntime(projectRoot, { open: opts.open });
         if (opts.open)
-            return;
+            exitAfterOpen();
         if (opts.json) {
             console.log(JSON.stringify({
                 ok: true,
@@ -1946,14 +2006,14 @@ repairCmd
     .action(async (opts) => {
     const projectRoot = resolveProjectRoot(opts.projectRoot);
     await initPaths(projectRoot);
-    await ensureDaemonProjectSpawned(projectRoot);
+    await ensureDaemonProjectReady(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;
+        exitAfterOpen();
     }
     if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -2149,69 +2209,6 @@ 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")