@zswarm/core 0.2.3 → 0.2.5

package/assets/slot.py

@@ -35,6 +35,7 @@ from __future__ import annotations  # macOS ships Python 3.9
 
 import os
 import re
+import shutil
 import signal
 import subprocess
 import sys
@@ -300,6 +301,39 @@ def main(argv: list[str]) -> int:
     return run(argv, env)
 
 
+def resolve_command(
+    argv: list[str],
+    env: dict[str, str],
+    os_name: str = os.name,
+    which=shutil.which,
+) -> list[str] | str:
+    """Rewrite argv so Windows can start argv[0], including .cmd/.bat shims.
+
+    CreateProcess does not search PATH or apply PATHEXT and cannot start a
+    batch file, so `slot -- pnpm ...` died 127 even though pnpm was on PATH.
+    On Windows, resolve argv[0] with shutil.which against the child's PATH;
+    shutil.which also applies PATHEXT from the environment this process
+    inherits (slot passes that environment straight through). A .cmd/.bat shim
+    runs through the command processor with `cmd.exe /d /s /c` and MS-quoted
+    arguments -- the documented way to run a batch file, and `cmd /c` returns
+    the batch's own exit code. A resolved .exe is spawned directly. POSIX and
+    anything that does not resolve are returned unchanged, so Popen still
+    reports the same FileNotFoundError and 127 as before.
+    """
+    if os_name != "nt" or not argv:
+        return argv
+    exe = which(argv[0], path=env.get("PATH"))
+    if not exe:
+        return argv
+    if Path(exe).suffix.lower() in (".cmd", ".bat"):
+        comspec = env.get("ComSpec") or "cmd.exe"
+        # One command line, handed to CreateProcess as is: a list would be
+        # quoted again by subprocess, and cmd.exe does not understand \".
+        # With /s, cmd strips exactly the outer quote pair and runs the rest.
+        return f'"{comspec}" /d /s /c "{subprocess.list2cmdline([exe, *argv[1:]])}"'
+    return [exe, *argv[1:]]
+
+
 def run(argv: list[str], env: dict[str, str], renice: bool = True) -> int:
     """Run the command as a child and wait. The lock descriptors stay in this
     process (close-on-exec), so a daemon the command leaves behind never
@@ -310,7 +344,7 @@ def run(argv: list[str], env: dict[str, str], renice: bool = True) -> int:
         except OSError:
             pass
     try:
-        child = subprocess.Popen(argv, env=env)
+        child = subprocess.Popen(resolve_command(argv, env), env=env)
     except FileNotFoundError:
         die(f"{argv[0]}: command not found", 127)
     for sig in (signal.SIGINT, signal.SIGTERM, getattr(signal, "SIGHUP", None)):

package/dist/harness.d.ts

@@ -14,6 +14,11 @@ export type HarnessProfile = {
      * turn. `send` matches these against the trailing lines after the paste.
      */
     queued: readonly RegExp[];
+    /**
+     * A hint that the harness is actively working on a turn. `status` matches
+     * these against the trailing lines to avoid treating a busy pane as idle.
+     */
+    busy: readonly RegExp[];
 };
 /**
  * Identify the harness from a pane's command and title, case-insensitively.
@@ -29,3 +34,8 @@ export declare function resolveHarness(pane: {
  * Only the last few lines count: a quoted marker in scrollback is not a queue.
  */
 export declare function queuedPrompt(screen: string, profile: HarnessProfile): boolean;
+/**
+ * Does this screen's trailing lines show the harness actively working? Only
+ * the last few lines count: a quoted marker in scrollback is not a live turn.
+ */
+export declare function busyPrompt(screen: string, profile: HarnessProfile): boolean;

package/dist/harness.js

@@ -69,11 +69,24 @@ const QUEUED = {
     gemini: GENERIC_QUEUED,
     pi: GENERIC_QUEUED,
 };
+/**
+ * Busy (working) markers seen live. OpenCode draws a progress bar of filled
+ * and hollow squares while a turn runs; no other named harness has an equally
+ * reliable marker yet, so they rely on the lease only (`[]`).
+ */
+const BUSY = {
+    codex: [],
+    cursor: [],
+    opencode: [/[■⬝]{4,}/],
+    gemini: [],
+    pi: [],
+};
 const UNKNOWN = {
     name: "unknown",
     submit: "auto",
     waiting: GENERIC_WAITING,
     queued: GENERIC_QUEUED,
+    busy: [/esc to interrupt/i],
 };
 function escapeRegExp(text) {
     return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -118,18 +131,36 @@ export function resolveHarness(pane) {
     const name = matchCommand(pane.command) ?? matchTitle(pane.title) ?? "unknown";
     if (name === "unknown")
         return UNKNOWN;
-    return { name, submit: SUBMIT[name], waiting: WAITING[name], queued: QUEUED[name] };
+    return {
+        name,
+        submit: SUBMIT[name],
+        waiting: WAITING[name],
+        queued: QUEUED[name],
+        busy: BUSY[name],
+    };
 }
 /**
  * Does this screen's trailing lines show the harness's queued-message hint?
  * Only the last few lines count: a quoted marker in scrollback is not a queue.
  */
 export function queuedPrompt(screen, profile) {
-    const lines = screen
+    const lines = trailingLines(screen);
+    return profile.queued.some((re) => lines.some((line) => re.test(line)));
+}
+/**
+ * Does this screen's trailing lines show the harness actively working? Only
+ * the last few lines count: a quoted marker in scrollback is not a live turn.
+ */
+export function busyPrompt(screen, profile) {
+    const lines = trailingLines(screen);
+    return profile.busy.some((re) => lines.some((line) => re.test(line)));
+}
+/** The six last non-empty, right-trimmed lines of a screen, CR stripped. */
+function trailingLines(screen) {
+    return screen
         .replace(/\r/g, "")
         .split("\n")
         .map((line) => line.trimEnd())
         .filter((line) => line.length > 0)
         .slice(-6);
-    return profile.queued.some((re) => lines.some((line) => re.test(line)));
 }

package/dist/host/cli.js

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
 import { ZellijError } from "../errors.js";
-import { crewCheck, crewDown, crewStart, crewStatus, crewUp } from "./crew.js";
+import { createStateStore } from "../state.js";
+import { crewCheck, crewClient, crewDown, crewStart, crewStatus, crewUp } from "./crew.js";
 import { hostDoctor, hostInstall, hostInstallArgs, hostScriptPath } from "./host.js";
+import { listLeases } from "./lease.js";
 import { cancelAllTo, cancelRelay, listRelays, pruneRelays, runRelayDir, startRelay, waitForRelay } from "./relay.js";
 import { runSlot } from "./slot.js";
 /**
@@ -73,6 +75,10 @@ async function crew(argv) {
             return crewStart(session);
         case "check":
             return crewCheck(session);
+        case "client":
+            // What the minimized console window on Windows runs: attach (and create)
+            // the session so its panes render and take input.
+            return crewClient(session);
         default:
             process.stderr.write(`${COMMANDS.crew.usage}\n`);
             return 2;
@@ -80,7 +86,7 @@ async function crew(argv) {
 }
 /** A plain-text table for `relay --list`, one row per relay. */
 function relayTable(rows) {
-    const header = ["ID", "STATE", "TO", "SESSION", "AGE", "LAST CHECK", "JOB"];
+    const header = ["ID", "STATE", "TO", "SESSION", "AGE", "LAST CHECK", "JOB", "LEASE"];
     const body = rows.map((r) => [
         r.id,
         r.state,
@@ -89,12 +95,26 @@ function relayTable(rows) {
         `${r.age}s`,
         r.lastCheck === undefined ? "-" : String(r.lastCheck),
         r.job ?? "-",
+        r.lease ? `${r.lease.relayId} (${r.lease.from})` : "-",
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
+    return [header, ...body].map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
+}
+/** A plain-text table for `relay --leases`, one row per live lease. */
+function leaseTable(leases) {
+    const header = ["KEY", "RELAY", "FROM", "PANE", "SINCE"];
+    const body = leases.map((l) => [
+        l.key,
+        l.relayId,
+        l.from,
+        l.pane,
+        new Date(l.at).toISOString(),
     ]);
     const widths = header.map((h, i) => Math.max(h.length, ...body.map((row) => row[i].length)));
     return [header, ...body].map((row) => row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd()).join("\n");
 }
 async function relay(argv) {
-    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--cancel-all", "--json"]);
+    const { flags } = parseHostArgs(argv, ["--foreground", "--prune", "--list", "--leases", "--cancel-all", "--json", "--queue", "--force"]);
     const run = str(flags["--run"]);
     if (run)
         return runRelayDir(run);
@@ -115,6 +135,13 @@ async function relay(argv) {
         process.stdout.write(`${relayTable(rows)}\n`);
         return 0;
     }
+    if (flags["--leases"] === true) {
+        const leases = listLeases(createStateStore());
+        if (flags["--json"] === true)
+            return json(() => ({ leases }));
+        process.stdout.write(`${leaseTable(leases)}\n`);
+        return 0;
+    }
     const cancelId = str(flags["--cancel"]);
     if (cancelId) {
         const res = cancelRelay(cancelId);
@@ -153,6 +180,8 @@ async function relay(argv) {
         timeoutMin: flags["--timeout-min"] ? Number(str(flags["--timeout-min"])) : undefined,
         maxAgeMin: flags["--max-age"] ? Number(str(flags["--max-age"])) : undefined,
         foreground: flags["--foreground"] === true,
+        queue: flags["--queue"] === true,
+        force: flags["--force"] === true,
     }));
 }
 async function host(argv) {
@@ -202,10 +231,13 @@ const COMMANDS = {
     crew: {
         usage: [
             "zswarm crew up <session> --layout L.kdl [--config C.kdl] [--env-file F] [--first-pane NAME] [--run-as USER]",
-            "                                  keep the session running from its layout (service + 2-min watchdog)",
+            "                                  keep the session running from its layout (service + 2-min watchdog;",
+            "                                  on Windows: Scheduled Tasks under \\zswarm\\ + an attached client window)",
             "zswarm crew status <session> [--run-as USER]   services, session, panes",
             "zswarm crew down <session> [--run-as USER]     remove the services and kill the session",
             "zswarm crew start|check <session>              what the service and the watchdog run",
+            "zswarm crew client <session>                   what the minimized console window runs (Windows)",
+            "--run-as installs for another account and is Linux/macOS only; a Windows crew runs as the signed-in user",
         ].join("\n"),
         run: crew,
     },
@@ -213,11 +245,14 @@ const COMMANDS = {
         usage: [
             "zswarm relay --to PANE --done REGEX --reply-to PANE [--serve TARGET] [--session S] [--body-file F]",
             "             [--reply-session S] [--from NAME] [--check SCRIPT] [--message TEMPLATE] [--id ID]",
-            "             [--timeout-min 240] [--max-age MIN] [--foreground]",
+            "             [--timeout-min 240] [--max-age MIN] [--queue] [--force] [--foreground]",
             "      send the body to PANE over serve (ZSWARM_SERVE / ZSWARM_SERVE_TOKEN), then a detached relay",
             "      waits for REGEX (and SCRIPT exit 0) and pastes a message into the local --reply-to pane;",
             "      --max-age (default --timeout-min + 60) is a hard end that always yields a final status",
-            "zswarm relay --list [--json]   id, state, target, session, age, last check and job per relay dir",
+            "      it leases its target pane until it ends; a second relay to a leased pane fails pane_leased",
+            "      unless --queue waits for the lease to free or --force shares it",
+            "zswarm relay --list [--json]   id, state, target, session, age, last check, job and lease per relay dir",
+            "zswarm relay --leases [--json]   live pane leases and the relay that holds each",
             "zswarm relay --cancel ID | --cancel-all --to PANE   stop the job, mark it CANCELLED, paste nothing",
             "zswarm relay --wait ID [--timeout-min 240]   block until relay ID has its message, print it (pull path)",
             "zswarm relay --prune [--days 14]   remove old relay dirs and undelivered messages",

package/dist/host/crew-windows.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Windows half of `zswarm crew`.
+ *
+ * A background Zellij session started with `zellij attach --create-background`
+ * on Windows renders empty pane grids and drops pasted input, because nothing
+ * is attached in a real console. The fix is two Scheduled Tasks under
+ * `\zswarm\` plus a minimized attached-client console window:
+ *
+ *   zswarm-crew-<session>        starts the session (interactive, highest)
+ *   zswarm-crew-<session>-watch  `crew check` every two minutes, so the crew
+ *                                restarts only when the session or its first
+ *                                layout pane is gone, and the client window is
+ *                                reopened when it is gone but the session lives
+ *
+ * This module is pure PowerShell text (unit-tested by text) plus thin async
+ * wrappers. It deliberately mirrors `buildServeTaskScript` in
+ * `ops/serve-install.ts`: same preamble helpers, same base64 UTF-8 round-trip
+ * for the cmd.exe action body, same `-EncodedCommand` invocation. It must not
+ * import `./crew.js`; that module imports this one.
+ */
+/** Scheduled-task folder every crew task lives in. */
+export declare const CREW_TASK_FOLDER = "\\zswarm\\";
+/** Watchdog cadence, matching the Linux/macOS `crew-<s>-watch` timer. */
+export declare const CREW_WATCH_MINUTES = 2;
+export type PowerShellResult = {
+    code: number;
+    stdout: string;
+    stderr: string;
+};
+export type PowerShellExec = (script: string, options: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}) => Promise<PowerShellResult>;
+export type CrewTaskNames = {
+    folder: string;
+    start: string;
+    watch: string;
+};
+export type CrewTaskState = {
+    /** Which of the two crew tasks this is. */
+    name: "start" | "watch";
+    /** Task name only, e.g. `zswarm-crew-crew`. */
+    task: string;
+    /** `\zswarm\zswarm-crew-crew`. */
+    path: string;
+    /** `Ready` | `Running` | `Disabled` | `missing` ... */
+    state: string;
+    /** Registered at all: Ready/Running/Disabled count; `missing` does not. */
+    active: boolean;
+    lastResult: number | null;
+    lastRun: string | null;
+};
+export type CrewClientWindow = {
+    present: boolean;
+    pid: number | null;
+    count: number;
+};
+/** `zswarm-crew-<session>`: task names, and the client window's title marker. */
+export declare function crewTaskNames(session: string): CrewTaskNames;
+/** The token that proves a console window is this crew's client: its title and
+ *  the string in its launcher's command line. */
+export declare function crewClientMarker(session: string): string;
+/** The cmd.exe action body for a task: `set "K=V"&& ...` then the CLI argv. */
+export declare function crewTaskCommand(input: {
+    launch: {
+        execPath: string;
+        scriptPath: string;
+    };
+    mode: "start" | "check";
+    session: string;
+    env: NodeJS.ProcessEnv;
+}): string;
+/** Pure PowerShell text, unit-tested by text. */
+export declare function buildCrewTaskScript(action: "register" | "inspect" | "start" | "unregister", params: {
+    session: string;
+    startCommand?: string;
+    watchCommand?: string;
+    intervalMinutes?: number;
+}): string;
+/**
+ * The command line the client window runs. The marker is both the window title
+ * and the token `ensure`/`close` look for in a process command line; the crew
+ * CLI does the actual `zellij attach --create`, so the window can read the crew
+ * dir (and its env file) itself instead of taking secrets on a command line.
+ */
+export declare function crewClientCommand(input: {
+    session: string;
+    launch: {
+        execPath: string;
+        scriptPath: string;
+    };
+}): string;
+/** The minimized attached-client window that makes a Windows Zellij session render. */
+export declare function buildCrewClientScript(action: "ensure" | "close", params: {
+    session: string;
+    clientCommand?: string;
+}): string;
+/** Last line that parses as a JSON object, else the first; null when none does. */
+export declare function parseCrewJson(stdout: string): Record<string, unknown> | null;
+/** Powershell runner used in production; injected in tests. Never throws. */
+export declare const defaultPowerShellExec: PowerShellExec;
+export declare function inspectCrewTasks(input: {
+    session: string;
+    runPowerShell: PowerShellExec;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    tasks: CrewTaskState[];
+    client: CrewClientWindow;
+}>;
+export declare function installCrewTasks(input: {
+    session: string;
+    startCommand: string;
+    watchCommand: string;
+    intervalMinutes?: number;
+    runPowerShell: PowerShellExec;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    lines: string[];
+    notes: string[];
+    tasks: CrewTaskState[];
+    client: CrewClientWindow;
+}>;
+export declare function removeCrewTasks(input: {
+    session: string;
+    runPowerShell: PowerShellExec;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    lines: string[];
+    tasks: CrewTaskState[];
+}>;
+export declare function ensureCrewClient(input: {
+    session: string;
+    clientCommand: string;
+    runPowerShell: PowerShellExec;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    opened: boolean;
+    pid: number | null;
+    title: string;
+    present: boolean;
+    count: number;
+}>;
+export declare function closeCrewClient(input: {
+    session: string;
+    runPowerShell: PowerShellExec;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<{
+    closed: number[];
+    count: number;
+}>;