agentroam 0.2.0-preview.8 → 0.2.0-preview.9

package/dist/service/service-command.test.js

@@ -0,0 +1,102 @@
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { runServiceCommand } from "./service-command.js";
+describe("runServiceCommand", () => {
+    it("installs the service using absolute runtime context and parsed start options", async () => {
+        const install = vi.fn(async (config) => ({
+            paths: { plistPath: "/Users/test/Library/LaunchAgents/com.agentroam.service.plist" },
+            state: { status: "ready", accessUrl: "https://ready.example/web" },
+            definition: "/Users/test/Library/LaunchAgents/com.agentroam.service.plist",
+        }));
+        const log = vi.fn();
+        await runServiceCommand(options("install"), {
+            platform: "darwin",
+            nodePath: "/node",
+            cliPath: "/agentroam.mjs",
+            version: "0.2.0-preview.9",
+            nodeVersion: "22.22.0",
+            now: () => new Date("2026-09-03T00:00:00.000Z"),
+            log,
+            controller: controller({ install }),
+        });
+        expect(install).toHaveBeenCalledWith(expect.objectContaining({
+            nodePath: "/node",
+            cliPath: "/agentroam.mjs",
+            roots: [resolve("workspace")],
+            version: "0.2.0-preview.9",
+            installedAt: "2026-09-03T00:00:00.000Z",
+        }));
+        expect(log).toHaveBeenCalledWith("Open: https://ready.example/web");
+    });
+    it("reports status without mutating an uninstalled service", async () => {
+        const log = vi.fn();
+        await runServiceCommand(options("status"), {
+            platform: "darwin",
+            nodePath: "/node",
+            cliPath: "/agentroam.mjs",
+            version: "test",
+            log,
+            controller: controller({ status: vi.fn(async () => ({ installed: false })) }),
+        });
+        expect(log).toHaveBeenCalledWith("AgentRoam service: not installed");
+    });
+    it("starts and stops a Windows service through the same command contract", async () => {
+        const start = vi.fn(async () => ({ status: "ready", accessUrl: "https://ready.example/web" }));
+        const stop = vi.fn(async () => undefined);
+        const log = vi.fn();
+        await runServiceCommand(options("start"), {
+            platform: "win32",
+            nodePath: "C:\\node.exe",
+            cliPath: "C:\\agentroam.mjs",
+            version: "test",
+            controller: controller({ start }),
+            log,
+        });
+        await runServiceCommand(options("stop"), {
+            platform: "win32",
+            nodePath: "C:\\node.exe",
+            cliPath: "C:\\agentroam.mjs",
+            version: "test",
+            controller: controller({ stop }),
+            log,
+        });
+        expect(start).toHaveBeenCalledOnce();
+        expect(stop).toHaveBeenCalledOnce();
+        expect(log).toHaveBeenCalledWith("✓ AgentRoam service started");
+        expect(log).toHaveBeenCalledWith("✓ AgentRoam service stopped");
+    });
+    it("rejects service management outside supported platforms", async () => {
+        await expect(runServiceCommand(options("status"), {
+            platform: "linux",
+            nodePath: "/node",
+            cliPath: "/agentroam.mjs",
+            version: "test",
+        })).rejects.toThrow("supported platforms are macOS and Windows");
+    });
+});
+function controller(overrides) {
+    return {
+        install: vi.fn(),
+        start: vi.fn(),
+        stop: vi.fn(),
+        status: vi.fn(),
+        url: vi.fn(),
+        logs: vi.fn(),
+        restart: vi.fn(),
+        uninstall: vi.fn(),
+        ...overrides,
+    };
+}
+function options(serviceAction) {
+    return {
+        command: "service",
+        serviceAction,
+        roots: [resolve("workspace")],
+        port: null,
+        relay: "auto",
+        tunnelCommand: null,
+        localOnly: false,
+        qr: false,
+        dataDir: resolve("data"),
+    };
+}

package/dist/service/service-controller.js

@@ -0,0 +1,27 @@
+import { spawn } from "node:child_process";
+export function buildStartArguments(config) {
+    const args = [config.nodePath, config.cliPath, "start"];
+    for (const root of config.roots)
+        args.push("--root", root);
+    if (config.port !== null)
+        args.push("--port", String(config.port));
+    if (config.localOnly)
+        args.push("--local-only");
+    else
+        args.push("--relay", config.relay);
+    if (!config.localOnly && config.tunnelCommand)
+        args.push("--tunnel-command", config.tunnelCommand);
+    args.push("--data-dir", config.dataDir, "--no-qr");
+    return args;
+}
+export function runCommand(command, args) {
+    return new Promise((resolveResult, reject) => {
+        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => { stdout += chunk; });
+        child.stderr.on("data", (chunk) => { stderr += chunk; });
+        child.once("error", reject);
+        child.once("exit", (code) => resolveResult({ code: code ?? 1, stdout, stderr }));
+    });
+}

package/dist/service/service-files.js

@@ -0,0 +1,78 @@
+import { randomBytes } from "node:crypto";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { chmod, mkdir, open, readFile, rename, rm } from "node:fs/promises";
+export const SERVICE_LABEL = "com.agentroam.service";
+export const WINDOWS_SERVICE_NAME = "AgentRoam";
+export function resolveServicePaths(homeDir = homedir(), dataDir = resolve(homeDir, ".agentroam")) {
+    const normalizedHome = resolve(homeDir);
+    const normalizedData = resolve(dataDir);
+    const launchAgentsDir = resolve(normalizedHome, "Library", "LaunchAgents");
+    const controlDir = resolve(normalizedHome, ".agentroam", "service");
+    const logsDir = resolve(normalizedData, "logs");
+    return {
+        homeDir: normalizedHome,
+        dataDir: normalizedData,
+        launchAgentsDir,
+        plistPath: resolve(launchAgentsDir, `${SERVICE_LABEL}.plist`),
+        controlDir,
+        configPath: resolve(controlDir, "config.json"),
+        statePath: resolve(controlDir, "state.json"),
+        urlPath: resolve(normalizedData, "tunnel.url"),
+        logsDir,
+        stdoutPath: resolve(logsDir, "service.stdout.log"),
+        stderrPath: resolve(logsDir, "service.stderr.log"),
+    };
+}
+export async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    await chmod(path, 0o700);
+}
+export async function ensurePrivateFile(path) {
+    await ensurePrivateDirectory(dirname(path));
+    const handle = await open(path, "a", 0o600);
+    await handle.close();
+    await chmod(path, 0o600);
+}
+export async function writePrivateJson(path, value) {
+    await writePrivateText(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+export async function writePrivateText(path, value) {
+    await ensurePrivateDirectory(dirname(path));
+    const temporary = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+    const handle = await open(temporary, "wx", 0o600);
+    try {
+        await handle.writeFile(value, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    try {
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+    }
+    catch (error) {
+        await rm(temporary, { force: true });
+        throw error;
+    }
+}
+export async function readServiceConfig(paths) {
+    return readJson(paths.configPath);
+}
+export async function readServiceState(paths) {
+    return readJson(paths.statePath);
+}
+export async function removeIfExists(path) {
+    await rm(path, { force: true });
+}
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}

package/dist/service/service-files.test.js

@@ -0,0 +1,48 @@
+import { mkdtemp, readFile, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { describe, expect, it } from "vitest";
+import { ensurePrivateFile, readServiceConfig, resolveServicePaths, writePrivateJson, writePrivateText, } from "./service-files.js";
+describe("service files", () => {
+    it("resolves control files under the home directory and runtime files under data-dir", async () => {
+        const home = await mkdtemp(resolve(tmpdir(), "agentroam-service-home-"));
+        const data = resolve(home, "custom-data");
+        const paths = resolveServicePaths(home, data);
+        expect(paths.plistPath).toBe(resolve(home, "Library/LaunchAgents/com.agentroam.service.plist"));
+        expect(paths.configPath).toBe(resolve(home, ".agentroam/service/config.json"));
+        expect(paths.statePath).toBe(resolve(home, ".agentroam/service/state.json"));
+        expect(paths.urlPath).toBe(resolve(data, "tunnel.url"));
+        expect(paths.stdoutPath).toBe(resolve(data, "logs/service.stdout.log"));
+    });
+    it("atomically replaces private JSON and text files", async () => {
+        const home = await mkdtemp(resolve(tmpdir(), "agentroam-service-private-"));
+        const paths = resolveServicePaths(home);
+        const first = config(paths.dataDir, "first");
+        const second = config(paths.dataDir, "second");
+        await writePrivateJson(paths.configPath, first);
+        await writePrivateJson(paths.configPath, second);
+        await writePrivateText(paths.urlPath, "https://example.trycloudflare.com/web\n");
+        await ensurePrivateFile(paths.stdoutPath);
+        expect(await readServiceConfig(paths)).toEqual(second);
+        expect(await readFile(paths.urlPath, "utf8")).toContain("trycloudflare.com");
+        for (const path of [paths.configPath, paths.urlPath, paths.stdoutPath]) {
+            expect((await stat(path)).mode & 0o777).toBe(0o600);
+        }
+        expect((await stat(paths.controlDir)).mode & 0o777).toBe(0o700);
+        expect((await stat(paths.logsDir)).mode & 0o777).toBe(0o700);
+    });
+});
+function config(dataDir, version) {
+    return {
+        version,
+        nodePath: "/node",
+        cliPath: "/agentroam.mjs",
+        roots: ["/workspace"],
+        port: null,
+        relay: "auto",
+        tunnelCommand: null,
+        localOnly: false,
+        dataDir,
+        installedAt: "2026-09-03T00:00:00.000Z",
+    };
+}

package/dist/service/windows-service-host.js

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+import { open, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildStartArguments } from "./service-controller.js";
+import { ensurePrivateFile, resolveServicePaths } from "./service-files.js";
+export async function runWindowsServiceHost(configPath, dependencies = {}) {
+    const config = JSON.parse(await readFile(configPath, "utf8"));
+    const paths = resolveServicePaths(undefined, config.dataDir);
+    await Promise.all([ensurePrivateFile(paths.stdoutPath), ensurePrivateFile(paths.stderrPath)]);
+    const [stdoutHandle, stderrHandle] = await Promise.all([open(paths.stdoutPath, "a"), open(paths.stderrPath, "a")]);
+    const [command, ...args] = buildStartArguments(config);
+    let child = null;
+    const requestStop = () => child?.kill("SIGTERM");
+    try {
+        child = (dependencies.spawnProcess ?? spawn)(command, args, {
+            cwd: config.roots[0],
+            env: { ...process.env, AGENTROAM_SERVICE: "1" },
+            stdio: ["ignore", stdoutHandle.fd, stderrHandle.fd],
+            windowsHide: true,
+        });
+        process.once("SIGINT", requestStop);
+        process.once("SIGTERM", requestStop);
+        return await waitForExit(child);
+    }
+    finally {
+        process.removeListener("SIGINT", requestStop);
+        process.removeListener("SIGTERM", requestStop);
+        await Promise.all([stdoutHandle.close(), stderrHandle.close()]);
+    }
+}
+function waitForExit(child) {
+    return new Promise((resolveExit, rejectExit) => {
+        child.once("error", rejectExit);
+        child.once("exit", (code, signal) => resolveExit(code ?? (signal ? 1 : 0)));
+    });
+}
+const currentFile = fileURLToPath(import.meta.url);
+if (process.argv[1] && resolve(process.argv[1]) === resolve(currentFile)) {
+    const configPath = process.argv[2];
+    if (!configPath) {
+        console.error("AgentRoam Windows service host requires a config path");
+        process.exitCode = 2;
+    }
+    else {
+        runWindowsServiceHost(configPath)
+            .then((code) => { process.exitCode = code; })
+            .catch((error) => {
+            console.error(error instanceof Error ? error.message : error);
+            process.exitCode = 1;
+        });
+    }
+}

package/dist/service/windows-service-host.test.js

@@ -0,0 +1,46 @@
+import { EventEmitter } from "node:events";
+import { mkdtemp, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { resolve } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { writePrivateJson } from "./service-files.js";
+import { runWindowsServiceHost } from "./windows-service-host.js";
+describe("Windows service host", () => {
+    it("starts the configured CLI in service mode with private log descriptors", async () => {
+        const root = await mkdtemp(resolve(tmpdir(), "agentroam-windows-host-"));
+        const workspace = resolve(root, "workspace with spaces");
+        const configPath = resolve(root, "service/config.json");
+        await mkdir(workspace, { recursive: true });
+        const config = {
+            version: "0.2.0-preview.9",
+            nodePath: "C:\\Node Runtime\\node.exe",
+            cliPath: "C:\\AgentRoam\\bin\\agentroam.mjs",
+            roots: [workspace],
+            port: 3010,
+            relay: "cloudflare",
+            tunnelCommand: null,
+            localOnly: false,
+            dataDir: resolve(root, "data"),
+            installedAt: "2026-09-04T00:00:00.000Z",
+        };
+        await writePrivateJson(configPath, config);
+        const child = new EventEmitter();
+        Object.assign(child, { kill: vi.fn(() => true) });
+        const spawnProcess = vi.fn(() => {
+            queueMicrotask(() => child.emit("exit", 0, null));
+            return child;
+        });
+        await expect(runWindowsServiceHost(configPath, { spawnProcess: spawnProcess })).resolves.toBe(0);
+        const calls = spawnProcess.mock.calls;
+        const [command, args, options] = calls[0];
+        expect(command).toBe(config.nodePath);
+        expect(args).toEqual([
+            config.cliPath, "start", "--root", workspace, "--port", "3010", "--relay", "cloudflare",
+            "--data-dir", config.dataDir, "--no-qr",
+        ]);
+        expect(options).toMatchObject({ cwd: workspace, windowsHide: true });
+        expect(options.env.AGENTROAM_SERVICE).toBe("1");
+        expect(typeof options.stdio[1]).toBe("number");
+        expect(typeof options.stdio[2]).toBe("number");
+    });
+});

package/dist/service/windows-task-service.js

@@ -0,0 +1,275 @@
+import { constants } from "node:fs";
+import { access, readFile, stat } from "node:fs/promises";
+import { win32 } from "node:path";
+import { WINDOWS_SERVICE_NAME, ensurePrivateDirectory, ensurePrivateFile, readServiceConfig, readServiceState, removeIfExists, resolveServicePaths, writePrivateJson, } from "./service-files.js";
+import { runCommand, } from "./service-controller.js";
+export class WindowsTaskService {
+    homeDir;
+    runner;
+    processExists;
+    now;
+    readyTimeoutMs;
+    stopTimeoutMs;
+    pollIntervalMs;
+    validate;
+    constructor(options = {}) {
+        this.homeDir = options.homeDir;
+        this.runner = options.runner ?? runCommand;
+        this.processExists = options.processExists ?? isProcessRunning;
+        this.now = options.now ?? (() => new Date());
+        this.readyTimeoutMs = options.readyTimeoutMs ?? 120_000;
+        this.stopTimeoutMs = options.stopTimeoutMs ?? 15_000;
+        this.pollIntervalMs = options.pollIntervalMs ?? 250;
+        this.validate = options.validateConfig ?? validateWindowsConfig;
+    }
+    async install(config) {
+        const hostPath = resolveWindowsServiceHost(config.cliPath);
+        await this.validate(config, hostPath);
+        const paths = resolveServicePaths(this.homeDir, config.dataDir);
+        await Promise.all([
+            ensurePrivateDirectory(paths.controlDir),
+            ensurePrivateDirectory(paths.logsDir),
+            ensurePrivateFile(paths.stdoutPath),
+            ensurePrivateFile(paths.stderrPath),
+        ]);
+        await writePrivateJson(paths.configPath, config);
+        await Promise.all([removeIfExists(paths.statePath), removeIfExists(paths.urlPath)]);
+        await this.runRequired(buildRegisterTaskScript(config, hostPath, paths.configPath));
+        await this.runRequired(buildStartTaskScript());
+        return {
+            paths,
+            state: await this.waitForReady(paths),
+            definition: WINDOWS_SERVICE_NAME,
+        };
+    }
+    async start() {
+        const status = await this.status();
+        if (!status.installed)
+            throw new Error("AgentRoam service is not installed");
+        if (status.running)
+            return status.state;
+        const paths = resolveServicePaths(this.homeDir, status.config?.dataDir);
+        await Promise.all([removeIfExists(paths.statePath), removeIfExists(paths.urlPath)]);
+        await this.runRequired(buildStartTaskScript());
+        return this.waitForReady(paths, status.state?.pid);
+    }
+    async stop() {
+        const status = await this.status();
+        if (!status.installed)
+            throw new Error("AgentRoam service is not installed");
+        const paths = resolveServicePaths(this.homeDir, status.config?.dataDir);
+        if (status.running) {
+            await this.runRequired(buildStopTaskScript());
+            if (status.state?.pid)
+                await this.waitForProcessExit(status.state.pid);
+        }
+        await removeIfExists(paths.urlPath);
+        if (status.state) {
+            await writePrivateJson(paths.statePath, {
+                status: "stopped",
+                pid: status.state.pid,
+                version: status.state.version,
+                startedAt: status.state.startedAt,
+                updatedAt: this.now().toISOString(),
+            });
+        }
+    }
+    async status() {
+        const basePaths = resolveServicePaths(this.homeDir);
+        const config = await readServiceConfig(basePaths);
+        const paths = resolveServicePaths(this.homeDir, config?.dataDir);
+        const task = await this.inspectTask();
+        return {
+            installed: task.installed,
+            loaded: task.installed,
+            running: task.running,
+            config,
+            state: await readServiceState(paths),
+            definition: WINDOWS_SERVICE_NAME,
+        };
+    }
+    async url() {
+        const status = await this.status();
+        if (!status.installed)
+            throw new Error("AgentRoam service is not installed");
+        if (!status.running)
+            throw new Error("AgentRoam service is installed but not running");
+        if (status.state?.status !== "ready" || !status.state.accessUrl) {
+            throw new Error("AgentRoam service is still starting; try again shortly");
+        }
+        const paths = resolveServicePaths(this.homeDir, status.config?.dataDir);
+        const value = (await readFile(paths.urlPath, "utf8")).trim();
+        if (!value || value !== status.state.accessUrl)
+            throw new Error("AgentRoam service URL is unavailable or stale");
+        return value;
+    }
+    async logs(maxBytes = 64 * 1024) {
+        const basePaths = resolveServicePaths(this.homeDir);
+        const config = await readServiceConfig(basePaths);
+        const paths = resolveServicePaths(this.homeDir, config?.dataDir);
+        const [stdout, stderr] = await Promise.all([
+            readTail(paths.stdoutPath, maxBytes),
+            readTail(paths.stderrPath, maxBytes),
+        ]);
+        return { stdoutPath: paths.stdoutPath, stderrPath: paths.stderrPath, stdout, stderr };
+    }
+    async restart() {
+        const status = await this.status();
+        if (!status.installed)
+            throw new Error("AgentRoam service is not installed");
+        const paths = resolveServicePaths(this.homeDir, status.config?.dataDir);
+        if (status.running) {
+            await this.runRequired(buildStopTaskScript());
+            if (status.state?.pid)
+                await this.waitForProcessExit(status.state.pid);
+        }
+        await Promise.all([removeIfExists(paths.statePath), removeIfExists(paths.urlPath)]);
+        await this.runRequired(buildStartTaskScript());
+        return this.waitForReady(paths, status.state?.pid);
+    }
+    async uninstall() {
+        const status = await this.status();
+        const paths = resolveServicePaths(this.homeDir, status.config?.dataDir);
+        if (status.running) {
+            await this.runRequired(buildStopTaskScript());
+            if (status.state?.pid)
+                await this.waitForProcessExit(status.state.pid);
+        }
+        if (status.installed)
+            await this.runRequired(buildUnregisterTaskScript());
+        await Promise.all([
+            removeIfExists(paths.configPath),
+            removeIfExists(paths.statePath),
+            removeIfExists(paths.urlPath),
+        ]);
+        return { removed: status.installed || Boolean(status.config), preservedDataDir: paths.dataDir };
+    }
+    async inspectTask() {
+        const result = await this.runPowerShell(buildStatusTaskScript());
+        if (result.code !== 0) {
+            const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`;
+            throw new Error(`PowerShell task status failed: ${detail}`);
+        }
+        const line = result.stdout.trim().split(/\r?\n/).filter(Boolean).at(-1);
+        if (!line)
+            throw new Error("PowerShell task status returned no JSON");
+        const value = JSON.parse(line);
+        return { installed: value.installed === true, running: value.running === true };
+    }
+    async runRequired(script) {
+        const result = await this.runPowerShell(script);
+        if (result.code !== 0) {
+            const detail = result.stderr.trim() || result.stdout.trim() || `exit ${result.code}`;
+            throw new Error(`PowerShell service command failed: ${detail}`);
+        }
+        return result;
+    }
+    runPowerShell(script) {
+        return this.runner("powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy", "Bypass",
+            "-EncodedCommand", Buffer.from(script, "utf16le").toString("base64"),
+        ]);
+    }
+    async waitForReady(paths, previousPid) {
+        const deadline = Date.now() + this.readyTimeoutMs;
+        do {
+            const state = await readServiceState(paths);
+            if (state?.status === "ready" && (!previousPid || state.pid !== previousPid))
+                return state;
+            if (Date.now() >= deadline)
+                return state;
+            await delay(this.pollIntervalMs);
+        } while (true);
+    }
+    async waitForProcessExit(pid) {
+        const deadline = Date.now() + this.stopTimeoutMs;
+        while (this.processExists(pid)) {
+            if (Date.now() >= deadline)
+                throw new Error(`service process ${pid} did not stop after task termination`);
+            await delay(this.pollIntervalMs);
+        }
+    }
+}
+export function resolveWindowsServiceHost(cliPath) {
+    return win32.resolve(win32.dirname(cliPath), "..", "dist", "service", "windows-service-host.js");
+}
+export function quoteWindowsCommandLineArgument(value) {
+    return `"${value.replace(/(\\*)"/g, "$1$1\\\"").replace(/(\\+)$/g, "$1$1")}"`;
+}
+export function buildRegisterTaskScript(config, hostPath, configPath) {
+    const argumentsValue = `${quoteWindowsCommandLineArgument(hostPath)} ${quoteWindowsCommandLineArgument(configPath)}`;
+    return String.raw `
+$ErrorActionPreference = "Stop"
+$user = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name
+$action = New-ScheduledTaskAction -Execute ${powerShellLiteral(config.nodePath)} -Argument ${powerShellLiteral(argumentsValue)} -WorkingDirectory ${powerShellLiteral(config.roots[0])}
+$trigger = New-ScheduledTaskTrigger -AtLogOn -User $user
+$principal = New-ScheduledTaskPrincipal -UserId $user -LogonType Interactive -RunLevel Limited
+$settings = New-ScheduledTaskSettingsSet -MultipleInstances IgnoreNew -RestartCount 999 -RestartInterval (New-TimeSpan -Seconds 5) -ExecutionTimeLimit ([TimeSpan]::Zero) -StartWhenAvailable -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries
+Register-ScheduledTask -TaskName ${powerShellLiteral(WINDOWS_SERVICE_NAME)} -Action $action -Trigger $trigger -Principal $principal -Settings $settings -Force | Out-Null
+`;
+}
+export function buildStatusTaskScript() {
+    return String.raw `
+$ErrorActionPreference = "Stop"
+$task = Get-ScheduledTask -TaskName ${powerShellLiteral(WINDOWS_SERVICE_NAME)} -ErrorAction SilentlyContinue
+if ($null -eq $task) {
+  [pscustomobject]@{ installed = $false; running = $false } | ConvertTo-Json -Compress
+} else {
+  [pscustomobject]@{ installed = $true; running = ([string]$task.State -eq "Running") } | ConvertTo-Json -Compress
+}
+`;
+}
+function buildStartTaskScript() {
+    return `Start-ScheduledTask -TaskName ${powerShellLiteral(WINDOWS_SERVICE_NAME)}\n`;
+}
+function buildStopTaskScript() {
+    return `Stop-ScheduledTask -TaskName ${powerShellLiteral(WINDOWS_SERVICE_NAME)}\n`;
+}
+function buildUnregisterTaskScript() {
+    return `Unregister-ScheduledTask -TaskName ${powerShellLiteral(WINDOWS_SERVICE_NAME)} -Confirm:$false\n`;
+}
+function powerShellLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+async function validateWindowsConfig(config, hostPath) {
+    if (!win32.isAbsolute(config.nodePath) || !win32.isAbsolute(config.cliPath)) {
+        throw new Error("AgentRoam service requires absolute Node and CLI paths");
+    }
+    if (config.cliPath.split(/[\\/]/).includes("_npx")) {
+        throw new Error("service install cannot use an npx temporary package; install AgentRoam with the versioned installer first");
+    }
+    await Promise.all([
+        access(config.nodePath, constants.X_OK),
+        access(config.cliPath, constants.R_OK),
+        access(hostPath, constants.R_OK),
+        ...config.roots.map(async (root) => {
+            if (!(await stat(root)).isDirectory())
+                throw new Error(`service root is not a directory: ${root}`);
+        }),
+    ]);
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function readTail(path, maxBytes) {
+    try {
+        const value = await readFile(path);
+        return value.subarray(Math.max(0, value.length - maxBytes)).toString("utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    }
+}
+function delay(timeoutMs) {
+    return new Promise((resolveDelay) => setTimeout(resolveDelay, timeoutMs));
+}