CLI service: automate the Windows Task Scheduler backend

Windows was a printed scaffold; make `executor service install` actually
register and supervise the daemon, matching macOS (launchd) and Linux
(systemd). Verified end-to-end on a real Windows host: install works, the
daemon auto-starts after a reboot with no interactive login, and a registered
integration's data survives the reboot.

- Task Scheduler backend (S4U + AtStartup): runs the daemon as the user, at
  boot, with no stored password and no interactive logon — the Windows analog
  of launchd RunAtLoad / systemd linger. A `.cmd` wrapper carries the
  supervised env (Task Scheduler has no env field); values are sanitized for
  cmd.exe (strip `"`, double `%`) so a hostile PATH entry can't inject a
  command at boot. Registration runs via PowerShell -EncodedCommand.
- isDevCliEntrypoint: recognize Bun's Windows embedded-binary path
  (`B:\~BUN\root\...`), anchored to a drive root, so a real executor.exe is
  not misread as a dev checkout and refused.
- `executor call <path> @file.json`: read a tool's JSON input from a file,
  the cross-platform equivalent of `"$(cat f)"` — PowerShell mangles inline
  JSON passed to a native binary. resolveToolInvocation moves to tooling.ts.
- win32 install now flows through the automated path (writes the 0600
  service.key, waits for reachability) instead of printing manual steps.

Adds unit tests for dev-entrypoint detection, the wrapper/register-script
generators, cmd value sanitization, and the @file path.

Author: RhysSullivan

apps/cli/src/daemon.test.ts

@@ -3,7 +3,38 @@ import { createServer, type Server } from "node:http";
 import type { AddressInfo } from "node:net";
 import * as Effect from "effect/Effect";
 
-import { canAutoStartLocalDaemonForHost, isExecutorServerReachable } from "./daemon";
+import {
+  canAutoStartLocalDaemonForHost,
+  isDevCliEntrypoint,
+  isExecutorServerReachable,
+} from "./daemon";
+
+describe("isDevCliEntrypoint", () => {
+  it("treats source entrypoints as dev", () => {
+    expect(isDevCliEntrypoint("/Users/x/src/executor/apps/cli/src/main.ts")).toBe(true);
+    expect(isDevCliEntrypoint("/Users/x/dist/main.js")).toBe(true);
+  });
+
+  it("treats compiled single-file binaries as NOT dev (both Unix and Windows)", () => {
+    // Bun's embedded filesystem: `/$bunfs/...` on Unix, `B:\~BUN\...` on Windows.
+    // Missing the Windows form made a real `executor.exe` look like a dev
+    // checkout, so `service install` wrongly refused on Windows.
+    expect(isDevCliEntrypoint("/$bunfs/root/main.js")).toBe(false);
+    expect(isDevCliEntrypoint("B:/~BUN/root/main.js")).toBe(false);
+    expect(isDevCliEntrypoint("B:\\~BUN\\root\\main.js")).toBe(false);
+  });
+
+  it("only treats a DRIVE-ROOTED ~BUN as compiled (a ~BUN dir mid-tree stays dev)", () => {
+    // The Windows bunfs root is `<drive>:\~BUN\...`; a dev checkout that merely
+    // contains a `~BUN` directory must not be misread as a compiled binary.
+    expect(isDevCliEntrypoint("/home/user/~BUN/project/src/main.ts")).toBe(true);
+    expect(isDevCliEntrypoint("C:/Users/dev/~BUN/src/main.ts")).toBe(true);
+  });
+
+  it("is false when no entrypoint is known", () => {
+    expect(isDevCliEntrypoint(undefined)).toBe(false);
+  });
+});
 
 describe("canAutoStartLocalDaemonForHost", () => {
   it("allows loopback hosts", () => {

apps/cli/src/daemon.ts

@@ -54,15 +54,32 @@ export const parseDaemonBaseUrl = (baseUrl: string, defaultPort: number): Parsed
 // ---------------------------------------------------------------------------
 
 const LOCAL_DAEMON_HOSTNAMES = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
-const BUN_EMBEDDED_ENTRYPOINT_PREFIX = "/$bunfs/";
 
 export const canAutoStartLocalDaemonForHost = (hostname: string): boolean =>
   LOCAL_DAEMON_HOSTNAMES.has(hostname.toLowerCase());
 
+/**
+ * Bun's compiled-binary embedded filesystem root, drive-rooted on Windows
+ * (`B:\~BUN\root\...`, argv normalized to `B:/~BUN/root/...`). Anchored to a
+ * drive prefix so a dev checkout that merely *contains* a `~BUN` directory
+ * isn't misread as a compiled binary.
+ */
+const WINDOWS_BUNFS_ENTRYPOINT = /^[a-z]:\/~BUN\//i;
+
+/**
+ * Whether the process is running from the dev source (`bun run src/main.ts`)
+ * rather than a compiled single-file binary. A compiled binary runs from Bun's
+ * embedded filesystem, whose entrypoint is `/$bunfs/root/main.js` on Unix but
+ * `B:\~BUN\root\main.js` (argv like `B:/~BUN/root/main.js`) on Windows — match
+ * BOTH. Missing the Windows form made a real `executor.exe` look like a dev
+ * checkout, so `service install` refused on Windows. (Found by a real EC2
+ * Windows test.)
+ */
 export const isDevCliEntrypoint = (scriptPath: string | undefined): boolean => {
   if (!scriptPath) return false;
-  if (scriptPath.startsWith(BUN_EMBEDDED_ENTRYPOINT_PREFIX)) return false;
-  return scriptPath.endsWith(".ts") || scriptPath.endsWith(".js");
+  const normalized = scriptPath.replaceAll("\\", "/");
+  if (normalized.startsWith("/$bunfs/") || WINDOWS_BUNFS_ENTRYPOINT.test(normalized)) return false;
+  return normalized.endsWith(".ts") || normalized.endsWith(".js");
 };
 
 export const isExecutorServerReachable = (

apps/cli/src/main.ts

@@ -114,7 +114,6 @@ import {
 } from "./server-profile";
 import {
   buildResumeContentTemplate,
-  buildToolPath,
   buildDescribeToolCode,
   filterToolPathChildren,
   buildInvokeToolCode,
@@ -126,6 +125,7 @@ import {
   inspectToolPath,
   normalizeCliErrorText,
   parseJsonObjectInput,
+  resolveToolInvocation,
   sanitizeCliOutputText,
   shellQuoteArg,
 } from "./tooling";
@@ -1602,38 +1602,6 @@ const runCallHelp = (
     });
   }).pipe(Effect.mapError(toError));
 
-const resolveToolInvocation = (input: {
-  rawPathParts: ReadonlyArray<string>;
-}): Effect.Effect<{ path: string; args: Record<string, unknown> }, Error> =>
-  Effect.gen(function* () {
-    if (!Array.isArray(input.rawPathParts)) {
-      return yield* Effect.fail(
-        new Error("Invalid tool invocation: path parts were not parsed as an array"),
-      );
-    }
-
-    const maybeJsonArg = input.rawPathParts.at(-1)?.trim();
-    const hasInlineJsonArg = maybeJsonArg !== undefined && maybeJsonArg.startsWith("{");
-    const pathParts = hasInlineJsonArg ? input.rawPathParts.slice(0, -1) : input.rawPathParts;
-    const args = hasInlineJsonArg ? yield* parseJsonObjectInput(maybeJsonArg) : {};
-
-    if (pathParts.some((part) => part.trim().startsWith("-"))) {
-      return yield* Effect.fail(
-        new Error(
-          "Tool invocation no longer accepts flags. Use: executor call <path...> '{...json...}'",
-        ),
-      );
-    }
-
-    const path = yield* Effect.try({
-      try: () => buildToolPath(pathParts),
-      catch: (cause) =>
-        cause instanceof Error ? cause : new Error(`Invalid tool path: ${String(cause)}`),
-    });
-
-    return { path, args };
-  });
-
 // ---------------------------------------------------------------------------
 // Commands
 // ---------------------------------------------------------------------------
@@ -2198,7 +2166,7 @@ const serviceInstallCommand = Command.make(
 
       const backend = getServiceBackend();
       if (!backend.automated) {
-        // win32 / unsupported: the backend surfaces manual steps via its error.
+        // Unsupported platforms surface their manual steps via the install error.
         yield* backend.install({ executablePath: process.execPath, port, version: CLI_VERSION });
         return;
       }

apps/cli/src/service.test.ts

@@ -1,10 +1,12 @@
 import { describe, expect, it } from "@effect/vitest";
 
 import {
+  cmdSetValue,
   generateLaunchdPlist,
   generateSystemdUnit,
+  generateWindowsDaemonWrapper,
+  generateWindowsRegisterScript,
   getServiceBackend,
-  windowsScheduledTaskCommand,
 } from "./service";
 
 describe("service unit generation", () => {
@@ -76,15 +78,50 @@ describe("service unit generation", () => {
     expect(unit).not.toContain("EXECUTOR_AUTH_PASSWORD");
   });
 
-  it("produces a Windows scheduled-task command", () => {
-    const cmd = windowsScheduledTaskCommand({
-      executablePath: "C:/Program Files/Executor/executor.exe",
-      port: 4789,
-      version: "1.5.10",
+  it("bakes the supervised env into the Windows wrapper .cmd", () => {
+    const wrapper = generateWindowsDaemonWrapper(
+      {
+        executablePath: "C:\\Program Files\\Executor\\executor.exe",
+        port: 4789,
+        version: "1.5.10",
+      },
+      "C:\\Users\\x\\.executor",
+      "C:\\Users\\x\\.executor\\logs",
+    );
+    // Task Scheduler can't set env, so it rides as `set` lines in the wrapper.
+    expect(wrapper).toContain('set "EXECUTOR_SUPERVISED=1"');
+    expect(wrapper).toContain('set "EXECUTOR_DATA_DIR=C:\\Users\\x\\.executor"');
+    expect(wrapper).toContain(
+      '"C:\\Program Files\\Executor\\executor.exe" daemon run --foreground --port 4789',
+    );
+    expect(wrapper).toContain('1>> "C:\\Users\\x\\.executor\\logs\\daemon.log"');
+    // The secret is never baked into the wrapper — the daemon reads service.key.
+    expect(wrapper).not.toContain("EXECUTOR_AUTH_PASSWORD");
+  });
+
+  it("sanitizes cmd.exe metacharacters in baked env values (cmdSetValue)", () => {
+    // A `"` in PATH would close the `set "PATH=..."` quote early and let a
+    // `& cmd &` fragment run at boot as the user; strip it (illegal in a path
+    // anyway). A `%` would re-expand against the boot environment; double it.
+    expect(cmdSetValue('C:\\a" & evil & "C:\\b')).toBe("C:\\a & evil & C:\\b");
+    expect(cmdSetValue("C:\\tools\\%LOCALAPPDATA%\\bin")).toBe("C:\\tools\\%%LOCALAPPDATA%%\\bin");
+    expect(cmdSetValue("C:\\Program Files\\node")).toBe("C:\\Program Files\\node");
+    // The sanitized value, embedded in a `set` line, can't break out of quotes.
+    expect(`set "PATH=${cmdSetValue('a"&b')}"`).not.toMatch(/"\s*&/);
+  });
+
+  it("registers a boot-triggered S4U task (the reboot-survival contract)", () => {
+    const script = generateWindowsRegisterScript({
+      taskName: "ExecutorDaemon",
+      wrapperPath: "C:\\Users\\x\\.executor\\server-control\\run-daemon.cmd",
+      userId: "x",
     });
-    expect(cmd).toContain("schtasks /Create");
-    expect(cmd).toContain("ONLOGON");
-    expect(cmd).toContain("--port 4789");
+    // S4U + AtStartup = run as the user, at boot, no stored password, no logon.
+    expect(script).toContain("-LogonType S4U");
+    expect(script).toContain("New-ScheduledTaskTrigger -AtStartup");
+    expect(script).toContain("-RestartCount 3");
+    expect(script).toContain("Register-ScheduledTask -TaskName 'ExecutorDaemon'");
+    expect(script).toContain("Start-ScheduledTask -TaskName 'ExecutorDaemon'");
   });
 });
 
@@ -99,10 +136,10 @@ describe("service backend dispatch", () => {
     expect(getServiceBackend("linux").platform).toBe("linux");
   });
 
-  it("is a guided (non-automated) backend on windows", () => {
+  it("selects Task Scheduler on windows (automated)", () => {
     const backend = getServiceBackend("win32");
     expect(backend.platform).toBe("win32");
-    expect(backend.automated).toBe(false);
+    expect(backend.automated).toBe(true);
   });
 
   it("falls back to unsupported on other platforms", () => {