conductor-remote 1.41.0 → 1.42.0

package/dist-node/src/writes.js

@@ -1,31 +1,89 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { execFile } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
 import { promisify } from 'node:util';
 import { sidecarAvailable, sidecarSendUserMessage } from "./sidecar.js";
 const exec = promisify(execFile);
+/** Waiting runs past this are refused rather than queued. */
+const MAX_UI_QUEUE = 4;
+const uiPriorityScope = new AsyncLocalStorage();
+/** Run `fn` with every UI operation it triggers marked at `priority`. */
+export function withUiPriority(priority, fn) {
+    return uiPriorityScope.run(priority, fn);
+}
+export class UiBusyError extends Error {
+    waiting;
+    constructor(waiting) {
+        super(`Conductor's UI is busy — ${waiting} operation${waiting === 1 ? '' : 's'} already queued. Try again shortly.`);
+        this.name = 'UiBusyError';
+        this.waiting = waiting;
+    }
+}
+let uiRunning = false;
+let uiSeq = 0;
+const uiWaiting = [];
+/** What the UI lock is doing right now — `waiting` excludes the run in flight. */
+export function uiQueueDepth() {
+    return { waiting: uiWaiting.length, busy: uiRunning };
+}
+function pumpUi() {
+    if (uiRunning)
+        return;
+    const next = uiWaiting.shift();
+    if (!next)
+        return;
+    uiRunning = true;
+    next.start();
+}
 /**
- * One UI operation at a time.
- *
- * Every script below drives Conductor's *shared, single* window — focus a
- * workspace, select a tab, write the composer — so two of them overlapping
- * interleaves their steps and lands a prompt in whatever the other one focused.
- * That is the exact failure the whole fail-closed AX design exists to prevent,
- * and no amount of per-step assertion catches it, because each script's reads
- * are true at the moment it makes them.
- *
- * It was unreachable while every write was one person tapping one button. It
- * stopped being unreachable when the relay grew a first-prompt queue that sends
- * on its own schedule (`firstprompt.ts`), so the queue can now fire while the
- * phone is mid-send. Cheap insurance either way: these run for seconds, the
- * caller is already awaiting, and there is never a real queue of them.
+ * Take the lock, run `op`, release it. Exported for `scripts/check-uilock.ts`,
+ * which is the only way this queue's control flow gets read by anything.
  */
-let uiTail = Promise.resolve();
-function uiTurn(op) {
-    // `.then(op, op)` so a previous failure doesn't skip the next turn.
-    const turn = uiTail.then(op, op);
-    uiTail = turn.catch(() => undefined);
-    return turn;
+export function uiTurn(op) {
+    const rank = uiPriorityScope.getStore() === 'background' ? 1 : 0;
+    if (uiWaiting.length >= MAX_UI_QUEUE)
+        return Promise.reject(new UiBusyError(uiWaiting.length));
+    return new Promise((resolve, reject) => {
+        const waiter = {
+            rank,
+            seq: uiSeq++,
+            start: () => {
+                // A throw *before* the first await is still this run's failure, not a crash
+                // that would leave the lock held forever.
+                let settled;
+                try {
+                    settled = op();
+                }
+                catch (err) {
+                    settled = Promise.reject(err);
+                }
+                // Release *before* resolving the caller, not after. Settling first and cleaning
+                // up in a chained `.then` frees the lock one microtask late, so code that awaits
+                // a write and then reads `uiQueueDepth()` is told a run is still in flight when
+                // none is — and the next turn starts a tick later than it could.
+                const release = () => {
+                    uiRunning = false;
+                    pumpUi();
+                };
+                settled.then(value => {
+                    release();
+                    resolve(value);
+                }, err => {
+                    release();
+                    reject(err);
+                });
+            }
+        };
+        // Stable insert: by rank, FIFO within a rank. A background run already started
+        // keeps the lock — this decides who is next, never who is interrupted.
+        const at = uiWaiting.findIndex(w => w.rank > rank);
+        if (at < 0)
+            uiWaiting.push(waiter);
+        else
+            uiWaiting.splice(at, 0, waiter);
+        pumpUi();
+    });
 }
 /**
  * How long one AppleScript run may take before it's killed.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "conductor-remote",
-	"version": "1.41.0",
+	"version": "1.42.0",
 	"type": "module",
 	"packageManager": "yarn@4.15.0",
 	"description": "Phone control panel for local Conductor agents. Reads ride SQLite + git; prompts ride Conductor's own dispatch path.",
@@ -50,12 +50,13 @@
 		"typecheck": "tsc -p tsconfig.json",
 		"lint": "biome check .",
 		"fix": "biome check . --fix",
-		"verify": "yarn typecheck && yarn lint && yarn check:applescript && yarn check:nosleep",
+		"verify": "yarn typecheck && yarn lint && yarn check:applescript && yarn check:nosleep && yarn check:uilock",
 		"release": "semantic-release",
 		"prepack": "yarn build && yarn build:node",
 		"postinstall": "husky || true",
 		"check:applescript": "node scripts/check-applescript.ts",
-		"check:nosleep": "node scripts/check-nosleep.ts"
+		"check:nosleep": "node scripts/check-nosleep.ts",
+		"check:uilock": "node scripts/check-uilock.ts"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.3.8",