@clipboard-health/groundcrew 4.45.5 → 4.45.7

package/dist/lib/cmuxAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cmuxAdapter.d.ts","sourceRoot":"","sources":["../../src/lib/cmuxAdapter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,KAAK,OAAO,EAIb,MAAM,uBAAuB,CAAC;AAG/B,eAAO,MAAM,WAAW,EAAE,OA+EzB,CAAC"}
+{"version":3,"file":"cmuxAdapter.d.ts","sourceRoot":"","sources":["../../src/lib/cmuxAdapter.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EACL,KAAK,OAAO,EAKb,MAAM,uBAAuB,CAAC;AAG/B,eAAO,MAAM,WAAW,EAAE,OA+EzB,CAAC"}

package/dist/lib/cmuxAdapter.js

@@ -4,21 +4,28 @@
  * per-workspace status pill, which `open` applies best-effort.
  */
 import { isSignalAborted, runWorkspaceCommand, } from "./workspaceAdapter.js";
-import { debug, errorMessage, log } from "./util.js";
+import { debug, errorMessage, log, logEvent } from "./util.js";
 export const cmuxAdapter = {
     async open(spec, signal) {
-        const output = await runWorkspaceCommand("cmux", [
-            "--json",
-            "new-workspace",
-            "--name",
-            spec.name,
-            "--cwd",
-            spec.cwd,
-            "--command",
-            spec.command,
-            "--description",
-            cmuxDescriptionFor(spec.name),
-        ], signal);
+        let output;
+        try {
+            output = await runWorkspaceCommand("cmux", [
+                "--json",
+                "new-workspace",
+                "--name",
+                spec.name,
+                "--cwd",
+                spec.cwd,
+                "--command",
+                spec.command,
+                "--description",
+                cmuxDescriptionFor(spec.name),
+            ], signal);
+        }
+        catch (error) {
+            await closeWorkspaceLeakedByFailedOpen(error, spec.name, signal);
+            throw error;
+        }
         const workspaceId = extractCmuxOpenId(output);
         if (workspaceId === undefined) {
             log(`cmux new-workspace returned unrecognized output for ${spec.name}; if a workspace was created, run \`cmux close-workspace\` manually.`);
@@ -51,28 +58,21 @@ export const cmuxAdapter = {
             debug(`cmux close-workspace skipped for ${name}: list-workspaces failed, no usable id`);
             return { kind: "unavailable" };
         }
-        const match = raw.find((ws) => cmuxTaskId(ws) === name);
-        if (match === undefined) {
+        const matches = raw.filter((ws) => cmuxTaskId(ws) === name);
+        if (matches.length === 0) {
             return { kind: "missing" };
         }
-        try {
-            await closeCmuxWorkspace(match.id, signal);
-            return { kind: "closed" };
-        }
-        catch (error) {
-            if (isSignalAborted(signal)) {
-                throw error;
-            }
-            const remaining = await listCmuxRaw(signal);
-            if (remaining === undefined) {
-                return { kind: "unavailable", error };
-            }
-            const isStillPresent = remaining.some((ws) => cmuxTaskId(ws) === name);
-            if (!isStillPresent) {
-                return { kind: "closed" };
-            }
-            throw error;
+        if (matches.length > 1) {
+            // A single task id maps to many cmux workspaces only after a leaked launch
+            // or session-restore duplication. Surface the leak so it's observable
+            // rather than silently reconciled away.
+            logEvent("cmux_close", {
+                outcome: "duplicate_markers",
+                task: name,
+                duplicates: matches.length,
+            });
         }
+        return await closeAllCmuxMatches(matches, signal);
     },
     accessHint(_name) {
         // cmux is a TUI; users surface workspaces by launching the cmux app,
@@ -177,9 +177,104 @@ async function applyCmuxStatus(workspaceId, status, signal) {
     arguments_.push("--workspace", workspaceId);
     await runWorkspaceCommand("cmux", arguments_, signal);
 }
+/**
+ * Closes every workspace sharing the requested marker. Closes run sequentially:
+ * a failure path re-lists cmux to confirm the workspace is gone, and firing N
+ * mutations plus N confirmation lists concurrently would race on that shared
+ * state. Each match is attempted even when an earlier one fails, so a single
+ * stuck duplicate can't orphan the rest; a confirmed-still-present failure is
+ * collected and rethrown only after the loop (preserving single-match
+ * semantics). A failure that cannot be confirmed yields `unavailable`; `closed`
+ * wins only when every match is gone.
+ */
+async function closeAllCmuxMatches(matches, signal) {
+    let unavailable;
+    const errors = [];
+    for (const match of matches) {
+        try {
+            // oxlint-disable-next-line no-await-in-loop -- sequential by design; failure re-lists shared cmux state
+            const result = await closeCmuxMatch(match, signal);
+            if (result.kind === "unavailable") {
+                unavailable = result;
+            }
+        }
+        catch (error) {
+            if (isSignalAborted(signal)) {
+                throw error;
+            }
+            errors.push(error);
+        }
+    }
+    if (errors.length > 0) {
+        throw errors.length === 1 ? errors[0] : new AggregateError(errors);
+    }
+    return unavailable ?? { kind: "closed" };
+}
+async function closeCmuxMatch(match, signal) {
+    try {
+        await closeCmuxWorkspace(match.id, signal);
+        return { kind: "closed" };
+    }
+    catch (error) {
+        if (isSignalAborted(signal)) {
+            throw error;
+        }
+        const remaining = await listCmuxRaw(signal);
+        if (remaining === undefined) {
+            return { kind: "unavailable", error };
+        }
+        const isStillPresent = remaining.some((ws) => ws.id === match.id);
+        if (!isStillPresent) {
+            return { kind: "closed" };
+        }
+        throw error;
+    }
+}
 async function closeCmuxWorkspace(workspaceId, signal) {
     await runWorkspaceCommand("cmux", ["close-workspace", "--workspace", workspaceId], signal);
 }
+/**
+ * cmux occasionally exits non-zero from `new-workspace` while still having
+ * created the workspace (a known flake where it also lands in the wrong `--cwd`).
+ * The id rides along in the failed command's captured output, so recover it and
+ * close that exact workspace by id — a failed launch must not strand an orphan
+ * tagged with the task's `groundcrew:<taskId>` marker. Closing by the recovered
+ * id needs no `list-workspaces`, so it survives a concurrent list failure that
+ * would defeat re-enumeration. Re-enumeration close is unsafe here anyway; we
+ * hold the precise id cmux returned, so there is no same-named-sibling risk.
+ */
+async function closeWorkspaceLeakedByFailedOpen(error, name, signal) {
+    if (isSignalAborted(signal)) {
+        return;
+    }
+    const workspaceId = extractCmuxOpenIdFromFailure(error);
+    if (workspaceId === undefined) {
+        return;
+    }
+    try {
+        await closeCmuxWorkspace(workspaceId, signal);
+        debug(`cmux new-workspace for ${name} exited non-zero but had created ${workspaceId}; closed the leaked workspace.`);
+    }
+    catch (closeError) {
+        log(`cmux new-workspace for ${name} exited non-zero and left workspace ${workspaceId}; automatic close failed (${errorMessage(closeError)}). Run \`cmux close-workspace --workspace ${workspaceId}\` by hand.`);
+    }
+}
+/**
+ * Recover the created workspace id from a failed `new-workspace`. Parse only
+ * the captured stdout slice of the command error's message (see
+ * `normalizeCommandError`), never the whole message — matching against stderr
+ * or the echoed command line risks grabbing an unrelated `workspace:N` and
+ * closing the wrong workspace. The slice is the same shape the success path
+ * sees, so `extractCmuxOpenId` handles both the `--json` id object and a bare
+ * `workspace:N` ref.
+ */
+function extractCmuxOpenIdFromFailure(error) {
+    const stdout = cmuxStdoutFromFailureMessage(errorMessage(error));
+    return stdout === undefined ? undefined : extractCmuxOpenId(stdout);
+}
+function cmuxStdoutFromFailureMessage(message) {
+    return /\nStdout:\n([\s\S]*?)(?:\nCause: |$)/.exec(message)?.[1];
+}
 function isCmuxSetStatusUnsupported(error) {
     return errorMessage(error).includes('unknown command "set-status"');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clipboard-health/groundcrew",
-  "version": "4.45.5",
+  "version": "4.45.7",
   "description": "Linear-driven orchestrator that launches AI coding agents in git worktrees, with workspace lifecycle and usage tracking.",
   "keywords": [
     "agent",
@@ -88,7 +88,7 @@
     "cspell": "10.0.1",
     "dependency-cruiser": "17.4.3",
     "husky": "9.1.7",
-    "jscpd": "5.0.10",
+    "jscpd": "5.0.11",
     "knip": "6.16.1",
     "lint-staged": "17.0.7",
     "markdownlint-cli2": "0.22.1",