@mostra/cli 0.2.0 → 0.4.0

package/dist/run-DdLe9hN3.js

@@ -0,0 +1,2 @@
+import { t as run } from "./run-DP-RoOv_.js";
+export { run };

package/dist/telemetry/flush-main.js

@@ -1,4 +1,4 @@
-import { r as TelemetryStore, t as flush } from "../flush-BCuWs0Zh.js";
+import { r as TelemetryStore, t as flush } from "../flush-C2lroV03.js";
 //#region src/telemetry/flush-main.ts
 /**
 * The flusher process (D140 item 6): `node flush-main.js <config dir>`, started detached by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mostra/cli",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "The mostra command: author, verify, publish, share and wait on agent artifacts, as a thin client of the Mostra host protocol.",
   "license": "Apache-2.0",
   "author": "The Mostra Authors",
@@ -34,12 +34,12 @@
     "provenance": true
   },
   "dependencies": {
-    "@mostra/protocol": "0.2.0",
-    "@mostra/sdk": "0.2.0",
+    "@mostra/protocol": "0.4.0",
+    "@mostra/sdk": "0.4.0",
     "zod": "4.6.5"
   },
   "devDependencies": {
-    "@mostra/runtime": "0.2.0",
+    "@mostra/runtime": "0.4.0",
     "@mostra/tools": "0.0.0",
     "@types/node": "24.19.1",
     "tsdown": "0.23.0",

package/src/browser.ts

@@ -3,13 +3,16 @@
  * review finding 4). A program's arguments are readable by every local user (`ps`,
  * `/proc/<pid>/cmdline`), so the opener gets the path of a page that redirects to the launch URL,
  * written mode 0600 in a fresh directory of mode 0700, as Jupyter's server does for its token.
- * The launch ticket in the page is single-use and lives a minute, so a page left behind is
- * harmless; each launch removes the ones older than that.
+ * Windows has no modes: there the page goes under the user's own profile
+ * (`%LOCALAPPDATA%\mostra-cli\open`), whose access list only the user, `SYSTEM` and
+ * administrators pass, never under `%TEMP%`, which may name a folder other users can read (Opus
+ * review of WP-W2, finding 1). The launch ticket in the page is single-use and lives a minute, so a
+ * page left behind is harmless; each launch removes the ones older than that.
  */
 import { spawn } from "node:child_process";
-import { lstatSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join, win32 } from "node:path";
 import type { Environment } from "./home.ts";
 
 /** The prefix of the directories launch pages live in. */
@@ -121,10 +124,48 @@ export function splitCommand(command: string): string[] {
   return words;
 }
 
+/** The program that opens a file with its default application, by platform. */
+function platformOpener(platform: string): string[] {
+  if (platform === "darwin") return ["open"];
+  // Explorer opens a path with the program associated with its type, `.html` with the default
+  // browser, as a double click would (VERIFIED_FACTS, WP-W2); its arguments go to it directly,
+  // never through `cmd`.
+  if (platform === "win32") return ["explorer.exe"];
+  return ["xdg-open"];
+}
+
+/**
+ * Splits a command as Windows programs read their command lines, for `$BROWSER` there: words
+ * separated by spaces, double quotes grouping words with spaces (`"C:\Program Files\Firefox\
+ * firefox.exe" %s`), and backslashes kept as they are.
+ */
+export function splitWindowsCommand(command: string): string[] {
+  const words: string[] = [];
+  let word = "";
+  let inWord = false;
+  let quoted = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      inWord = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (inWord) words.push(word);
+      word = "";
+      inWord = false;
+    } else {
+      word += char;
+      inWord = true;
+    }
+  }
+  if (inWord) words.push(word);
+  return words;
+}
+
 /**
- * The commands that may open `target`, in order: each entry of `$BROWSER` (separated by `:`, its
- * `%s` replaced by the target, else the target appended, `%%` a literal `%`, as `xdg-open` and
- * Python's `webbrowser` read it), else the platform's opener.
+ * The commands that may open `target`, in order: each entry of `$BROWSER` (separated by the
+ * platform's path delimiter, `:` or `;` on Windows, its `%s` replaced by the target, else the
+ * target appended, `%%` a literal `%`, as `xdg-open` and Python's `webbrowser` read it), else the
+ * platform's opener.
  */
 export function browserCommands(
   target: string,
@@ -132,13 +173,14 @@ export function browserCommands(
   platform: string = process.platform,
 ): string[][] {
   const chosen = env["BROWSER"];
-  const entries =
-    chosen !== undefined && chosen.trim() !== ""
-      ? chosen.split(":").filter((entry) => entry.trim() !== "")
-      : [platform === "darwin" ? "open" : "xdg-open"];
+  if (chosen === undefined || chosen.trim() === "") return [[...platformOpener(platform), target]];
+  const entries = chosen
+    .split(platform === "win32" ? ";" : ":")
+    .filter((entry) => entry.trim() !== "");
   const commands: string[][] = [];
   for (const entry of entries) {
-    const words = splitCommand(entry);
+    // A Windows path's backslashes are separators, never escapes.
+    const words = platform === "win32" ? splitWindowsCommand(entry) : splitCommand(entry);
     if (words.length === 0) continue;
     let substituted = false;
     const argv = words.map((word) =>
@@ -171,11 +213,27 @@ function start(argv: readonly string[]): Promise<boolean> {
   });
 }
 
+/**
+ * Where launch pages go: the system's temporary directory on POSIX (the page's modes protect it),
+ * the user's own profile on Windows, whatever `%TEMP%` names.
+ */
+export function launchBase(env: Environment, platform: string = process.platform): string {
+  if (platform !== "win32") return tmpdir();
+  const local = env["LOCALAPPDATA"];
+  const base =
+    local !== undefined && local !== "" && win32.isAbsolute(local)
+      ? local
+      : win32.join(homedir(), "AppData", "Local");
+  return win32.join(base, "mostra-cli", "open");
+}
+
 /** Opens `url` in a browser through a launch page; whether a browser command started. */
 export async function openInBrowser(url: string, env: Environment): Promise<boolean> {
   let page: string;
   try {
-    page = writeLaunchPage(url);
+    const base = launchBase(env);
+    mkdirSync(base, { recursive: true, mode: 0o700 });
+    page = writeLaunchPage(url, base);
   } catch {
     return false;
   }

package/src/client.ts

@@ -6,8 +6,8 @@
  */
 import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
-import { createConnection, type Socket } from "node:net";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+import type { Duplex } from "node:stream";
 import {
   ARTIFACT_PROGRESS,
   CLI_CLIENT_NAME,
@@ -23,6 +23,8 @@ import {
   RpcError,
   RpcPeer,
 } from "@mostra/protocol";
+import { connectControl, type Runtime } from "@mostra/sdk";
+import { detachedDirectory, detachedEnvironment } from "./detached.ts";
 import { type Environment, locateRuntime } from "./home.ts";
 import { cliVersion } from "./version.ts";
 
@@ -98,6 +100,17 @@ export async function connect(options: ConnectOptions): Promise<InstanceConnecti
   return open(started.socket, options, started.status === "started");
 }
 
+/**
+ * Opens the endpoint `instance.json` or a starting daemon named: a Unix socket, or on Windows the
+ * owner-only pipe through the runtime's helper, which refuses a pipe another user created under
+ * the name (D150, the SDK's `connectControl`). Only Windows needs the runtime resolved first.
+ */
+async function openEndpoint(endpoint: string, options: ConnectOptions): Promise<Duplex> {
+  const runtime: Runtime | undefined =
+    process.platform === "win32" ? (await locateRuntime(options.env)).runtime : undefined;
+  return connectControl(endpoint, { runtime, env: options.env, timeoutMs: ATTACH_TIMEOUT_MS });
+}
+
 /** The socket `instance.json` records (D81), if the file exists and reads. */
 function readSocket(home: string): string | undefined {
   try {
@@ -135,7 +148,10 @@ export async function startDaemon(options: ConnectOptions): Promise<DaemonLine>
   const runtime = await locateRuntime(options.env);
   if (Date.now() >= deadlineAt) throw timedOut();
   const args = [
-    runtime.entry,
+    // Absolute: the daemon runs in the file system's root, where a relative entry (a relative
+    // `MOSTRA_RUNTIME_BIN`, checked against this process's directory) would name nothing (GPT
+    // review of WP-W2).
+    resolve(runtime.entry),
     "daemon",
     // The home this CLI resolved, so the daemon owns exactly it whatever its own environment.
     "--home",
@@ -144,8 +160,15 @@ export async function startDaemon(options: ConnectOptions): Promise<DaemonLine>
   return new Promise((resolve, reject) => {
     const child = spawn(runtime.node, args, {
       detached: true,
+      // Not the command's directory but its home's file system root, which always exists: the
+      // daemon outlives the command by up to 30 idle minutes, and on Windows nobody can remove or
+      // rename a running process's working directory, so a project the CLI ran in would stay
+      // locked (WP-W2).
+      cwd: detachedDirectory(options.home),
+      // No console window for the daemon on Windows.
+      windowsHide: true,
       stdio: ["ignore", "pipe", "ignore"],
-      env: { ...process.env, ...options.env } as NodeJS.ProcessEnv,
+      env: detachedEnvironment({ ...process.env, ...options.env }) as NodeJS.ProcessEnv,
     });
     const splitter = new LineSplitter();
     let settled = false;
@@ -218,21 +241,7 @@ async function open(
   options: ConnectOptions,
   started: boolean,
 ): Promise<InstanceConnection> {
-  const socket = await new Promise<Socket>((resolve, reject) => {
-    const connection = createConnection(socketPath);
-    const timer = setTimeout(() => {
-      connection.destroy();
-      reject(closed(socketPath, "timed out"));
-    }, ATTACH_TIMEOUT_MS);
-    connection.once("error", (error: NodeJS.ErrnoException) => {
-      clearTimeout(timer);
-      reject(closed(socketPath, error.code ?? "failed"));
-    });
-    connection.once("connect", () => {
-      clearTimeout(timer);
-      resolve(connection);
-    });
-  });
+  const socket = await openEndpoint(socketPath, options);
   const handlers = new Map<string, (params: unknown) => void>();
   const peer = new RpcPeer({
     send: (message) => {
@@ -297,14 +306,6 @@ async function open(
   };
 }
 
-function closed(path: string, why: string): RpcError {
-  return new RpcError(
-    createDiagnostic("MOSTRA_HOST_CONNECTION_CLOSED", {
-      message: `Couldn't reach the instance at ${path} (${why}).`,
-    }),
-  );
-}
-
 /** A limit as people write it: `250 ms`, `5 s`, `1.5 s`. */
 function formatDuration(ms: number): string {
   if (ms < 1000) return `${ms} ms`;

package/src/commands/admin.ts

@@ -27,6 +27,7 @@ import { docsIndex, indexMarkdown, nearestTopics } from "../docs.ts";
 import { EXIT, exitCodeFor } from "../exit.ts";
 import { embeddedHome, locateRuntime, readHomeMarks } from "../home.ts";
 import { usage } from "../parse.ts";
+import { checkPlatform } from "../platform.ts";
 import { TelemetryStore, TURNED, telemetryStatus } from "../telemetry/index.ts";
 import { NOTICE_DEFAULT } from "../telemetry/words.ts";
 import { cliVersion } from "../version.ts";
@@ -199,7 +200,8 @@ async function service(
 const noStart = {
   name: "no-start",
   kind: "boolean" as const,
-  summary: "Write or remove the service's file without asking launchd or systemd to load it.",
+  summary:
+    "Write or remove the service's definition without asking launchd, systemd or Task Scheduler to load it.",
 };
 
 /** `mostra daemon start`. */
@@ -294,7 +296,7 @@ export const daemonStatusCommand: CommandDef = defineCommand({
 export const daemonInstallCommand: CommandDef = defineCommand({
   path: ["daemon", "install"],
   summary:
-    "Run the home's daemon as a login service (launchd or systemd), so links answer at any hour.",
+    "Run the home's daemon as a login service (launchd, systemd or Task Scheduler), so links answer at any hour.",
   flags: [noStart],
   output: { type: "ServiceStatus", topic: "cli" },
   exits: [],
@@ -447,20 +449,15 @@ export const doctorCommand: CommandDef = defineCommand({
   async run(context) {
     const checks: DoctorCheck[] = [];
     const node = Number(process.versions.node.split(".")[0]);
+    const unsupported = checkPlatform(process.platform, process.arch, context.env);
     checks.push(
-      process.platform === "darwin" || process.platform === "linux"
+      unsupported === undefined
         ? {
             name: "platform",
             status: "ok",
             detail: `${process.platform} ${process.arch}, Node ${process.versions.node}`,
           }
-        : {
-            name: "platform",
-            status: "error",
-            diagnostic: createDiagnostic("MOSTRA_PLATFORM_UNSUPPORTED", {
-              message: `Mostra runs on macOS and Linux; this is ${process.platform}.`,
-            }),
-          },
+        : { name: "platform", status: "error", diagnostic: unsupported },
     );
     if (node < 24) {
       checks.push({

package/src/commands/dev.ts

@@ -79,16 +79,16 @@ export const devCommand: CommandDef = defineCommand({
       `Development preview, not published: ${started.url}\nPress Ctrl-C to stop.\n`,
     );
     for (const event of early.splice(0)) if (event.sessionId === sessionId) show(event);
-    // The session lasts until Ctrl-C (or SIGTERM), or until the instance ends it.
+    // The session lasts until Ctrl-C (or SIGTERM; Ctrl+Break on Windows), or until the instance
+    // ends it.
     let stop: () => void = () => {};
+    const signals = ["SIGINT", "SIGTERM", "SIGBREAK"] as const;
     const ended = await new Promise<"signal" | "closed">((done) => {
       stop = (): void => done("signal");
-      process.once("SIGINT", stop);
-      process.once("SIGTERM", stop);
+      for (const signal of signals) process.once(signal, stop);
       void connection?.closed.then(() => done("closed"));
     });
-    process.off("SIGINT", stop);
-    process.off("SIGTERM", stop);
+    for (const signal of signals) process.off(signal, stop);
     if (ended === "closed") {
       throw new RpcError(
         createDiagnostic("MOSTRA_HOST_CONNECTION_CLOSED", {

package/src/commands/viewing.ts

@@ -20,10 +20,13 @@ import type { Environment } from "../home.ts";
 import { usage } from "../parse.ts";
 import { arg, artifactRef, flag } from "./shared.ts";
 
-/** Whether this session can show a browser: not over SSH without a display. */
+/**
+ * Whether this session can show a browser: not over SSH without a display. On macOS and Windows a
+ * local session always has the user's desktop; an SSH session there has none.
+ */
 export function hasDisplay(env: Environment, platform: string = process.platform): boolean {
   const ssh = env["SSH_CONNECTION"] !== undefined || env["SSH_TTY"] !== undefined;
-  if (platform === "darwin") return !ssh;
+  if (platform === "darwin" || platform === "win32") return !ssh;
   return env["DISPLAY"] !== undefined || env["WAYLAND_DISPLAY"] !== undefined;
 }
 

package/src/detached.ts

@@ -0,0 +1,49 @@
+/**
+ * The directory and environment of the processes the CLI leaves running: its home's daemon and
+ * the telemetry flusher. They run in their file system's root, because on Windows nobody can
+ * rename or remove a running process's working directory, and they outlive the command (WP-W2,
+ * D151 item 3). Every path the environment names relative to the command's directory is made
+ * absolute first, so it still names what it named for the command (Opus review of WP-W2,
+ * finding 3).
+ */
+import { isAbsolute, parse, resolve } from "node:path";
+
+/**
+ * The variables whose values are paths: Mostra's own, as the runtime, the SDK and the CLI read
+ * them. A test keeps the list complete.
+ */
+export const PATH_VARIABLES: readonly string[] = [
+  "MOSTRA_HOME",
+  "MOSTRA_RUNTIME_DIR",
+  "MOSTRA_CONFIG_DIR",
+  "MOSTRA_CACHE_DIR",
+  "MOSTRA_BUNDLE",
+  "MOSTRA_RUNTIME_BIN",
+  "MOSTRA_SHELL_DIR",
+  "MOSTRA_WARM_DIR",
+  "MOSTRA_WORKER_ENTRY",
+  "MOSTRA_VERIFY_ENTRY",
+  "MOSTRA_WIN_HELPER",
+  "MOSTRA_TEST_WORKER_HOST",
+  "MOSTRA_TEST_BUNDLE_PINS",
+];
+
+/** `env` with every relative path variable resolved against `cwd`. */
+export function detachedEnvironment(
+  env: Readonly<Record<string, string | undefined>>,
+  cwd: string = process.cwd(),
+): Record<string, string | undefined> {
+  const result: Record<string, string | undefined> = { ...env };
+  for (const name of PATH_VARIABLES) {
+    const value = result[name];
+    if (value !== undefined && value !== "" && !isAbsolute(value)) {
+      result[name] = resolve(cwd, value);
+    }
+  }
+  return result;
+}
+
+/** The working directory of a process the CLI leaves running: the root of `anchor`'s file system. */
+export function detachedDirectory(anchor: string): string {
+  return parse(resolve(anchor)).root;
+}

package/src/home.ts

@@ -5,8 +5,8 @@
  */
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import { resolveRuntime } from "@mostra/sdk";
+import { isAbsolute, join, resolve, win32 } from "node:path";
+import { type Runtime, resolveRuntime } from "@mostra/sdk";
 
 /** The environment the CLI reads. */
 export type Environment = Readonly<Record<string, string | undefined>>;
@@ -16,7 +16,8 @@ const nonEmpty = (value: string | undefined): string | undefined =>
 
 /**
  * The home, in D84's order: `--home`, then `MOSTRA_HOME`, then the platform default (`~/.mostra`
- * on macOS, `${XDG_DATA_HOME:-~/.local/share}/mostra` on Linux), the same order the runtime uses.
+ * on macOS, `${XDG_DATA_HOME:-~/.local/share}/mostra` on Linux, `%LOCALAPPDATA%\mostra` on
+ * Windows), the same order and defaults the runtime uses (its `platform` module).
  */
 export function resolveHome(options: {
   readonly home?: string | undefined;
@@ -26,8 +27,19 @@ export function resolveHome(options: {
 }): string {
   const chosen = nonEmpty(options.home) ?? nonEmpty(options.env["MOSTRA_HOME"]);
   if (chosen !== undefined) return resolve(options.cwd, chosen);
+  const platform = options.platform ?? process.platform;
+  if (platform === "win32") {
+    // As the runtime: the user's profile from the system, never a `HOME` a POSIX shell set.
+    const local = nonEmpty(options.env["LOCALAPPDATA"]);
+    return win32.join(
+      local !== undefined && win32.isAbsolute(local)
+        ? local
+        : win32.join(homedir(), "AppData", "Local"),
+      "mostra",
+    );
+  }
   const user = nonEmpty(options.env["HOME"]) ?? homedir();
-  if ((options.platform ?? process.platform) === "darwin") return join(user, ".mostra");
+  if (platform === "darwin") return join(user, ".mostra");
   const data = nonEmpty(options.env["XDG_DATA_HOME"]);
   return join(
     data !== undefined && isAbsolute(data) ? data : join(user, ".local", "share"),
@@ -37,12 +49,26 @@ export function resolveHome(options: {
 
 /**
  * The CLI's config directory (D140 item 5): `MOSTRA_CONFIG_DIR`, else
- * `${XDG_CONFIG_HOME:-~/.config}/mostra`, on both platforms. It holds telemetry's choice and
- * queue, per operating-system user, never per home.
+ * `${XDG_CONFIG_HOME:-~/.config}/mostra` on macOS and Linux, and `%APPDATA%\mostra` on Windows,
+ * where per-user settings live (D151). It holds telemetry's choice and queue, per
+ * operating-system user, never per home.
  */
-export function configDir(env: Environment, cwd: string): string {
+export function configDir(
+  env: Environment,
+  cwd: string,
+  platform: string = process.platform,
+): string {
   const override = nonEmpty(env["MOSTRA_CONFIG_DIR"]);
   if (override !== undefined) return resolve(cwd, override);
+  if (platform === "win32") {
+    const roaming = nonEmpty(env["APPDATA"]);
+    return win32.join(
+      roaming !== undefined && win32.isAbsolute(roaming)
+        ? roaming
+        : win32.join(homedir(), "AppData", "Roaming"),
+      "mostra",
+    );
+  }
   const xdg = nonEmpty(env["XDG_CONFIG_HOME"]);
   const base =
     xdg !== undefined && isAbsolute(xdg)
@@ -57,6 +83,8 @@ export interface RuntimeLocation {
   readonly node: string;
   /** `mostra-runtime`'s entry. */
   readonly entry: string;
+  /** The runtime as the SDK resolved it (its bundle, for the Windows helper beside it). */
+  readonly runtime: Runtime;
 }
 
 /**
@@ -67,7 +95,7 @@ export interface RuntimeLocation {
  */
 export async function locateRuntime(env: Environment): Promise<RuntimeLocation> {
   const runtime = await resolveRuntime({ env });
-  return { node: runtime.node, entry: runtime.runtimeEntry };
+  return { node: runtime.node, entry: runtime.runtimeEntry, runtime };
 }
 
 /** What the CLI reads of a home's `config.json` (DATA_MODEL §1). */

package/src/platform.ts

@@ -0,0 +1,24 @@
+/**
+ * The CLI's platform gate (D35, D146, RT-07), the runtime's rule (`home/platform.ts` in
+ * `@mostra/runtime`) repeated where the CLI must decide before it reaches any runtime: macOS and
+ * Linux on x64 and arm64; Windows on x64 and arm64 only behind the development switch
+ * `MOSTRA_DEV_WINDOWS=1`, which only Mostra's CI sets until WP-W3; everything else fails closed.
+ */
+import { createDiagnostic, type Diagnostic } from "@mostra/protocol";
+import type { Environment } from "./home.ts";
+
+/** `MOSTRA_PLATFORM_UNSUPPORTED` for a platform Mostra doesn't run on, else `undefined`. */
+export function checkPlatform(
+  platform: string,
+  arch: string,
+  env: Environment,
+): Diagnostic | undefined {
+  if (arch === "x64" || arch === "arm64") {
+    if (platform === "darwin" || platform === "linux") return undefined;
+    if (platform === "win32" && env["MOSTRA_DEV_WINDOWS"] === "1") return undefined;
+  }
+  const name = platform === "win32" ? `Windows (${platform}-${arch})` : `${platform}-${arch}`;
+  return createDiagnostic("MOSTRA_PLATFORM_UNSUPPORTED", {
+    message: `Mostra doesn't run on ${name}; it supports macOS and Linux on x64 and arm64.`,
+  });
+}

package/src/run.ts

@@ -33,6 +33,7 @@ import {
   resolveHome,
 } from "./home.ts";
 import { globalFlags, parseCommandLine } from "./parse.ts";
+import { checkPlatform } from "./platform.ts";
 import { telemetrySession } from "./telemetry/index.ts";
 import { cliVersion } from "./version.ts";
 
@@ -54,6 +55,8 @@ export interface RunnerIo {
   readonly tty: { readonly stdin: boolean; readonly stdout: boolean; readonly stderr: boolean };
   /** The platform; default process.platform. */
   readonly platform?: string;
+  /** The architecture; default process.arch. */
+  readonly arch?: string;
 }
 
 /** The diagnostic an exception is, for the envelope: its own, or an internal error. */
@@ -140,13 +143,8 @@ export async function run(io: RunnerIo): Promise<number> {
 
   // Every entry point fails closed on an unsupported platform before touching the home (D35).
   const platform = io.platform ?? process.platform;
-  if (platform !== "darwin" && platform !== "linux") {
-    return fail(
-      createDiagnostic("MOSTRA_PLATFORM_UNSUPPORTED", {
-        message: `Mostra runs on macOS and Linux; this is ${platform}.`,
-      }),
-    );
-  }
+  const unsupported = checkPlatform(platform, io.arch ?? process.arch, io.env);
+  if (unsupported) return fail(unsupported);
 
   let parsed: ReturnType<typeof parseCommandLine>;
   try {

package/src/telemetry/events.ts

@@ -37,7 +37,7 @@ const common = {
   at: z.string().regex(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:00Z$/),
   installId: z.uuid(),
   version: z.string().regex(/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/),
-  os: z.enum(["darwin", "linux"]),
+  os: z.enum(["darwin", "linux", "win32"]),
   arch: z.string().regex(/^[a-z0-9]{2,12}$/),
   node: z.int().min(0).max(999),
   harness: z.enum([...HARNESSES, "other", "none"]),
@@ -51,7 +51,7 @@ export interface CommonFields {
   readonly at: string;
   readonly installId: string;
   readonly version: string;
-  readonly os: "darwin" | "linux";
+  readonly os: "darwin" | "linux" | "win32";
   readonly arch: string;
   readonly node: number;
   readonly harness: Harness;

package/src/telemetry/flush.ts

@@ -5,10 +5,12 @@
  * but `Content-Type`, `User-Agent` and the ones HTTP itself needs, and keeps what a failed
  * attempt couldn't send for the next flush.
  */
+
 import { spawn } from "node:child_process";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { join } from "node:path";
+import { detachedDirectory, detachedEnvironment } from "../detached.ts";
 import type { Environment } from "../home.ts";
 import { cliVersion, fromSource, packageRoot } from "../version.ts";
 import { buildEndpoint, decide } from "./decision.ts";
@@ -133,7 +135,11 @@ export function startFlusher(store: TelemetryStore, env: Environment, now: numbe
     const child = spawn(process.execPath, [...nodeArgs, entry, store.dir], {
       detached: true,
       stdio: "ignore",
-      env: { ...process.env, ...env } as NodeJS.ProcessEnv,
+      // Not the command's directory but its file system's root, which always exists: on Windows
+      // a process's working directory can't be removed or renamed while it runs, and the flusher
+      // outlives the command (WP-W2).
+      cwd: detachedDirectory(store.dir),
+      env: detachedEnvironment({ ...process.env, ...env }) as NodeJS.ProcessEnv,
     });
     child.on("error", () => {});
     child.unref();

package/src/telemetry/index.ts

@@ -210,7 +210,10 @@ export function telemetrySession(options: TelemetryOptions): TelemetrySession {
         at: minute(new Date(now())),
         installId: id.id,
         version: cliVersion(),
-        os: process.platform === "darwin" ? "darwin" : "linux",
+        os:
+          process.platform === "darwin" || process.platform === "win32"
+            ? process.platform
+            : "linux",
         arch: process.arch,
         node: Number(process.versions.node.split(".")[0]),
         harness,