@zswarm/core 0.2.4 → 0.2.5

package/dist/host/cli.js

@@ -1,7 +1,7 @@
 import { readFileSync } from "node:fs";
 import { ZellijError } from "../errors.js";
 import { createStateStore } from "../state.js";
-import { crewCheck, crewDown, crewStart, crewStatus, crewUp } from "./crew.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";
@@ -75,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;
@@ -227,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,
     },

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;
+}>;

package/dist/host/crew-windows.js

@@ -0,0 +1,556 @@
+import { execFile } from "node:child_process";
+import { ZellijError } from "../errors.js";
+import { encodePowerShellCommand } from "../zellij/ipc.js";
+/**
+ * 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 const CREW_TASK_FOLDER = "\\zswarm\\";
+/** Watchdog cadence, matching the Linux/macOS `crew-<s>-watch` timer. */
+export const CREW_WATCH_MINUTES = 2;
+/** Same shape the `zswarm crew` session validator uses; duplicated to avoid a cycle. */
+const CREW_SESSION = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+/** Overall helper deadline when `timeoutMs` is omitted. Registering two tasks is two calls. */
+const DEFAULT_CREW_TIMEOUT_MS = 20_000;
+function checkSession(session) {
+    const text = session?.trim() ?? "";
+    if (!CREW_SESSION.test(text)) {
+        throw new ZellijError("bad_arg", `invalid session name ${JSON.stringify(session)}`);
+    }
+    return text;
+}
+/** `zswarm-crew-<session>`: task names, and the client window's title marker. */
+export function crewTaskNames(session) {
+    const start = `zswarm-crew-${checkSession(session)}`;
+    return { folder: CREW_TASK_FOLDER, start, watch: `${start}-watch` };
+}
+/** The token that proves a console window is this crew's client: its title and
+ *  the string in its launcher's command line. */
+export function crewClientMarker(session) {
+    return `zswarm-crew-${checkSession(session)}`;
+}
+/**
+ * A task registration is a readable, long-lived artifact, so only the two
+ * variables a crew task cannot discover on its own are serialized — never the
+ * caller's whole environment, which can hold tokens. PATH is deliberately not
+ * one of them: the task runs as the signed-in user and inherits their PATH, and
+ * a host PATH (kilometres of it on Windows) would blow the ~32k Windows
+ * command-line limit once the action is base64-encoded inside this script.
+ */
+const CREW_TASK_ENV_KEYS = ["ZSWARM_BIN", "ZSWARM_STATE_DIR"];
+function crewEnvAssignments(env) {
+    const assignments = [];
+    for (const key of CREW_TASK_ENV_KEYS) {
+        const value = env[key]?.trim();
+        if (!value)
+            continue;
+        if (/[\0\r\n"%]/.test(value)) {
+            throw new ZellijError("bad_arg", `${key} must not contain quotes, newlines, or %`);
+        }
+        assignments.push(`set "${key}=${value}"`);
+    }
+    return assignments;
+}
+/** The cmd.exe action body for a task: `set "K=V"&& ...` then the CLI argv. */
+export function crewTaskCommand(input) {
+    if (input.mode !== "start" && input.mode !== "check") {
+        throw new ZellijError("bad_arg", `unknown crew task mode ${String(input.mode)}`);
+    }
+    const session = checkSession(input.session);
+    for (const [label, value] of [
+        ["execPath", input.launch.execPath],
+        ["scriptPath", input.launch.scriptPath],
+    ]) {
+        if (!value || /[\0\r\n"]/.test(value)) {
+            throw new ZellijError("bad_arg", `crew task ${label} must not contain quotes or newlines`);
+        }
+    }
+    const argv = `"${input.launch.execPath}" "${input.launch.scriptPath}" crew ${input.mode} ${session}`;
+    const assignments = crewEnvAssignments(input.env);
+    const line = assignments.length === 0 ? argv : `${assignments.join("&& ")}&& ${argv}`;
+    // The task action is `cmd.exe /c <line>`, and cmd strips the first and last
+    // quote of a `/c "..."` tail: on a line that starts with the program's own
+    // quote that costs the program its opening quote ("The filename, directory
+    // name, or volume label syntax is incorrect"). Wrapping the whole line in one
+    // more pair makes the stripping harmless — the line still ends with the
+    // unquoted session name, so nothing after it is lost.
+    return `"${line}"`;
+}
+const PS_PREAMBLE = [
+    "$ErrorActionPreference = 'Stop'",
+    "$ProgressPreference = 'SilentlyContinue'",
+    "[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false",
+    "function Get-ZswarmIdentity {",
+    "  $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()",
+    "  if (-not $id -or -not $id.User -or [string]::IsNullOrWhiteSpace($id.User.Value)) {",
+    "    throw 'cannot resolve the current Windows SID for the Interactive crew task'",
+    "  }",
+    "  $name = [string]$id.Name",
+    "  if ([string]::IsNullOrWhiteSpace($name)) {",
+    "    throw 'cannot resolve the current Windows account name for the Interactive crew task'",
+    "  }",
+    "  return @{ name = $name; sid = [string]$id.User.Value }",
+    "}",
+    "function Resolve-ZswarmSid($account) {",
+    "  if ($null -eq $account) { return $null }",
+    "  $text = [string]$account",
+    "  if ([string]::IsNullOrWhiteSpace($text)) { return $null }",
+    "  if ($text -match '^S-\\d-') { return $text }",
+    "  try {",
+    "    $nt = New-Object System.Security.Principal.NTAccount($text)",
+    "    $sid = $nt.Translate([System.Security.Principal.SecurityIdentifier])",
+    "    if (-not $sid -or [string]::IsNullOrWhiteSpace($sid.Value)) { return $null }",
+    "    return [string]$sid.Value",
+    "  } catch {",
+    "    return $null",
+    "  }",
+    "}",
+    "function Assert-ZswarmCurrentOwner($task) {",
+    "  $identity = Get-ZswarmIdentity",
+    "  $existingSid = Resolve-ZswarmSid ([string]$task.Principal.UserId)",
+    "  if ([string]::IsNullOrWhiteSpace($existingSid) -or $existingSid -ne $identity.sid) {",
+    "    throw 'a zswarm crew task is owned by a different or unverified Windows account'",
+    "  }",
+    "  return $identity",
+    "}",
+    "function Write-ZswarmJson($obj) {",
+    "  $json = $obj | ConvertTo-Json -Compress -Depth 6",
+    "  [Console]::Out.Write($json)",
+    "}",
+    `function Get-ZswarmTask($name) { Get-ScheduledTask -TaskName $name -TaskPath '${CREW_TASK_FOLDER}' -ErrorAction Stop }`,
+    "function Test-ZswarmMissing($err) {",
+    "  return $err.CategoryInfo.Category -eq 'ObjectNotFound' -or ([string]$err.FullyQualifiedErrorId -match 'ObjectNotFound')",
+    "}",
+].join("\n");
+/** The client scripts do not schedule anything, so they only need JSON output. */
+const PS_CLIENT_PREAMBLE = [
+    "$ErrorActionPreference = 'Stop'",
+    "$ProgressPreference = 'SilentlyContinue'",
+    "[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding $false",
+    "function Write-ZswarmJson($obj) {",
+    "  $json = $obj | ConvertTo-Json -Compress -Depth 6",
+    "  [Console]::Out.Write($json)",
+    "}",
+].join("\n");
+/**
+ * PIDs of our client windows. Image name alone is never identity: the marker
+ * must be in the command line, because every other `powershell.exe` (including
+ * this helper's own `-EncodedCommand` process) has an unrelated command line.
+ */
+function psClientPidLine(marker) {
+    // Match the whole `title <marker> &&` token crewClientCommand writes, not the
+    // bare marker: crew "crew" must never match crew "crew-2"'s window.
+    return `$clientPids = @(Get-CimInstance Win32_Process | Where-Object { ($_.Name -eq 'cmd.exe' -or $_.Name -eq 'powershell.exe') -and $_.CommandLine -and $_.CommandLine.Contains('title ${marker} &&') } | ForEach-Object { [int]$_.ProcessId })`;
+}
+/** Pure PowerShell text, unit-tested by text. */
+export function buildCrewTaskScript(action, params) {
+    const names = crewTaskNames(params.session);
+    if (action === "register") {
+        // Base64 UTF-8 round-trip, exactly like serve's register: neither the
+        // command nor its quoting ever appears in the script text.
+        const startB64 = Buffer.from(params.startCommand ?? "", "utf8").toString("base64");
+        const watchB64 = Buffer.from(params.watchCommand ?? "", "utf8").toString("base64");
+        const interval = Math.max(1, Math.floor(params.intervalMinutes ?? CREW_WATCH_MINUTES));
+        return [
+            PS_PREAMBLE,
+            `$cmd = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${startB64}'))`,
+            `$startName = '${names.start}'`,
+            `$watchName = '${names.watch}'`,
+            "$identity = Get-ZswarmIdentity",
+            "foreach ($name in @($startName, $watchName)) {",
+            "  try {",
+            "    $existing = Get-ZswarmTask $name",
+            "    [void](Assert-ZswarmCurrentOwner $existing)",
+            "  } catch {",
+            "    if (-not (Test-ZswarmMissing $_)) { throw }",
+            "  }",
+            "}",
+            "$userId = $identity.name",
+            // Highest, unlike serve's Limited: the crew must own the desktop session
+            // and its Zellij console window.
+            "$principal = New-ScheduledTaskPrincipal -UserId $userId -LogonType Interactive -RunLevel Highest",
+            "$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable",
+            "$startAction = New-ScheduledTaskAction -Execute 'cmd.exe' -Argument ('/c ' + $cmd)",
+            "$startTrigger = New-ScheduledTaskTrigger -AtLogOn -User $userId",
+            `Register-ScheduledTask -TaskName $startName -TaskPath '${CREW_TASK_FOLDER}' -Action $startAction -Principal $principal -Trigger $startTrigger -Settings $settings -Force | Out-Null`,
+            `$cmd = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${watchB64}'))`,
+            "$watchAction = New-ScheduledTaskAction -Execute 'cmd.exe' -Argument ('/c ' + $cmd)",
+            // A once-trigger with a long repetition is the supported way to run an
+            // interval task for a user; an AtLogOn trigger would only run once.
+            `$watchTrigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -Minutes ${interval}) -RepetitionDuration (New-TimeSpan -Days 3650)`,
+            `Register-ScheduledTask -TaskName $watchName -TaskPath '${CREW_TASK_FOLDER}' -Action $watchAction -Principal $principal -Trigger $watchTrigger -Settings $settings -Force | Out-Null`,
+            "Write-ZswarmJson @{",
+            "  registered = $true",
+            "  userId = $userId",
+            "  userSid = $identity.sid",
+            "  logonType = 'Interactive'",
+            "  runLevel = 'Highest'",
+            `  folder = '${CREW_TASK_FOLDER}'`,
+            "  startTask = $startName",
+            "  watchTask = $watchName",
+            "}",
+        ].join("\n");
+    }
+    if (action === "inspect") {
+        const marker = crewClientMarker(params.session);
+        return [
+            PS_PREAMBLE,
+            `$startName = '${names.start}'`,
+            `$watchName = '${names.watch}'`,
+            `$marker = '${marker}'`,
+            "$tasks = @{}",
+            "foreach ($pair in @(@{ key = 'start'; name = $startName }, @{ key = 'watch'; name = $watchName })) {",
+            "  try {",
+            "    $task = Get-ZswarmTask $pair.name",
+            "  } catch {",
+            "    if (Test-ZswarmMissing $_) {",
+            "      $tasks[$pair.key] = @{ exists = $false; state = 'missing'; lastResult = $null; lastRunTime = $null; userId = $null; userSid = $null; logonType = $null; runLevel = $null; execute = $null; arguments = $null }",
+            "      continue",
+            "    }",
+            "    throw",
+            "  }",
+            "  $action = @($task.Actions)[0]",
+            `  $info = Get-ScheduledTaskInfo -TaskName $pair.name -TaskPath '${CREW_TASK_FOLDER}'`,
+            "  $lastRun = $null",
+            "  if ($info.LastRunTime -and $info.LastRunTime.Year -gt 1900) { $lastRun = $info.LastRunTime.ToString('o') }",
+            "  $tasks[$pair.key] = @{",
+            "    exists = $true",
+            "    state = [string]$task.State",
+            "    lastResult = $info.LastTaskResult",
+            "    lastRunTime = $lastRun",
+            "    userId = [string]$task.Principal.UserId",
+            "    userSid = (Resolve-ZswarmSid ([string]$task.Principal.UserId))",
+            "    logonType = [string]$task.Principal.LogonType",
+            "    runLevel = [string]$task.Principal.RunLevel",
+            "    execute = [string]$action.Execute",
+            "    arguments = [string]$action.Arguments",
+            "  }",
+            "}",
+            psClientPidLine(marker),
+            "Write-ZswarmJson @{",
+            "  start = $tasks['start']",
+            "  watch = $tasks['watch']",
+            "  clientPresent = ($clientPids.Count -gt 0)",
+            "  clientPids = @($clientPids)",
+            "  clientCount = $clientPids.Count",
+            "}",
+        ].join("\n");
+    }
+    if (action === "start") {
+        return [
+            PS_PREAMBLE,
+            `$startName = '${names.start}'`,
+            `$watchName = '${names.watch}'`,
+            "foreach ($name in @($startName, $watchName)) {",
+            "  try {",
+            "    $task = Get-ZswarmTask $name",
+            "    [void](Assert-ZswarmCurrentOwner $task)",
+            `    Start-ScheduledTask -TaskName $name -TaskPath '${CREW_TASK_FOLDER}'`,
+            "  } catch {",
+            "    if (-not (Test-ZswarmMissing $_)) { throw }",
+            "  }",
+            "}",
+            "Write-ZswarmJson @{ started = $true; startTask = $startName; watchTask = $watchName }",
+        ].join("\n");
+    }
+    return [
+        PS_PREAMBLE,
+        `$startName = '${names.start}'`,
+        `$watchName = '${names.watch}'`,
+        "foreach ($name in @($startName, $watchName)) {",
+        "  try {",
+        "    $task = Get-ZswarmTask $name",
+        "    [void](Assert-ZswarmCurrentOwner $task)",
+        "    try {",
+        `      Stop-ScheduledTask -TaskName $name -TaskPath '${CREW_TASK_FOLDER}'`,
+        "    } catch {",
+        "      if (-not (Test-ZswarmMissing $_)) { throw }",
+        "    }",
+        `    Unregister-ScheduledTask -TaskName $name -TaskPath '${CREW_TASK_FOLDER}' -Confirm:$false`,
+        "  } catch {",
+        "    if (-not (Test-ZswarmMissing $_)) { throw }",
+        "  }",
+        "}",
+        "Write-ZswarmJson @{ cleared = $true; startTask = $startName; watchTask = $watchName }",
+    ].join("\n");
+}
+/**
+ * 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 function crewClientCommand(input) {
+    const session = checkSession(input.session);
+    const quote = (value) => `"${value.replace(/"/g, '""')}"`;
+    return `title ${crewClientMarker(session)} && ${quote(input.launch.execPath)} ${quote(input.launch.scriptPath)} crew client ${session}`;
+}
+/** The minimized attached-client window that makes a Windows Zellij session render. */
+export function buildCrewClientScript(action, params) {
+    const session = checkSession(params.session);
+    const marker = crewClientMarker(session);
+    if (action === "ensure") {
+        // `cmd.exe /c <line>`: Start-Process joins -ArgumentList with spaces and
+        // does not re-quote the elements, so cmd.exe gets the whole line as its /c
+        // command with no quoting layers of our own. `title` names the window and
+        // puts the marker in the launcher's command line, which is what later finds
+        // and closes this window. The launcher stays alive while its child runs, so
+        // its process is also the tree `close` kills.
+        const line = params.clientCommand ?? crewClientCommand({
+            session,
+            launch: { execPath: "node", scriptPath: "zswarm" },
+        });
+        return [
+            PS_CLIENT_PREAMBLE,
+            `$marker = '${marker}'`,
+            `$line = '${line.replace(/'/g, "''")}'`,
+            psClientPidLine(marker),
+            "if ($clientPids.Count -gt 0) {",
+            "  Write-ZswarmJson @{ opened = $false; present = $true; pid = $clientPids[0]; title = $marker; count = $clientPids.Count }",
+            "  exit 0",
+            "}",
+            "$proc = Start-Process -FilePath 'cmd.exe' -WindowStyle Minimized -PassThru -ArgumentList @('/c', $line)",
+            "Write-ZswarmJson @{ opened = $true; present = $true; pid = [int]$proc.Id; title = $marker; count = 1 }",
+        ].join("\n");
+    }
+    return [
+        PS_CLIENT_PREAMBLE,
+        `$marker = '${marker}'`,
+        psClientPidLine(marker),
+        "$closed = @()",
+        "foreach ($clientPid in $clientPids) {",
+        "  # The window is the launcher's console, so the tree has to go with it:",
+        "  # /T reaches the attached `zellij` client that shares that console.",
+        "  & taskkill.exe /PID $clientPid /T /F 2>$null | Out-Null",
+        "  $closed += $clientPid",
+        "}",
+        "Write-ZswarmJson @{ closed = @($closed); count = $closed.Count }",
+    ].join("\n");
+}
+/** Last line that parses as a JSON object, else the first; null when none does. */
+export function parseCrewJson(stdout) {
+    let found = null;
+    for (const line of stdout.split(/\r?\n/)) {
+        const text = line.trim();
+        if (!text.startsWith("{") || !text.endsWith("}"))
+            continue;
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            continue;
+        }
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            found = value;
+        }
+    }
+    if (found)
+        return found;
+    // A single pretty-printed object spans lines and never parses per line.
+    const text = stdout.trim();
+    if (!text.startsWith("{") || !text.endsWith("}"))
+        return null;
+    try {
+        const value = JSON.parse(text);
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            return value;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+/**
+ * `powershell -EncodedCommand` costs two bytes of UTF-16 per script character,
+ * then base64 inflates that by 4/3; Windows refuses a command line over ~32k
+ * characters with a bare `ENAMETOOLONG`, so a script that cannot fit is
+ * reported as itself instead of as a spawn failure.
+ */
+const MAX_ENCODED_SCRIPT = 30_000;
+/** Powershell runner used in production; injected in tests. Never throws. */
+export const defaultPowerShellExec = (script, options) => {
+    const timeout = Math.floor(options.timeoutMs);
+    if (timeout <= 0) {
+        return Promise.resolve({ code: 1, stdout: "", stderr: "no remaining budget" });
+    }
+    const encoded = encodePowerShellCommand(script);
+    if (encoded.length > MAX_ENCODED_SCRIPT) {
+        return Promise.resolve({
+            code: 1,
+            stdout: "",
+            stderr: `the generated PowerShell is ${encoded.length} characters, too long for a Windows command line`,
+        });
+    }
+    return new Promise((resolve) => {
+        execFile("powershell.exe", [
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-EncodedCommand",
+            encoded,
+        ], {
+            windowsHide: true,
+            timeout,
+            signal: options.signal,
+            maxBuffer: 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const err = error;
+                const text = String(stderr ?? "").trim();
+                resolve({ code: 1, stdout: String(stdout ?? ""), stderr: text || err.message });
+                return;
+            }
+            resolve({ code: 0, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+        });
+    });
+};
+function crewTimeout(timeoutMs) {
+    return Math.max(1, Math.floor(timeoutMs ?? DEFAULT_CREW_TIMEOUT_MS));
+}
+async function crewRun(run, script, timeoutMs, signal) {
+    const result = await run(script, { timeoutMs, signal });
+    if (result.code !== 0) {
+        const detail = (result.stderr || result.stdout).trim().slice(0, 300);
+        throw new ZellijError("failed", detail || "zswarm crew helper failed");
+    }
+    const parsed = parseCrewJson(result.stdout);
+    if (!parsed)
+        throw new ZellijError("failed", "zswarm crew helper returned no JSON");
+    return parsed;
+}
+function asTaskState(name, task, raw) {
+    const info = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    const exists = info.exists === true;
+    return {
+        name,
+        task,
+        path: `${CREW_TASK_FOLDER}${task}`,
+        state: exists ? String(info.state ?? "Unknown") : "missing",
+        active: exists,
+        lastResult: typeof info.lastResult === "number" ? info.lastResult : null,
+        lastRun: typeof info.lastRunTime === "string" && info.lastRunTime ? info.lastRunTime : null,
+    };
+}
+function clientPids(value) {
+    // A one-element `@(...)` can serialize as a scalar, not an array.
+    if (typeof value === "number" && Number.isFinite(value))
+        return [value];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "number" && Number.isFinite(item));
+}
+export async function inspectCrewTasks(input) {
+    const session = checkSession(input.session);
+    const script = buildCrewTaskScript("inspect", { session });
+    const data = await crewRun(input.runPowerShell, script, crewTimeout(input.timeoutMs), input.signal);
+    const names = crewTaskNames(session);
+    const pids = clientPids(data.clientPids);
+    const count = typeof data.clientCount === "number" && Number.isFinite(data.clientCount)
+        ? data.clientCount
+        : pids.length;
+    return {
+        tasks: [
+            asTaskState("start", names.start, data.start),
+            asTaskState("watch", names.watch, data.watch),
+        ],
+        client: {
+            present: data.clientPresent === true,
+            pid: pids.length > 0 ? pids[0] : null,
+            count,
+        },
+    };
+}
+export async function installCrewTasks(input) {
+    const session = checkSession(input.session);
+    const names = crewTaskNames(session);
+    const intervalMinutes = Math.max(1, Math.floor(input.intervalMinutes ?? CREW_WATCH_MINUTES));
+    const timeoutMs = crewTimeout(input.timeoutMs);
+    const script = buildCrewTaskScript("register", {
+        session,
+        startCommand: input.startCommand,
+        watchCommand: input.watchCommand,
+        intervalMinutes,
+    });
+    await crewRun(input.runPowerShell, script, timeoutMs, input.signal);
+    // Start both now, the way the Linux oneshot unit is started on install: the
+    // start task builds the session and opens the client window; the watchdog's
+    // first run is a no-op while that session is healthy.
+    await crewRun(input.runPowerShell, buildCrewTaskScript("start", { session }), timeoutMs, input.signal);
+    const inspected = await inspectCrewTasks({
+        session,
+        runPowerShell: input.runPowerShell,
+        timeoutMs,
+        signal: input.signal,
+    });
+    return {
+        lines: [
+            `${names.folder}${names.start} registered and started`,
+            `${names.folder}${names.watch} registered and started`,
+        ],
+        notes: [
+            "A Windows scheduled task runs in the signed-in interactive desktop session, so the crew needs a logged-in user: a logoff ends the client window and the session it renders.",
+            `The start task builds the session and keeps an attached client window titled ${names.start}; the watchdog runs crew check every ${intervalMinutes} minute(s) and reopens that window when it is gone.`,
+        ],
+        tasks: inspected.tasks,
+        client: inspected.client,
+    };
+}
+export async function removeCrewTasks(input) {
+    const session = checkSession(input.session);
+    const names = crewTaskNames(session);
+    const timeoutMs = crewTimeout(input.timeoutMs);
+    const script = buildCrewTaskScript("unregister", { session });
+    await crewRun(input.runPowerShell, script, timeoutMs, input.signal);
+    const inspected = await inspectCrewTasks({
+        session,
+        runPowerShell: input.runPowerShell,
+        timeoutMs,
+        signal: input.signal,
+    });
+    return {
+        lines: [`${names.folder}${names.start} removed`, `${names.folder}${names.watch} removed`],
+        tasks: inspected.tasks,
+    };
+}
+export async function ensureCrewClient(input) {
+    const session = checkSession(input.session);
+    const title = crewClientMarker(session);
+    const script = buildCrewClientScript("ensure", { session, clientCommand: input.clientCommand });
+    const data = await crewRun(input.runPowerShell, script, crewTimeout(input.timeoutMs), input.signal);
+    const pid = typeof data.pid === "number" && Number.isFinite(data.pid) ? data.pid : null;
+    const count = typeof data.count === "number" && Number.isFinite(data.count) ? data.count : pid === null ? 0 : 1;
+    return {
+        opened: data.opened === true,
+        pid,
+        title: typeof data.title === "string" && data.title ? data.title : title,
+        present: data.present === true,
+        count,
+    };
+}
+export async function closeCrewClient(input) {
+    const session = checkSession(input.session);
+    const script = buildCrewClientScript("close", { session });
+    const data = await crewRun(input.runPowerShell, script, crewTimeout(input.timeoutMs), input.signal);
+    const closed = clientPids(data.closed);
+    const count = typeof data.count === "number" && Number.isFinite(data.count) ? data.count : closed.length;
+    return { closed, count };
+}

package/dist/host/crew.d.ts

@@ -1,3 +1,4 @@
+import { type PowerShellExec } from "./crew-windows.js";
 import { type Runner, type ServiceAccount, type ServiceHost, type ServiceSpec } from "./services.js";
 export declare const CREW_WATCH_SEC = 120;
 export type CrewDeps = {
@@ -23,6 +24,24 @@ export type CrewDeps = {
     log?: (line: string) => void;
     /** Restarts a systemd user unit (the watchdog on Linux); injected in tests. */
     restartUnit?: (unit: string) => number;
+    /** The account the crew runs for; injected in tests (a win32 account cannot run real tasks in CI). */
+    account?: ServiceAccount;
+    /** Runs the crew's scheduled-task PowerShell on Windows; injected in tests. */
+    runPowerShell?: PowerShellExec;
+    /** The CLI launcher the client window runs; defaults to this process's. */
+    launch?: {
+        execPath: string;
+        scriptPath: string;
+    };
+    /** The attached client window on Windows; injected in tests. */
+    client?: {
+        ensure: (session: string) => Promise<{
+            opened: boolean;
+            pid: number | null;
+            count: number;
+        }>;
+        close: (session: string) => Promise<number[]>;
+    };
 };
 /** Env the Linux watchdog unit carries: restart this unit instead of starting Zellij itself. */
 export declare const CREW_UNIT_ENV = "ZSWARM_CREW_UNIT";
@@ -34,6 +53,13 @@ export declare function firstLayoutPane(kdl: string): string | undefined;
 export declare function parseEnvFile(text: string): Record<string, string>;
 /** Start the session from its layout and prove the first pane exists; up to three tries. */
 export declare function crewStart(session: string, deps?: CrewDeps): Promise<number>;
+/**
+ * `crew client`: what the minimized console window runs. It reads the crew dir
+ * (so an env file's variables reach Zellij without being written into a task or
+ * a command line) and attaches with `--create`, which is what makes a Windows
+ * session render — a background-only session leaves pane grids empty.
+ */
+export declare function crewClient(session: string, deps?: CrewDeps): number;
 /** Watchdog: restart the session if its server died or its first pane is gone. */
 export declare function crewCheck(session: string, deps?: CrewDeps): Promise<number>;
 export type CrewUpInput = {
@@ -54,6 +80,8 @@ export type CrewUpInput = {
     /** Copies crew files into the crew dir; injected in tests. */
     copy?: (account: ServiceAccount, from: string, to: string, secret: boolean) => void;
     writeMeta?: (account: ServiceAccount, path: string, text: string) => void;
+    /** Runs the crew's scheduled-task PowerShell on Windows; injected in tests. */
+    runPowerShell?: PowerShellExec;
 };
 export declare function crewServiceSpecs(input: {
     account: ServiceAccount;
@@ -64,7 +92,7 @@ export declare function crewServiceSpecs(input: {
     };
     env: NodeJS.ProcessEnv;
 }): ServiceSpec[];
-export declare function crewUp(input: CrewUpInput): Record<string, unknown>;
+export declare function crewUp(input: CrewUpInput): Promise<Record<string, unknown>>;
 export declare function crewStatus(input: {
     session: string;
     runAs?: string;
@@ -72,6 +100,7 @@ export declare function crewStatus(input: {
     account?: ServiceAccount;
     run?: Runner;
     deps?: CrewDeps;
+    runPowerShell?: PowerShellExec;
 }): Promise<Record<string, unknown>>;
 export declare function crewDown(input: {
     session: string;
@@ -80,4 +109,5 @@ export declare function crewDown(input: {
     account?: ServiceAccount;
     run?: Runner;
     fs?: ServiceHost["fs"];
-}): Record<string, unknown>;
+    runPowerShell?: PowerShellExec;
+}): Promise<Record<string, unknown>>;

package/dist/host/crew.js

@@ -1,14 +1,15 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { posix } from "node:path";
+import { dirname, posix, win32 } from "node:path";
 import { ZellijError } from "../errors.js";
 import { dispatchZswarm } from "../ops/dispatch.js";
 import { resolveServeCliLaunch } from "../ops/serve-install.js";
 import { defaultStateDir } from "../state.js";
 import { resolveZellijBinary } from "../zellij/binary.js";
+import { closeCrewClient, crewClientCommand, crewClientMarker, crewTaskCommand, defaultPowerShellExec, ensureCrewClient, inspectCrewTasks, installCrewTasks, removeCrewTasks, } from "./crew-windows.js";
 import { defaultRunner, ensureAccountDir, installServices, removeServices, serviceAccount, serviceStates, writeAccountFile, writeSecretFile, } from "./services.js";
-// Service accounts are Linux or macOS accounts: their paths are POSIX paths
-// even when this code runs (in tests) on Windows.
+// Linux and macOS accounts carry POSIX paths even when this code runs (in
+// tests) on Windows; a Windows crew account carries native Windows paths.
 const { join } = posix;
 /**
  * `zswarm crew`: keep a Zellij session built from a layout running on a host.
@@ -23,12 +24,37 @@ const { join } = posix;
  *   status  services, session and panes
  *   down    remove the services and kill the session
  *
+ * On Windows there is no systemd or launchd: `up` registers two Scheduled
+ * Tasks under `\zswarm\` (a start task and a two-minute watchdog running
+ * `crew check`) and the start path keeps an attached client in a minimized
+ * console window, because a background-only Windows session renders empty
+ * panes and drops pasted input.
+ *
  * Zellij now and then starts `attach --create-background --layout` as a
  * plain one-pane session; the first-pane check is what catches that.
  */
 const SESSION = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const FOREIGN_PATH = "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin";
 export const CREW_WATCH_SEC = 120;
+/** The Windows client window: real PowerShell, or the test seam. */
+function windowsClient(deps, env) {
+    if (deps.client)
+        return deps.client;
+    const runPowerShell = deps.runPowerShell ?? defaultPowerShellExec;
+    const launch = deps.launch ?? resolveServeCliLaunch({ env });
+    return {
+        ensure: (session) => ensureCrewClient({
+            session,
+            clientCommand: crewClientCommand({ session, launch }),
+            runPowerShell,
+        }),
+        close: async (session) => (await closeCrewClient({ session, runPowerShell })).closed,
+    };
+}
+/** A task row shaped like the systemd/launchd `services` entries. */
+function taskStateView(task) {
+    return { name: task.name, unit: task.path, state: task.state, active: task.active };
+}
 /** Env the Linux watchdog unit carries: restart this unit instead of starting Zellij itself. */
 export const CREW_UNIT_ENV = "ZSWARM_CREW_UNIT";
 export function checkCrewSession(session) {
@@ -38,8 +64,13 @@ export function checkCrewSession(session) {
     return s;
 }
 export function crewDir(account, session, env = process.env) {
-    const base = !account.foreign && env.ZSWARM_STATE_DIR?.trim() ? defaultStateDir(env) : join(account.home, ".zswarm");
-    return join(base, "crews", session);
+    // A Windows account's home and state dir are native paths; joining them with
+    // posix.join would leave a mixed `C:\Users\x/.zswarm` for Zellij to open.
+    const path = account.platform === "win32" ? win32 : posix;
+    const base = !account.foreign && env.ZSWARM_STATE_DIR?.trim()
+        ? defaultStateDir(env)
+        : path.join(account.home, ".zswarm");
+    return path.join(base, "crews", session);
 }
 /** The first `pane ... name="X"` in a KDL layout: the pane whose presence proves the layout took. */
 export function firstLayoutPane(kdl) {
@@ -72,7 +103,7 @@ export function parseEnvFile(text) {
     return out;
 }
 function readCrewFiles(dir) {
-    const meta = join(dir, "crew.json");
+    const meta = crewFile(dir, "crew.json");
     if (!existsSync(meta))
         throw new ZellijError("usage", `no crew in ${dir}; run zswarm crew up first`);
     return JSON.parse(readFileSync(meta, "utf8"));
@@ -102,15 +133,25 @@ function defaultZellij(args, env) {
     const res = spawnSync(resolveZellijBinary(env), args, { env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 30_000 });
     return { status: res.status ?? 1, stdout: res.stdout ?? "", stderr: res.stderr ?? "" };
 }
+/**
+ * Zellij, sharing this process's console. `attach --create` needs a real
+ * terminal — with a pipe on stdin it exits 0 having created nothing, which is
+ * exactly the "session that never renders" a Windows crew must avoid.
+ */
+function defaultZellijInteractive(args, env) {
+    const res = spawnSync(resolveZellijBinary(env), args, { env, stdio: "inherit" });
+    return { status: res.status ?? 1, stdout: "", stderr: res.error?.message ?? "" };
+}
 function crewEnv(dir, files, env) {
-    const extra = files.env ? parseEnvFile(readFileSync(join(dir, files.env), "utf8")) : {};
+    const extra = files.env ? parseEnvFile(readFileSync(crewFile(dir, files.env), "utf8")) : {};
     // No bus inside the start/check helpers: they list panes once and exit.
     return { ...env, TERM: env.TERM || "xterm-256color", ...extra, ZSWARM_BUS: "0" };
 }
 /** Start the session from its layout and prove the first pane exists; up to three tries. */
 export async function crewStart(session, deps = {}) {
     const env0 = deps.env ?? process.env;
-    const dir = deps.dir ?? crewDir(serviceAccount(undefined), checkCrewSession(session), env0);
+    const account = deps.account ?? serviceAccount(undefined);
+    const dir = deps.dir ?? crewDir(account, checkCrewSession(session), env0);
     const files = readCrewFiles(dir);
     const env = crewEnv(dir, files, env0);
     const zellij = deps.zellij ?? defaultZellij;
@@ -118,10 +159,37 @@ export async function crewStart(session, deps = {}) {
     const panes = deps.panes ?? defaultPanes;
     const sleep = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
     const log = deps.log ?? ((line) => process.stdout.write(`${new Date().toISOString()} ${line}\n`));
-    const config = files.config ? ["--config", join(dir, files.config)] : [];
+    const config = files.config ? ["--config", crewFile(dir, files.config)] : [];
+    if (account.platform === "win32") {
+        // Windows: a session created with `attach --create-background` renders
+        // empty panes and drops pasted input, so the session is created BY an
+        // attached client instead — a minimized console window running
+        // `zellij --layout ... attach --create`, which `crew client` starts. That
+        // window is also what the watchdog reopens when it dies.
+        const client = windowsClient(deps, env);
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            zellij(["delete-session", session], env); // clears only a dead session of this name
+            await client.close(session); // a window left over from the previous attempt
+            const opened = await client.ensure(session);
+            log(`client window ${opened.opened ? "opened" : "already open"} for ${session}`);
+            for (let i = 0; i < 30 && !(await sessions(env)).includes(session); i++)
+                await sleep(1_000);
+            await sleep(3_000);
+            if ((await panes(session, env)).some((p) => p.title === files.first)) {
+                log(`session ${session} up in window ${crewClientMarker(session)} (attempt ${attempt})`);
+                return 0;
+            }
+            log(`session ${session} came up without its layout (attempt ${attempt}); recreating`);
+            zellij(["kill-session", session], env);
+            await client.close(session);
+            await sleep(1_000);
+        }
+        log(`session ${session} never took its layout`);
+        return 1;
+    }
     for (let attempt = 1; attempt <= 3; attempt++) {
         zellij(["delete-session", session], env); // clears only a dead session of this name
-        zellij([...config, "--layout", join(dir, files.layout), "attach", "--create-background", session], env);
+        zellij([...config, "--layout", crewFile(dir, files.layout), "attach", "--create-background", session], env);
         for (let i = 0; i < 20 && !(await sessions(env)).includes(session); i++)
             await sleep(500);
         await sleep(2_000);
@@ -136,16 +204,63 @@ export async function crewStart(session, deps = {}) {
     log(`session ${session} never took its layout`);
     return 1;
 }
+/**
+ * Zellij's own client variables. A client started from inside a pane inherits
+ * `ZELLIJ=0`, `ZELLIJ_SESSION_NAME`, ...; a nested client then exits without
+ * creating anything. The console window is opened from whatever process asked
+ * for the crew (an agent pane, a scheduled task), so strip them all.
+ */
+const ZELLIJ_CLIENT_ENV = /^ZELLIJ(_|$)/;
+function withoutZellijClientEnv(env) {
+    const out = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (ZELLIJ_CLIENT_ENV.test(key))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * `crew client`: what the minimized console window runs. It reads the crew dir
+ * (so an env file's variables reach Zellij without being written into a task or
+ * a command line) and attaches with `--create`, which is what makes a Windows
+ * session render — a background-only session leaves pane grids empty.
+ */
+export function crewClient(session, deps = {}) {
+    const env0 = deps.env ?? process.env;
+    const account = deps.account ?? serviceAccount(undefined);
+    const dir = deps.dir ?? crewDir(account, checkCrewSession(session), env0);
+    const files = readCrewFiles(dir);
+    const env = withoutZellijClientEnv(crewEnv(dir, files, env0));
+    const args = [
+        ...(files.config ? ["--config", crewFile(dir, files.config)] : []),
+        "--layout", crewFile(dir, files.layout),
+        "attach", "--create", session,
+    ];
+    // OSC 0 titles the console window; the marker is how status and down find it.
+    // Only on a real console — a piped run (tests, logs) has no window to title.
+    if (process.stdout.isTTY)
+        process.stdout.write(`\u001b]0;${crewClientMarker(session)}\u0007`);
+    return (deps.zellij ?? defaultZellijInteractive)(args, env).status;
+}
 /** Watchdog: restart the session if its server died or its first pane is gone. */
 export async function crewCheck(session, deps = {}) {
     const env0 = deps.env ?? process.env;
-    const dir = deps.dir ?? crewDir(serviceAccount(undefined), checkCrewSession(session), env0);
+    const account = deps.account ?? serviceAccount(undefined);
+    const dir = deps.dir ?? crewDir(account, checkCrewSession(session), env0);
     const files = readCrewFiles(dir);
     const env = crewEnv(dir, files, env0);
     const sessions = deps.sessions ?? defaultSessions;
     const panes = deps.panes ?? defaultPanes;
     const log = deps.log ?? ((line) => process.stdout.write(`${new Date().toISOString()} ${line}\n`));
     if ((await sessions(env)).includes(session) && (await panes(session, env)).some((p) => p.title === files.first)) {
+        if (account.platform === "win32") {
+            // The session surviving is not enough on Windows: without the attached
+            // client window its panes render empty, so the watchdog reopens it.
+            const opened = await windowsClient(deps, env).ensure(session);
+            if (opened.opened)
+                log(`client window reopened for ${session}`);
+        }
         return 0;
     }
     log(`session ${session} is gone or lost its layout; restarting`);
@@ -159,8 +274,26 @@ export async function crewCheck(session, deps = {}) {
     }
     return await crewStart(session, deps);
 }
+/** A file inside a crew dir, which is a Windows path for a win32 account. */
+function crewFile(dir, name) {
+    return dir.includes("\\") ? win32.join(dir, name) : join(dir, name);
+}
+/**
+ * The env a Windows crew task action reproduces. Not the whole caller env (it
+ * can hold tokens) and not PATH (the interactive task inherits the user's, and
+ * a host PATH would not fit in a Windows command line).
+ */
+function crewTaskEnv(env) {
+    const out = {};
+    for (const key of ["ZSWARM_BIN", "ZSWARM_STATE_DIR"]) {
+        const value = env[key]?.trim();
+        if (value)
+            out[key] = value;
+    }
+    return out;
+}
 function copyForAccount(account, from, to, secret) {
-    ensureAccountDir(account, to.slice(0, to.lastIndexOf("/")));
+    ensureAccountDir(account, dirname(to));
     if (secret) {
         writeSecretFile(account, to, readFileSync(from, "utf8"));
         return;
@@ -203,7 +336,7 @@ export function crewServiceSpecs(input) {
         },
     ];
 }
-export function crewUp(input) {
+export async function crewUp(input) {
     const env = input.env ?? process.env;
     const run = input.run ?? defaultRunner;
     const account = input.account ?? serviceAccount(input.runAs, run);
@@ -219,17 +352,42 @@ export function crewUp(input) {
     const dir = crewDir(account, session, env);
     const copy = input.copy ?? copyForAccount;
     const files = { layout: "layout.kdl", first };
-    copy(account, input.layout, join(dir, "layout.kdl"), false);
+    copy(account, input.layout, crewFile(dir, "layout.kdl"), false);
     if (input.config) {
-        copy(account, input.config, join(dir, "config.kdl"), false);
+        copy(account, input.config, crewFile(dir, "config.kdl"), false);
         files.config = "config.kdl";
     }
     if (input.envFile) {
-        copy(account, input.envFile, join(dir, "env"), true);
+        copy(account, input.envFile, crewFile(dir, "env"), true);
         files.env = "env";
     }
     // crew.json is written last, so a half-copied crew never starts.
-    (input.writeMeta ?? writeSecretFile)(account, join(dir, "crew.json"), `${JSON.stringify(files, null, 1)}\n`);
+    (input.writeMeta ?? writeSecretFile)(account, crewFile(dir, "crew.json"), `${JSON.stringify(files, null, 1)}\n`);
+    if (account.platform === "win32") {
+        // Windows has no systemd/launchd: two Scheduled Tasks (a start task and a
+        // two-minute watchdog) plus the minimized client window the start task
+        // opens, because a background-only session renders empty panes.
+        const taskEnv = crewTaskEnv(env);
+        const installed = await installCrewTasks({
+            session,
+            startCommand: crewTaskCommand({ launch, mode: "start", session, env: taskEnv }),
+            watchCommand: crewTaskCommand({ launch, mode: "check", session, env: taskEnv }),
+            runPowerShell: input.runPowerShell ?? defaultPowerShellExec,
+        });
+        const states = installed.tasks.map(taskStateView);
+        return {
+            session,
+            user: account.user,
+            dir,
+            firstPane: first,
+            services: states,
+            ready: states.every((s) => s.active),
+            tasks: installed.tasks,
+            clientWindow: installed.client,
+            actions: installed.lines,
+            notes: installed.notes,
+        };
+    }
     const specs = crewServiceSpecs({ account, session, launch, env });
     const done = installServices({ account, run, fs: input.fs }, specs);
     const states = serviceStates({ account, run }, specs);
@@ -249,14 +407,28 @@ export async function crewStatus(input) {
     const run = input.run ?? defaultRunner;
     const account = input.account ?? serviceAccount(input.runAs, run);
     const session = checkCrewSession(input.session);
-    const specs = crewServiceSpecs({ account, session, launch: { execPath: "", scriptPath: "" }, env });
-    const services = serviceStates({ account, run }, specs);
-    const out = { session, user: account.user, services };
+    const out = { session, user: account.user };
     if (account.foreign) {
+        const specs = crewServiceSpecs({ account, session, launch: { execPath: "", scriptPath: "" }, env });
+        out.services = serviceStates({ account, run }, specs);
         out.note = `session and panes belong to ${account.user}: run zswarm crew status ${session} as that user`;
         return out;
     }
-    const files = existsSync(join(crewDir(account, session, env), "crew.json"))
+    let client = null;
+    if (account.platform === "win32") {
+        const inspected = await inspectCrewTasks({
+            session,
+            runPowerShell: input.runPowerShell ?? defaultPowerShellExec,
+        });
+        out.services = inspected.tasks.map(taskStateView);
+        client = inspected.client;
+        out.clientWindow = inspected.client;
+    }
+    else {
+        const specs = crewServiceSpecs({ account, session, launch: { execPath: "", scriptPath: "" }, env });
+        out.services = serviceStates({ account, run }, specs);
+    }
+    const files = existsSync(crewFile(crewDir(account, session, env), "crew.json"))
         ? readCrewFiles(crewDir(account, session, env))
         : undefined;
     const live = (await (input.deps?.sessions ?? defaultSessions)(env)).includes(session);
@@ -267,17 +439,34 @@ export async function crewStatus(input) {
     out.firstPane = files?.first ?? null;
     out.layoutTook = files ? panes.some((p) => p.title === files.first) : null;
     out.panes = panes;
-    out.healthy = services.every((s) => s.active) && live && out.layoutTook !== false && panes.every((p) => !p.exited);
+    out.healthy =
+        out.services.every((s) => s.active) &&
+            live &&
+            out.layoutTook !== false &&
+            panes.every((p) => !p.exited) &&
+            (client ? client.present : true);
     if (live && exited) {
         out.note = `an exited session named ${session} is also listed (resurrectable); remove it with zswarm sessions --prune-exited`;
     }
     return out;
 }
-export function crewDown(input) {
+export async function crewDown(input) {
     const env = input.env ?? process.env;
     const run = input.run ?? defaultRunner;
     const account = input.account ?? serviceAccount(input.runAs, run);
     const session = checkCrewSession(input.session);
+    if (account.platform === "win32") {
+        const runPowerShell = input.runPowerShell ?? defaultPowerShellExec;
+        const removed = await removeCrewTasks({ session, runPowerShell });
+        const lines = [...removed.lines];
+        const closed = await closeCrewClient({ session, runPowerShell });
+        lines.push(closed.closed.length > 0
+            ? `client window closed (pids ${closed.closed.join(", ")})`
+            : "no client window was open");
+        const kill = run(resolveZellijBinary(env), ["kill-session", session]);
+        lines.push(kill.status === 0 ? `session ${session} killed` : `session ${session} was not running`);
+        return { session, user: account.user, actions: lines };
+    }
     const specs = crewServiceSpecs({ account, session, launch: { execPath: "", scriptPath: "" }, env });
     const lines = removeServices({ account, run, fs: input.fs }, specs);
     // The Zellij server belongs to the account: kill it as that user.

package/dist/host/services.d.ts

@@ -2,9 +2,12 @@
  * Background services for host commands (serve, crew): systemd user units
  * on Linux (with linger, so they run without a login), launchd on macOS (a
  * LaunchAgent for the current user, or, from root with `runAs`, a
- * LaunchDaemon that runs as that user, for accounts that never log in).
- * Secrets never go into unit files or plists: services read them from
- * mode-600 files named in their environment.
+ * LaunchDaemon that runs as that user, for accounts that never log in). On
+ * Windows there is no systemd or launchd here: `serviceAccount` returns the
+ * signed-in user (`platform: "win32"`, uid/gid 0) so crew can install a
+ * scheduled task instead, and `--run-as` is refused. Secrets never go into
+ * unit files or plists: services read them from mode-600 files named in
+ * their environment.
  */
 export type ServiceKind = 
 /** Long-running; restarted when it exits. */
@@ -31,7 +34,7 @@ export type ServiceSpec = {
     workingDir?: string;
 };
 export type ServiceAccount = {
-    platform: "linux" | "darwin";
+    platform: "linux" | "darwin" | "win32";
     user: string;
     uid: number;
     gid: number;

package/dist/host/services.js

@@ -1,10 +1,10 @@
 import { spawnSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, userInfo } from "node:os";
-import { posix } from "node:path";
+import { dirname, posix } from "node:path";
 import { ZellijError } from "../errors.js";
-// Service accounts are Linux or macOS accounts: their paths are POSIX paths
-// even when this code runs (in tests) on Windows.
+// Linux and macOS accounts carry POSIX paths even when this code runs (in
+// tests) on Windows; a Windows crew account carries native Windows paths.
 const { join } = posix;
 const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,80}$/;
 export const defaultRunner = (cmd, args) => {
@@ -22,6 +22,12 @@ function hostSleep(host, ms) {
 /** The account services are installed for: the current user, or `runAs` when root. */
 export function serviceAccount(runAs, run = defaultRunner) {
     const platform = process.platform;
+    if (platform === "win32") {
+        if (runAs?.trim()) {
+            throw new ZellijError("usage", "--run-as is Linux and macOS only; a Windows crew task runs as the signed-in user");
+        }
+        return { platform: "win32", user: userInfo().username, uid: 0, gid: 0, home: process.env.USERPROFILE || homedir(), foreign: false };
+    }
     if (platform !== "linux" && platform !== "darwin") {
         throw new ZellijError("usage", `host services are for Linux and macOS (this is ${platform}); on Windows use serve --install`);
     }
@@ -72,6 +78,10 @@ function runAsAccount(account, argv, input) {
 }
 /** Write a file in the account's home as the account (see accountArgv). */
 export function writeAccountFile(account, path, text, mode) {
+    if (account.platform === "win32") {
+        writeFileSync(path, text);
+        return;
+    }
     if (!installingFor(account)) {
         writeFileSync(path, text, { mode });
         chmodSync(path, mode);
@@ -416,6 +426,10 @@ function must(res, what) {
 }
 /** Create dir and any missing parents, owned by the account when installing for it. */
 export function ensureAccountDir(account, dir, mode = 0o700) {
+    if (account.platform === "win32") {
+        mkdirSync(dir, { recursive: true });
+        return;
+    }
     const missing = [];
     for (let d = dir; d && d !== "/" && !existsSync(d); d = d.slice(0, d.lastIndexOf("/")) || "/")
         missing.unshift(d);
@@ -428,7 +442,7 @@ export function ensureAccountDir(account, dir, mode = 0o700) {
 }
 /** Write a mode-600 file for the account, creating its directory (700) as needed. */
 export function writeSecretFile(account, path, text) {
-    ensureAccountDir(account, path.slice(0, path.lastIndexOf("/")));
+    ensureAccountDir(account, dirname(path));
     writeAccountFile(account, path, text, 0o600);
 }
 export function readSecretFile(path) {

package/dist/index.d.ts

@@ -34,6 +34,6 @@ export { HOST_COMMANDS, hostUsage, parseHostArgs, runHostCommand } from "./host/
 export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, type ServeServiceInput, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, type Runner, type ServiceAccount, type ServiceHost, type ServiceKind, type ServiceSpec, type ServiceState, } from "./host/services.js";
-export { crewCheck, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, type CrewDeps, type CrewUpInput, } from "./host/crew.js";
+export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, type CrewDeps, type CrewUpInput, } from "./host/crew.js";
 export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, type RelayAdminDeps, type RelayCancelResult, type RelayConfig, type RelayDeps, type RelayJob, type RelayJobRunner, type RelayRow, type RelayStartInput, type RelayStatus, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, type HostCheck, type HostDoctorInput, type HostInstallInput, type SshRunner, } from "./host/host.js";

package/dist/index.js

@@ -32,6 +32,6 @@ export { HOST_COMMANDS, hostUsage, parseHostArgs, runHostCommand } from "./host/
 export { findPython, runSlot, slotScriptPath } from "./host/slot.js";
 export { installServeService, serveServiceName, serveServiceSpec, serveTokenFromEnv, serveTokenPath, uninstallServeService, SERVE_AWAIT_SESSION_ENV, SERVE_TOKEN_FILE_ENV, } from "./host/serve-service.js";
 export { accountArgv, installServices, launchdLabel, launchdPlist, removeServices, serviceAccount, serviceStates, systemdUnitName, systemdUnits, writeAccountFile, } from "./host/services.js";
-export { crewCheck, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, } from "./host/crew.js";
+export { crewCheck, crewClient, crewDir, crewDown, crewServiceSpecs, crewStart, crewStatus, crewUp, firstLayoutPane, parseEnvFile, CREW_UNIT_ENV, CREW_WATCH_SEC, } from "./host/crew.js";
 export { cancelAllTo, cancelRelay, deliverMessage, doneLines, fillMessage, freshDoneLine, launchRelay, listRelays, prepareRelay, pruneRelays, relayLoop, relaysDir, runRelayDir, scrubRelayToken, startRelay, waitForRelay, } from "./host/relay.js";
 export { hostChecks, hostDoctor, hostInstall, hostInstallArgs, hostScriptPath, parseHostReport, } from "./host/host.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zswarm/core",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "type": "module",
   "description": "zSwarm Zellij client and shared ops dispatch",
   "exports": {