aimux-cli 0.1.13 → 0.1.14

package/dist/multiplexer/persistence-methods.js

@@ -1,15 +1,30 @@
 import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
 import { basename, join } from "node:path";
 import { debug } from "../debug.js";
 import { DashboardPendingActions } from "../dashboard/pending-actions.js";
+import { addDashboardOperationFailure, clearDashboardOperationFailures, listDashboardOperationFailures, } from "../dashboard/operation-failures.js";
+import { composeDashboardWorktreeGroups } from "./dashboard-model.js";
 import { loadDaemonInfo } from "../daemon.js";
 import { getGraveyardPath, getLocalAimuxDir, getProjectStateDir, getStatePath } from "../paths.js";
 import { loadMetadataState } from "../metadata-store.js";
-import { renderCurrentDashboardView as renderCurrentDashboardViewImpl } from "./runtime-state.js";
+import { renderCurrentDashboardView as renderCurrentDashboardViewImpl, stopSessionToOffline } from "./runtime-state.js";
+import { listWorktreeGraveyardEntries as listWorktreeGraveyardEntriesImpl, listWorktreeGraveyardPaths, writeWorktreeGraveyardEntries, } from "./worktree-graveyard.js";
 import { loadStatusline, renderTmuxStatuslineFromData } from "../tmux/statusline.js";
 import { ensureTmuxStatuslineDir, invalidateTmuxStatuslineArtifacts } from "../tmux/statusline-cache.js";
-import { findMainRepo, getWorktreeBaseDir, getWorktreeCreatePath, listWorktrees as listAllWorktrees, } from "../worktree.js";
+import { markLastUsed } from "../last-used.js";
+import { findMainRepo, getWorktreeBaseDir, getWorktreeAddArgs, getWorktreeCreatePath, isToolInternalWorktree, listWorktrees as listAllWorktrees, } from "../worktree.js";
+function recordDashboardFailure(host, input) {
+    const failure = addDashboardOperationFailure(input);
+    host.publishAlert?.({
+        kind: "task_failed",
+        title: input.title,
+        message: input.message,
+        worktreePath: input.worktreePath,
+        dedupeKey: `dashboard-operation-failed:${input.targetKind}:${input.operation}:${input.targetId ?? input.worktreePath ?? input.title}:${input.message}`,
+    });
+    return failure;
+}
 export const persistenceMethods = {
     writeSessionsFile() {
         const dir = getLocalAimuxDir();
@@ -55,6 +70,8 @@ export const persistenceMethods = {
         const managedWindows = this.tmuxRuntimeManager.listProjectManagedWindows(process.cwd());
         const liveTargets = new Map();
         for (const { target, metadata } of managedWindows) {
+            if (metadata.kind !== "agent")
+                continue;
             liveTargets.set(metadata.sessionId, target);
         }
         for (const session of this.sessions) {
@@ -190,6 +207,7 @@ export const persistenceMethods = {
             services: desktopState.services,
             statusline: this.buildStatuslineSnapshot(),
             worktrees: desktopState.worktrees,
+            operationFailures: desktopState.operationFailures,
             mainCheckoutInfo: desktopState.mainCheckoutInfo,
             mainCheckoutPath: desktopState.mainCheckoutPath,
         };
@@ -197,13 +215,14 @@ export const persistenceMethods = {
     reapplyDashboardPendingActions() {
         this.dashboardSessionsCache = this.dashboardPendingActions.applyToSessions(this.dashboardSessionsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, ...session }) => session));
         this.dashboardServicesCache = this.dashboardPendingActions.applyToServices(this.dashboardServicesCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, ...service }) => service));
-        this.dashboardWorktreeGroupsCache = this.dashboardPendingActions.applyToWorktrees(this.dashboardWorktreeGroupsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, pending: _pending, removing: _removing, ...wt }) => wt));
+        this.dashboardWorktreeGroupsCache = composeDashboardWorktreeGroups(this.dashboardPendingActions.applyToWorktrees(this.dashboardWorktreeGroupsCache.map(({ pendingAction: _pendingAction, optimistic: _optimistic, pending: _pending, removing: _removing, operationFailure: _operationFailure, ...wt }) => wt)), this.dashboardSessionsCache, this.dashboardServicesCache);
     },
     listDesktopWorktrees() {
         const pendingCreates = this.pendingWorktreeCreates;
         const pendingRemovals = this.pendingWorktreeRemovals;
+        const hiddenPaths = listWorktreeGraveyardPaths();
         const worktrees = listAllWorktrees()
-            .filter((wt) => !wt.isBare)
+            .filter((wt) => !wt.isBare && !hiddenPaths.has(wt.path) && !isToolInternalWorktree(wt))
             .map((wt) => ({
             ...wt,
             pending: pendingRemovals?.has(wt.path) ?? false,
@@ -226,9 +245,168 @@ export const persistenceMethods = {
                 });
             }
         }
+        const worktreePaths = new Set(worktrees.map((worktree) => worktree.path));
+        for (const failure of listDashboardOperationFailures()) {
+            if (failure.targetKind !== "worktree" || failure.operation !== "create" || !failure.worktreePath)
+                continue;
+            if (hiddenPaths.has(failure.worktreePath) || worktreePaths.has(failure.worktreePath))
+                continue;
+            worktrees.push({
+                name: failure.worktreeName ?? basename(failure.worktreePath),
+                path: failure.worktreePath,
+                branch: "(failed)",
+                isBare: false,
+                createdAt: failure.createdAt,
+                operationFailure: failure,
+            });
+            worktreePaths.add(failure.worktreePath);
+        }
         sortDesktopWorktrees(worktrees);
         return worktrees;
     },
+    listWorktreeGraveyardEntries() {
+        return listWorktreeGraveyardEntriesImpl();
+    },
+    async graveyardDesktopWorktree(path) {
+        this.syncSessionsFromState();
+        const mainRepo = findMainRepo();
+        if (path === mainRepo) {
+            throw new Error("Cannot graveyard the main checkout");
+        }
+        const matching = listAllWorktrees()
+            .filter((worktree) => !worktree.isBare)
+            .find((worktree) => worktree.path === path);
+        if (!matching) {
+            throw new Error(`Worktree "${path}" not found`);
+        }
+        const worktreeGraveyardEntries = this.listWorktreeGraveyardEntries();
+        if (worktreeGraveyardEntries.some((entry) => entry.path === path)) {
+            throw new Error(`Worktree "${matching.name}" is already in the graveyard`);
+        }
+        const attachedServices = collectWorktreeServices(this, path);
+        detachWorktreeServices(this, path);
+        const liveSessions = this.sessions.filter((session) => this.sessionWorktreePaths.get(session.id) === path && this.isSessionRuntimeLive(session) && !session.exited);
+        for (const session of liveSessions) {
+            stopSessionToOffline(this, session);
+        }
+        await waitForWorktreeSessionsToStop(this, path);
+        const attachedAgents = collectWorktreeAgents(this, path);
+        const nextEntries = [
+            ...worktreeGraveyardEntries.filter((entry) => entry.path !== path),
+            {
+                name: matching.name,
+                path: matching.path,
+                branch: matching.branch,
+                createdAt: matching.createdAt,
+                graveyardedAt: new Date().toISOString(),
+                agents: attachedAgents,
+                services: attachedServices,
+            },
+        ];
+        writeWorktreeGraveyardEntries(nextEntries);
+        this.worktreeGraveyardEntries = nextEntries;
+        this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
+        this.saveState();
+        this.invalidateDesktopStateSnapshot();
+        this.refreshLocalDashboardModel();
+        this.metadataServer?.notifyChange?.();
+        if (this.mode === "dashboard") {
+            this.renderDashboard();
+        }
+        return { path, status: "graveyarded" };
+    },
+    async resurrectGraveyardWorktree(path) {
+        const entries = this.listWorktreeGraveyardEntries();
+        const entry = entries.find((candidate) => candidate.path === path);
+        if (!entry) {
+            throw new Error(`Graveyard worktree "${path}" not found`);
+        }
+        const nextEntries = entries.filter((candidate) => candidate.path !== path);
+        writeWorktreeGraveyardEntries(nextEntries);
+        this.worktreeGraveyardEntries = nextEntries;
+        const flatAgents = takeFlatGraveyardAgentsForWorktree(path);
+        const seen = new Set(this.offlineSessions.map((session) => session.id));
+        for (const agent of [...entry.agents, ...flatAgents]) {
+            if (seen.has(agent.id))
+                continue;
+            this.offlineSessions.push(agent);
+            seen.add(agent.id);
+        }
+        const serviceSeen = new Set(this.offlineServices.map((service) => service.id));
+        for (const service of entry.services ?? []) {
+            if (serviceSeen.has(service.id))
+                continue;
+            this.offlineServices.push(service);
+            serviceSeen.add(service.id);
+        }
+        this.saveState();
+        this.invalidateDesktopStateSnapshot();
+        this.refreshLocalDashboardModel();
+        this.metadataServer?.notifyChange?.();
+        if (this.mode === "dashboard") {
+            this.renderDashboard();
+        }
+        return { path, status: "offline" };
+    },
+    async deleteGraveyardWorktree(path) {
+        const entries = this.listWorktreeGraveyardEntries();
+        const entry = entries.find((candidate) => candidate.path === path);
+        if (!entry) {
+            throw new Error(`Graveyard worktree "${path}" not found`);
+        }
+        const mainRepo = findMainRepo();
+        if (path !== mainRepo) {
+            if (!existsSync(path)) {
+                await removeOrphanedDesktopWorktree(this, mainRepo, path);
+            }
+            else {
+                await new Promise((resolve, reject) => {
+                    let stderr = "";
+                    let child;
+                    try {
+                        child = spawn("git", ["worktree", "remove", path, "--force"], {
+                            cwd: mainRepo,
+                            stdio: ["ignore", "ignore", "pipe"],
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                        return;
+                    }
+                    child.stderr.on("data", (chunk) => {
+                        stderr += chunk.toString();
+                    });
+                    child.on("error", reject);
+                    child.on("close", (code) => {
+                        if (code === 0) {
+                            resolve();
+                            return;
+                        }
+                        const detail = stderr
+                            .split("\n")
+                            .map((line) => line.trim())
+                            .filter(Boolean)
+                            .at(-1);
+                        reject(new Error(detail || `git worktree remove exited with code ${code ?? 1}`));
+                    });
+                });
+            }
+        }
+        const nextEntries = entries.filter((candidate) => candidate.path !== path);
+        writeWorktreeGraveyardEntries(nextEntries);
+        this.worktreeGraveyardEntries = nextEntries;
+        this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
+        this.offlineServices = this.offlineServices.filter((service) => service.worktreePath !== path);
+        removeFlatGraveyardAgentsForWorktree(path);
+        this.saveState();
+        this.invalidateDesktopStateSnapshot();
+        this.refreshLocalDashboardModel();
+        this.metadataServer?.notifyChange?.();
+        if (this.mode === "dashboard") {
+            this.renderDashboard();
+        }
+        return { path, status: "removed" };
+    },
     createDesktopWorktree(name) {
         const targetPath = getWorktreeCreatePath(name);
         const pendingCreates = this.pendingWorktreeCreates;
@@ -236,9 +414,10 @@ export const persistenceMethods = {
         if (existingCreate) {
             return { path: targetPath, status: "creating" };
         }
-        if (this.listDesktopWorktrees().some((worktree) => worktree.path === targetPath && !worktree.pending)) {
+        if (this.listDesktopWorktrees().some((worktree) => worktree.path === targetPath && !worktree.pending && !worktree.operationFailure)) {
             throw new Error(`Worktree "${name}" already exists`);
         }
+        clearDashboardOperationFailures({ targetKind: "worktree", operation: "create", worktreePath: targetPath });
         let resolveCreate;
         let rejectCreate;
         const createPromise = new Promise((resolve, reject) => {
@@ -246,10 +425,28 @@ export const persistenceMethods = {
             rejectCreate = reject;
         });
         pendingCreates.set(targetPath, createPromise);
+        const clearPendingCreate = () => {
+            if (pendingCreates.get(targetPath) === createPromise) {
+                pendingCreates.delete(targetPath);
+            }
+            if (this.worktreeCreateJob?.path === targetPath) {
+                this.worktreeCreateJob = null;
+            }
+        };
         this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(targetPath), "creating", {
             timeoutMs: 180_000,
             onTimeout: () => {
-                this.footerFlash = `Timed out creating ${name}`;
+                clearPendingCreate();
+                const message = `Timed out creating worktree "${name}"`;
+                recordDashboardFailure(this, {
+                    targetKind: "worktree",
+                    operation: "create",
+                    title: `Failed to create worktree "${name}"`,
+                    message,
+                    worktreePath: targetPath,
+                    worktreeName: name,
+                });
+                this.footerFlash = message;
                 this.footerFlashTicks = 5;
                 this.invalidateDesktopStateSnapshot();
                 this.refreshLocalDashboardModel();
@@ -271,12 +468,11 @@ export const persistenceMethods = {
         void (async () => {
             try {
                 const mainRepo = findMainRepo();
-                const branchExists = branchExistsInRepo(mainRepo, name);
                 await new Promise((resolve, reject) => {
                     let stderr = "";
                     let child;
                     try {
-                        child = spawn("git", branchExists ? ["worktree", "add", targetPath, name] : ["worktree", "add", targetPath, "-b", name], {
+                        child = spawn("git", getWorktreeAddArgs(name, targetPath, mainRepo), {
                             cwd: mainRepo,
                             stdio: ["ignore", "ignore", "pipe"],
                         });
@@ -310,11 +506,20 @@ export const persistenceMethods = {
         })();
         void createPromise
             .then(() => {
+            clearDashboardOperationFailures({ targetKind: "worktree", operation: "create", worktreePath: targetPath });
             this.footerFlash = `Created: ${name}`;
             this.footerFlashTicks = 3;
         })
             .catch((error) => {
             const message = error instanceof Error ? error.message : String(error);
+            recordDashboardFailure(this, {
+                targetKind: "worktree",
+                operation: "create",
+                title: `Failed to create worktree "${name}"`,
+                message,
+                worktreePath: targetPath,
+                worktreeName: name,
+            });
             this.footerFlash = `Failed: ${message}`;
             this.footerFlashTicks = 5;
             if (this.mode === "dashboard") {
@@ -322,9 +527,8 @@ export const persistenceMethods = {
             }
         });
         const finalizeCreate = () => {
-            pendingCreates.delete(targetPath);
+            clearPendingCreate();
             this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(targetPath), null);
-            this.worktreeCreateJob = null;
             this.invalidateDesktopStateSnapshot();
             this.refreshLocalDashboardModel();
             this.metadataServer?.notifyChange?.();
@@ -351,7 +555,17 @@ export const persistenceMethods = {
         this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(path), "removing", {
             timeoutMs: 180_000,
             onTimeout: () => {
-                this.footerFlash = `Timed out removing ${path.split("/").pop() ?? path}`;
+                const name = path.split("/").pop() ?? path;
+                const message = `Timed out removing worktree "${name}"`;
+                recordDashboardFailure(this, {
+                    targetKind: "worktree",
+                    operation: "remove",
+                    title: `Failed to remove worktree "${name}"`,
+                    message,
+                    worktreePath: path,
+                    worktreeName: name,
+                });
+                this.footerFlash = message;
                 this.footerFlashTicks = 5;
                 this.invalidateDesktopStateSnapshot();
                 this.refreshLocalDashboardModel();
@@ -374,6 +588,7 @@ export const persistenceMethods = {
                 }
                 if (!existsSync(path)) {
                     await removeOrphanedDesktopWorktree(this, mainRepo, path);
+                    clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                     resolveRemoval({ path, status: "removed" });
                     return;
                 }
@@ -382,6 +597,7 @@ export const persistenceMethods = {
                     const worktreeBaseDir = getWorktreeBaseDir();
                     if (path.startsWith(`${worktreeBaseDir}/`) || path === worktreeBaseDir) {
                         await removeOrphanedDesktopWorktree(this, mainRepo, path);
+                        clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                         resolveRemoval({ path, status: "removed" });
                         return;
                     }
@@ -391,10 +607,7 @@ export const persistenceMethods = {
                 if (attachedSession) {
                     throw new Error(`Cannot remove "${matching.name}" while agent "${attachedSession.label || attachedSession.id}" is attached`);
                 }
-                const attachedService = this.buildLiveServiceStates().find((service) => service.worktreePath === path);
-                if (attachedService) {
-                    throw new Error(`Cannot remove "${matching.name}" while service "${attachedService.label || attachedService.id}" is attached`);
-                }
+                detachWorktreeServices(this, path);
                 await new Promise((resolve, reject) => {
                     let stderr = "";
                     let child;
@@ -434,13 +647,29 @@ export const persistenceMethods = {
                 });
                 this.offlineSessions = this.offlineSessions.filter((session) => session.worktreePath !== path);
                 this.offlineServices = this.offlineServices.filter((service) => service.worktreePath !== path);
+                removeFlatGraveyardAgentsForWorktree(path);
                 this.saveState();
+                clearDashboardOperationFailures({ targetKind: "worktree", operation: "remove", worktreePath: path });
                 resolveRemoval({ path, status: "removed" });
             }
             catch (error) {
                 rejectRemoval(error);
             }
         })();
+        void removalPromise.catch((error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            const name = path.split("/").pop() ?? path;
+            recordDashboardFailure(this, {
+                targetKind: "worktree",
+                operation: "remove",
+                title: `Failed to remove worktree "${name}"`,
+                message,
+                worktreePath: path,
+                worktreeName: name,
+            });
+            this.footerFlash = `Failed: ${message}`;
+            this.footerFlashTicks = 5;
+        });
         const finalizeRemoval = () => {
             this.dashboardPendingActions.set(DashboardPendingActions.worktreeKey(path), null);
             pendingRemovals.delete(path);
@@ -516,18 +745,6 @@ async function pruneGitWorktrees(mainRepo) {
     }
     catch { }
 }
-function branchExistsInRepo(mainRepo, branch) {
-    try {
-        execFileSync("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
-            cwd: mainRepo,
-            stdio: "ignore",
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function sortDesktopWorktrees(worktrees) {
     let mainRepo;
     try {
@@ -547,6 +764,47 @@ function sortDesktopWorktrees(worktrees) {
         return a.name.localeCompare(b.name);
     });
 }
+function collectWorktreeAgents(host, path) {
+    const byId = new Map();
+    for (const session of host.offlineSessions) {
+        if (session.worktreePath !== path)
+            continue;
+        byId.set(session.id, session);
+    }
+    return [...byId.values()].sort((a, b) => {
+        const aTime = a.createdAt ? Date.parse(a.createdAt) : 0;
+        const bTime = b.createdAt ? Date.parse(b.createdAt) : 0;
+        return bTime - aTime || a.id.localeCompare(b.id);
+    });
+}
+function collectWorktreeServices(host, path) {
+    const byId = new Map();
+    for (const service of host.offlineServices ?? []) {
+        if (service.worktreePath !== path)
+            continue;
+        byId.set(service.id, service);
+    }
+    for (const service of host.buildLiveServiceStates?.() ?? []) {
+        if (service.worktreePath !== path)
+            continue;
+        byId.set(service.id, service);
+    }
+    return [...byId.values()].sort((a, b) => {
+        const aTime = a.createdAt ? Date.parse(a.createdAt) : 0;
+        const bTime = b.createdAt ? Date.parse(b.createdAt) : 0;
+        return bTime - aTime || a.id.localeCompare(b.id);
+    });
+}
+async function waitForWorktreeSessionsToStop(host, path, timeoutMs = 10_000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const remaining = host.sessions.some((session) => host.sessionWorktreePaths.get(session.id) === path && host.isSessionRuntimeLive(session) && !session.exited);
+        if (!remaining)
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Timed out offlining agents for worktree "${basename(path)}"`);
+}
 async function removeOrphanedDesktopWorktree(host, mainRepo, path) {
     await pruneGitWorktrees(mainRepo);
     if (existsSync(path)) {
@@ -557,4 +815,67 @@ async function removeOrphanedDesktopWorktree(host, mainRepo, path) {
     host.offlineServices = host.offlineServices.filter((service) => service.worktreePath !== path);
     host.saveState();
 }
+function detachWorktreeServices(host, path) {
+    for (const { target, metadata } of host.tmuxRuntimeManager.listProjectManagedWindows(process.cwd())) {
+        if (metadata.kind !== "service" || metadata.worktreePath !== path)
+            continue;
+        markLifecycleUsed(host, metadata.sessionId);
+        try {
+            host.tmuxRuntimeManager.killWindow(target);
+        }
+        catch { }
+    }
+    host.offlineServices = host.offlineServices.filter((service) => service.worktreePath !== path);
+    removePersistedServicesForWorktree(path);
+}
+function removePersistedServicesForWorktree(path) {
+    const statePath = getStatePath();
+    if (!existsSync(statePath))
+        return;
+    try {
+        const state = JSON.parse(readFileSync(statePath, "utf-8"));
+        const nextServices = (state.services ?? []).filter((service) => service.worktreePath !== path);
+        if (nextServices.length === (state.services ?? []).length)
+            return;
+        writeFileSync(statePath, JSON.stringify({ ...state, services: nextServices }, null, 2) + "\n");
+    }
+    catch { }
+}
+function markLifecycleUsed(host, itemId) {
+    try {
+        if (typeof host.noteLastUsedItem === "function") {
+            host.noteLastUsedItem(itemId);
+            return;
+        }
+        if (host.mode === "dashboard" || host.mode === "project-service") {
+            markLastUsed(process.cwd(), {
+                itemId,
+                clientSession: host.tmuxRuntimeManager?.currentClientSession?.() ?? undefined,
+            });
+        }
+    }
+    catch { }
+}
+function takeFlatGraveyardAgentsForWorktree(path) {
+    const graveyardPath = getGraveyardPath();
+    if (!existsSync(graveyardPath))
+        return [];
+    try {
+        const entries = JSON.parse(readFileSync(graveyardPath, "utf-8"));
+        if (!Array.isArray(entries))
+            return [];
+        const matching = entries.filter((entry) => entry?.worktreePath === path);
+        const remaining = entries.filter((entry) => entry?.worktreePath !== path);
+        if (matching.length > 0) {
+            writeFileSync(graveyardPath, JSON.stringify(remaining, null, 2) + "\n");
+        }
+        return matching;
+    }
+    catch {
+        return [];
+    }
+}
+function removeFlatGraveyardAgentsForWorktree(path) {
+    void takeFlatGraveyardAgentsForWorktree(path);
+}
 //# sourceMappingURL=persistence-methods.js.map