agent-relay-orchestrator 0.10.26 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.10.26",
+  "version": "0.11.0",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {

package/src/self-supervision.ts

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
 export interface SelfSupervision {
-  supervisor: "process" | "systemd" | "unknown";
+  supervisor: "process" | "systemd" | "launchd" | "unknown";
   selfUnit?: string;
   runtimePrefix?: string;
 }
@@ -11,7 +11,7 @@ let cached: SelfSupervision | undefined;
 
 /**
  * Detect how this orchestrator process is supervised so the relay can target a
- * remote self-upgrade at the correct systemd unit and install prefix. Result is
+ * remote self-upgrade at the correct unit/label and install prefix. Result is
  * stable for the process lifetime, so it is computed once and cached.
  */
 export function detectSelfSupervision(moduleUrl: string = import.meta.url): SelfSupervision {
@@ -21,6 +21,12 @@ export function detectSelfSupervision(moduleUrl: string = import.meta.url): Self
   if (unit) {
     cached.supervisor = "systemd";
     cached.selfUnit = unit;
+  } else if (process.platform === "darwin") {
+    const label = detectLaunchdLabel();
+    if (label) {
+      cached.supervisor = "launchd";
+      cached.selfUnit = label;
+    }
   }
   return cached;
 }
@@ -64,6 +70,29 @@ function detectSystemdUnit(): string | undefined {
   }
 }
 
+/**
+ * Parse `launchctl list` output to find the label for a given PID. Output format
+ * is tab-separated: PID\tStatus\tLabel (PID is "-" when not running).
+ */
+export function parseLaunchdLabelForPid(output: string, pid: number): string | undefined {
+  const target = String(pid);
+  for (const line of output.split("\n")) {
+    const parts = line.split("\t");
+    if (parts[0] === target && parts[2]) return parts[2];
+  }
+  return undefined;
+}
+
+function detectLaunchdLabel(): string | undefined {
+  try {
+    const result = Bun.spawnSync({ cmd: ["launchctl", "list"], stdout: "pipe", stderr: "ignore" });
+    if (result.exitCode !== 0) return undefined;
+    return parseLaunchdLabelForPid(new TextDecoder().decode(result.stdout), process.pid);
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * The install prefix is the directory above `node_modules` when the orchestrator
  * runs from an installed package (e.g. ~/.agent-relay/runtime). Undefined when

package/src/self-upgrade.ts

@@ -59,8 +59,8 @@ export function planSelfUpgrade(
   }
   const providers = normalizeProviders(params.providers);
 
-  if (supervision.supervisor !== "systemd" || !supervision.selfUnit) {
-    throw new Error("orchestrator is not under systemd --user; remote self-upgrade requires a systemd unit (P1)");
+  if ((supervision.supervisor !== "systemd" && supervision.supervisor !== "launchd") || !supervision.selfUnit) {
+    throw new Error("orchestrator is not under systemd or launchd; remote self-upgrade requires a managed service");
   }
   const unit = supervision.selfUnit;
   const binary = resolveBinary(supervision.runtimePrefix);
@@ -74,13 +74,24 @@ export function planSelfUpgrade(
   ];
   if (supervision.runtimePrefix) installCmd.push("--runtime-prefix", supervision.runtimePrefix);
 
-  // Decouple the restart from this orchestrator's own cgroup: restarting our unit
-  // SIGTERMs us, and a child in our cgroup would be killed mid-restart. systemd-run
-  // schedules it as an independent transient unit that survives our teardown.
-  const restartDetached = runner.commandExists("systemd-run");
-  const restartCmd = restartDetached
-    ? ["systemd-run", "--user", "--collect", "--description", "agent-relay orchestrator self-upgrade restart", "systemctl", "--user", "restart", unit]
-    : ["setsid", "systemctl", "--user", "restart", unit];
+  let restartDetached: boolean;
+  let restartCmd: string[];
+
+  if (supervision.supervisor === "launchd") {
+    const uid = process.getuid?.() ?? 501;
+    // Shell-background the kickstart so it survives our process teardown when
+    // launchd kills us. The shell exits immediately; launchd handles the restart.
+    restartCmd = ["/bin/sh", "-c", `launchctl kickstart -kp gui/${uid}/${unit} &`];
+    restartDetached = true;
+  } else {
+    // Decouple the restart from this orchestrator's own cgroup: restarting our unit
+    // SIGTERMs us, and a child in our cgroup would be killed mid-restart. systemd-run
+    // schedules it as an independent transient unit that survives our teardown.
+    restartDetached = runner.commandExists("systemd-run");
+    restartCmd = restartDetached
+      ? ["systemd-run", "--user", "--collect", "--description", "agent-relay orchestrator self-upgrade restart", "systemctl", "--user", "restart", unit]
+      : ["setsid", "systemctl", "--user", "restart", unit];
+  }
 
   return { targetVersion, providers, unit, runtimePrefix: supervision.runtimePrefix, binary, installCmd, restartCmd, restartDetached };
 }

package/src/spawn.ts

@@ -962,20 +962,14 @@ export function captureTerminal(name: string, config: OrchestratorConfig): Termi
   }
 
   const size = tmuxPaneSize(name, socketName);
-  const cursor = tmuxCursorPos(name, socketName);
-  const result = Bun.spawnSync(tmuxCommand(socketName, "capture-pane", "-p", "-e", "-S", "-1000", "-t", name), {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  if (result.exitCode !== 0) {
-    const stderr = result.stderr.toString().trim();
-    throw new Error(stderr || `tmux capture-pane failed with exit code ${result.exitCode}`);
-  }
+  const { content, cursor } = captureConsistent(
+    () => captureContent(name, socketName),
+    () => tmuxCursorPos(name, socketName),
+  );
 
   return {
     session: name,
-    content: result.stdout.toString(),
+    content,
     running: true,
     agentAlive,
     ...size,
@@ -984,6 +978,42 @@ export function captureTerminal(name: string, config: OrchestratorConfig): Termi
   };
 }
 
+// Capture cursor and content *consistently*. They come from separate tmux invocations,
+// so if the pane scrolls between them (e.g. tool output streaming while the agent
+// "thinks"), cursorY ends up off-by-one against the captured grid — the parked cursor
+// then lands a row off and the TUI's next relative redraw stacks a stale statusline row
+// (bottom-box ghost). Read content, then cursor, then content again; accept only when the
+// two content reads bracket the cursor read unchanged, which proves the cursor reflects
+// that exact grid. Fall through with the latest capture if the pane never holds still.
+export function captureConsistent(
+  readContent: () => string,
+  readCursor: () => { cursorX?: number; cursorY?: number },
+  maxAttempts = 4,
+): { content: string; cursor: { cursorX?: number; cursorY?: number } } {
+  let content = readContent();
+  let cursor = readCursor();
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const recheck = readContent();
+    if (recheck === content) break;
+    content = recheck;
+    cursor = readCursor();
+  }
+  return { content, cursor };
+}
+
+function captureContent(name: string, socketName?: string): string {
+  const result = Bun.spawnSync(tmuxCommand(socketName, "capture-pane", "-p", "-e", "-S", "-1000", "-t", name), {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  if (result.exitCode !== 0) {
+    const stderr = result.stderr.toString().trim();
+    throw new Error(stderr || `tmux capture-pane failed with exit code ${result.exitCode}`);
+  }
+  return result.stdout.toString();
+}
+
 export function terminalInputTokens(data: string): TerminalInputToken[] {
   const tokens: TerminalInputToken[] = [];
   let literal = "";