@mcoda/mswarm 0.1.0 → 0.1.46

package/dist/runtime.js

@@ -1,16 +1,24 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { hostname, homedir, platform, userInfo } from "node:os";
 import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
 const DEFAULT_GATEWAY_BASE_URL = "http://127.0.0.1:8080";
+const DEFAULT_SETUP_GATEWAY_BASE_URL = "https://api.mswarm.org";
 const DEFAULT_OLLAMA_BASE_URL = "http://127.0.0.1:11434";
 const DEFAULT_LISTEN_HOST = "127.0.0.1";
 const DEFAULT_LISTEN_PORT = 18083;
 const DEFAULT_HEARTBEAT_INTERVAL_SECONDS = 30;
-const DEFAULT_REQUEST_TIMEOUT_MS = 10_000;
+const DEFAULT_REQUEST_TIMEOUT_MS = 10000;
+const DEFAULT_SERVICE_COMMAND_TIMEOUT_MS = 60000;
 const DEFAULT_MCODA_BIN = "mcoda";
 const DEFAULT_MCODA_LIST_ARGS = ["agent", "list", "--json", "--refresh-health"];
 const DEFAULT_COMMAND_MAX_BUFFER = 16 * 1024 * 1024;
+const DEFAULT_JOB_POLL_WAIT_MS = 25000;
+const SERVICE_LABEL = "com.mcoda.mswarm.self-hosted-node";
+const SYSTEMD_SERVICE_NAME = "mswarm-self-hosted-node.service";
+const WINDOWS_TASK_NAME = "MswarmSelfHostedNode";
+const WINDOWS_WRAPPER_SCRIPT_NAME = "mswarm-self-hosted-node.ps1";
 function optionalText(value) {
     return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
 }
@@ -53,6 +61,48 @@ function parseDiscoveryMode(value) {
     const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
     return normalized === "ollama" ? "ollama" : "mcoda";
 }
+function parseRelayMode(value) {
+    const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
+    return normalized === "direct" ? "direct" : "outbound";
+}
+function normalizeLocalName(value) {
+    return (value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80) || "local-node");
+}
+export function resolveDefaultServerName() {
+    return normalizeLocalName(hostname() || "local-node");
+}
+function defaultMachineIdPath() {
+    return join(homedir(), ".mswarm", "self-hosted-node", "machine.id");
+}
+function parseCliOptions(argv) {
+    const options = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (!token.startsWith("--")) {
+            continue;
+        }
+        const equalsIndex = token.indexOf("=");
+        if (equalsIndex > 0) {
+            options[token.slice(2, equalsIndex)] = token.slice(equalsIndex + 1);
+            continue;
+        }
+        const key = token.slice(2);
+        const next = argv[index + 1];
+        if (next && !next.startsWith("--")) {
+            options[key] = next;
+            index += 1;
+        }
+        else {
+            options[key] = true;
+        }
+    }
+    return options;
+}
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/g, "");
 }
@@ -62,6 +112,26 @@ function defaultStatePath() {
 function defaultRuntimeTokenPath() {
     return join(homedir(), ".mswarm", "self-hosted-node", "node.key");
 }
+export async function readOrCreateSelfHostedMachineId(machineIdPath = defaultMachineIdPath()) {
+    try {
+        const existing = (await readFile(machineIdPath, "utf8")).trim();
+        if (existing) {
+            return existing;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const machineId = randomUUID();
+    await mkdir(dirname(machineIdPath), { recursive: true });
+    await writeFile(machineIdPath, `${machineId}\n`, { encoding: "utf8", mode: 0o600 });
+    return machineId;
+}
+export function machineFingerprintFromId(machineId) {
+    return `sha256:${createHash("sha256").update(machineId.trim()).digest("hex")}`;
+}
 function isVisionModel(modelName, family) {
     const normalized = `${modelName} ${family || ""}`.toLowerCase();
     return normalized.includes("llava") || normalized.includes("vision") || normalized.includes("bakllava");
@@ -198,6 +268,389 @@ export async function writeSelfHostedRuntimeToken(tokenPath, runtimeToken) {
     await mkdir(dirname(tokenPath), { recursive: true });
     await writeFile(tokenPath, `${runtimeToken.trim()}\n`, { encoding: "utf8", mode: 0o600 });
 }
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+function quoteSystemdValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function quoteEnvAssignment(key, value) {
+    return `${key}=${value}`;
+}
+function serviceLogDir(homeDir) {
+    return join(homeDir, ".mswarm", "self-hosted-node");
+}
+function serviceEnvironment(config, env, homeDir) {
+    const values = {
+        HOME: env.HOME || homeDir,
+        PATH: env.PATH || env.Path || env.path || "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin",
+        MSWARM_GATEWAY_BASE_URL: config.gatewayBaseUrl,
+        MSWARM_SELF_HOSTED_NODE_STATE_PATH: config.statePath,
+        MSWARM_SELF_HOSTED_NODE_KEY_PATH: config.runtimeTokenPath,
+        MSWARM_SELF_HOSTED_RELAY_MODE: config.relayMode || "outbound",
+        MSWARM_SELF_HOSTED_DIRECT_BASE_URL: config.directBaseUrl || null,
+        MSWARM_SELF_HOSTED_DISCOVERY_MODE: config.discoveryMode,
+        MSWARM_SELF_HOSTED_MCODA_BIN: config.mcodaBin,
+        MSWARM_SELF_HOSTED_MCODA_LIST_ARGS: config.mcodaListArgs.join(","),
+        MSWARM_SELF_HOSTED_OLLAMA_BASE_URL: config.ollamaBaseUrl,
+        MSWARM_SELF_HOSTED_NODE_VERSION: config.nodeVersion,
+        MSWARM_SELF_HOSTED_EXPOSE_ALL_MODELS: config.exposeAllModels ? "true" : "false",
+        MSWARM_SELF_HOSTED_MODEL_ALLOWLIST: config.modelAllowlist.join(","),
+        MSWARM_SELF_HOSTED_MODEL_BLOCKLIST: config.modelBlocklist.join(","),
+        MSWARM_SELF_HOSTED_HEARTBEAT_INTERVAL_SECONDS: String(config.heartbeatIntervalSeconds),
+        MSWARM_SELF_HOSTED_REQUEST_TIMEOUT_MS: String(config.requestTimeoutMs)
+    };
+    return Object.fromEntries(Object.entries(values).filter((entry) => typeof entry[1] === "string" && entry[1] !== ""));
+}
+function buildLaunchdPlist(input) {
+    const args = [
+        "/usr/bin/env",
+        "-i",
+        ...Object.entries(input.env).map(([key, value]) => quoteEnvAssignment(key, value)),
+        input.nodePath,
+        input.commandPath,
+        "start"
+    ]
+        .map((value) => `    <string>${escapeXml(value)}</string>`)
+        .join("\n");
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(input.label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(input.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(input.errorLogPath)}</string>
+</dict>
+</plist>
+`;
+}
+function buildSystemdUserService(input) {
+    const envArgs = Object.entries(input.env)
+        .map(([key, value]) => quoteSystemdValue(quoteEnvAssignment(key, value)))
+        .join(" ");
+    return `[Unit]
+Description=mswarm self-hosted node
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/env -i ${envArgs} ${quoteSystemdValue(input.nodePath)} ${quoteSystemdValue(input.commandPath)} start
+Restart=always
+RestartSec=5
+StandardOutput=append:${input.logPath}
+StandardError=append:${input.errorLogPath}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function quotePowerShellValue(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function quoteWindowsCommandArg(value) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+function buildWindowsTaskWrapperScript(input) {
+    const env = Object.entries(input.env)
+        .map(([key, value]) => `$env:${key} = ${quotePowerShellValue(value)}`)
+        .join("\n");
+    return `$ErrorActionPreference = 'Continue'
+
+$logPath = ${quotePowerShellValue(input.logPath)}
+$errorLogPath = ${quotePowerShellValue(input.errorLogPath)}
+$nodePath = ${quotePowerShellValue(input.nodePath)}
+$commandArguments = @(${quotePowerShellValue(input.commandPath)}, 'start')
+$allowedInheritedEnvironment = @('SystemRoot', 'WINDIR', 'COMSPEC', 'PATHEXT', 'PSModulePath', 'ProgramFiles', 'ProgramFiles(x86)', 'ProgramW6432', 'TEMP', 'TMP')
+
+New-Item -ItemType Directory -Force -Path (Split-Path -Parent $logPath) | Out-Null
+
+Get-ChildItem Env: | Where-Object { $allowedInheritedEnvironment -notcontains $_.Name } | ForEach-Object {
+  Remove-Item -Path ("Env:" + $_.Name) -ErrorAction SilentlyContinue
+}
+
+${env}
+
+while ($true) {
+  $startedAt = Get-Date -Format o
+  Add-Content -Path $logPath -Value "[$startedAt] starting mswarm self-hosted node"
+  try {
+    & $nodePath @commandArguments >> $logPath 2>> $errorLogPath
+    $exitCode = if ($null -eq $LASTEXITCODE) { 0 } else { $LASTEXITCODE }
+    $endedAt = Get-Date -Format o
+    Add-Content -Path $errorLogPath -Value "[$endedAt] mswarm self-hosted node exited with code $exitCode; restarting in 5 seconds"
+  } catch {
+    $failedAt = Get-Date -Format o
+    Add-Content -Path $errorLogPath -Value "[$failedAt] mswarm self-hosted node wrapper error: $_"
+  }
+  Start-Sleep -Seconds 5
+}
+`;
+}
+function buildWindowsTaskRegistrationCommand(wrapperPath) {
+    const actionArguments = `-NoProfile -ExecutionPolicy Bypass -File ${quoteWindowsCommandArg(wrapperPath)}`;
+    const settings = "New-ScheduledTaskSettingsSet " +
+        "-AllowStartIfOnBatteries " +
+        "-DontStopIfGoingOnBatteries " +
+        "-StartWhenAvailable " +
+        "-MultipleInstances IgnoreNew " +
+        "-RestartCount 999 " +
+        "-RestartInterval (New-TimeSpan -Minutes 1) " +
+        "-ExecutionTimeLimit (New-TimeSpan -Seconds 0)";
+    return [
+        `Stop-ScheduledTask -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)} -ErrorAction SilentlyContinue`,
+        `$action = New-ScheduledTaskAction -Execute 'powershell.exe' -Argument ${quotePowerShellValue(actionArguments)}`,
+        "$trigger = New-ScheduledTaskTrigger -AtLogOn",
+        `$settings = ${settings}`,
+        `Register-ScheduledTask -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)} -Action $action -Trigger $trigger -Settings $settings -Description 'mswarm self-hosted node daemon' -Force | Out-Null`
+    ].join("; ");
+}
+function windowsTaskCommand(command) {
+    return `${command} -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)}`;
+}
+function launchdDomain() {
+    const uid = typeof process.getuid === "function" ? process.getuid() : userInfo().uid;
+    return `gui/${uid}`;
+}
+export function resolveSelfHostedNodeServiceLayout(input = {}) {
+    const targetPlatform = input.platform || platform();
+    const homeDir = input.homeDir || homedir();
+    const logDir = serviceLogDir(homeDir);
+    const logPath = join(logDir, "daemon.log");
+    const errorLogPath = join(logDir, "daemon.err.log");
+    if (targetPlatform === "darwin") {
+        return {
+            platform: targetPlatform,
+            manager: "launchd",
+            serviceName: SERVICE_LABEL,
+            servicePath: join(homeDir, "Library", "LaunchAgents", `${SERVICE_LABEL}.plist`),
+            logPath,
+            errorLogPath
+        };
+    }
+    if (targetPlatform === "linux") {
+        return {
+            platform: targetPlatform,
+            manager: "systemd",
+            serviceName: SYSTEMD_SERVICE_NAME,
+            servicePath: join(homeDir, ".config", "systemd", "user", SYSTEMD_SERVICE_NAME),
+            logPath,
+            errorLogPath
+        };
+    }
+    if (targetPlatform === "win32") {
+        return {
+            platform: targetPlatform,
+            manager: "windows-task-scheduler",
+            serviceName: WINDOWS_TASK_NAME,
+            servicePath: join(logDir, WINDOWS_WRAPPER_SCRIPT_NAME),
+            logPath,
+            errorLogPath
+        };
+    }
+    throw new Error(`Persistent service control is not supported on ${targetPlatform}`);
+}
+function serviceControlResult(layout, action, result, ok = true, message) {
+    return {
+        manager: layout.manager,
+        serviceName: layout.serviceName,
+        servicePath: layout.servicePath,
+        logPath: layout.logPath,
+        errorLogPath: layout.errorLogPath,
+        action,
+        ok,
+        stdout: redactServiceManagerOutput(result.stdout),
+        stderr: redactServiceManagerOutput(result.stderr),
+        ...(message ? { message } : {})
+    };
+}
+function serviceCommandTimeoutMs(timeoutMs) {
+    return Math.max(Number.isFinite(timeoutMs) && typeof timeoutMs === "number" && timeoutMs > 0 ? timeoutMs : 0, DEFAULT_SERVICE_COMMAND_TIMEOUT_MS);
+}
+function redactServiceManagerOutput(value) {
+    return value.replace(/^(\s*[\w.-]*(?:API[_-]?KEY|ACCESS[_-]?KEY|PRIVATE[_-]?KEY|SECRET|TOKEN|PASSWORD|CREDENTIAL)[\w.-]*\s*(?:=>|=|:)\s*).*$/gim, "$1[redacted]");
+}
+async function runServiceCommand(runner, command, args, timeoutMs) {
+    return runner(command, args, { timeoutMs, maxBuffer: DEFAULT_COMMAND_MAX_BUFFER });
+}
+export async function installSelfHostedNodeService(config, options) {
+    const homeDir = options.homeDir || homedir();
+    const layout = resolveSelfHostedNodeServiceLayout({ platform: options.platform, homeDir });
+    const logDir = serviceLogDir(homeDir);
+    const env = serviceEnvironment(config, options.env || process.env, homeDir);
+    const nodePath = options.nodePath || process.execPath;
+    const runner = options.runner || defaultCommandRunner;
+    const serviceTimeoutMs = serviceCommandTimeoutMs(config.requestTimeoutMs);
+    await mkdir(logDir, { recursive: true });
+    if (layout.platform === "darwin") {
+        await mkdir(dirname(layout.servicePath), { recursive: true });
+        await writeFile(layout.servicePath, buildLaunchdPlist({
+            label: SERVICE_LABEL,
+            nodePath,
+            commandPath: options.commandPath,
+            logPath: layout.logPath,
+            errorLogPath: layout.errorLogPath,
+            env
+        }), "utf8");
+        const domain = launchdDomain();
+        await runner("launchctl", ["bootout", `${domain}/${SERVICE_LABEL}`], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        }).catch(() => undefined);
+        await runner("launchctl", ["bootstrap", domain, layout.servicePath], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        await runner("launchctl", ["enable", `${domain}/${SERVICE_LABEL}`], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        }).catch(() => undefined);
+        await runner("launchctl", ["kickstart", "-k", `${domain}/${SERVICE_LABEL}`], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        return { ...layout, started: true };
+    }
+    if (layout.platform === "linux") {
+        await mkdir(dirname(layout.servicePath), { recursive: true });
+        await writeFile(layout.servicePath, buildSystemdUserService({
+            nodePath,
+            commandPath: options.commandPath,
+            logPath: layout.logPath,
+            errorLogPath: layout.errorLogPath,
+            env
+        }), "utf8");
+        await runner("systemctl", ["--user", "daemon-reload"], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        await runner("systemctl", ["--user", "enable", SYSTEMD_SERVICE_NAME], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        await runner("loginctl", ["enable-linger", options.env?.USER || options.env?.USERNAME || userInfo().username], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        }).catch(() => undefined);
+        await runner("systemctl", ["--user", "restart", SYSTEMD_SERVICE_NAME], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        return { ...layout, started: true };
+    }
+    if (layout.platform === "win32") {
+        await writeFile(layout.servicePath, buildWindowsTaskWrapperScript({
+            nodePath,
+            commandPath: options.commandPath,
+            logPath: layout.logPath,
+            errorLogPath: layout.errorLogPath,
+            env
+        }), "utf8");
+        await runner("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", buildWindowsTaskRegistrationCommand(layout.servicePath)], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        await runner("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", windowsTaskCommand("Start-ScheduledTask")], {
+            timeoutMs: serviceTimeoutMs,
+            maxBuffer: DEFAULT_COMMAND_MAX_BUFFER
+        });
+        return { ...layout, started: true };
+    }
+    throw new Error(`Persistent service install is not supported on ${layout.platform}`);
+}
+export async function controlSelfHostedNodeService(action, options = {}) {
+    const layout = resolveSelfHostedNodeServiceLayout(options);
+    const runner = options.runner || defaultCommandRunner;
+    const timeoutMs = serviceCommandTimeoutMs(options.requestTimeoutMs);
+    try {
+        if (layout.manager === "launchd") {
+            const domain = launchdDomain();
+            const serviceTarget = `${domain}/${SERVICE_LABEL}`;
+            if (action === "stop") {
+                const result = await runServiceCommand(runner, "launchctl", ["bootout", serviceTarget], timeoutMs);
+                return serviceControlResult(layout, action, result);
+            }
+            if (action === "status") {
+                const result = await runServiceCommand(runner, "launchctl", ["print", serviceTarget], timeoutMs);
+                return serviceControlResult(layout, action, result);
+            }
+            if (action === "restart") {
+                await runServiceCommand(runner, "launchctl", ["bootout", serviceTarget], timeoutMs).catch(() => undefined);
+            }
+            await runServiceCommand(runner, "launchctl", ["bootstrap", domain, layout.servicePath], timeoutMs).catch(() => undefined);
+            await runServiceCommand(runner, "launchctl", ["enable", serviceTarget], timeoutMs).catch(() => undefined);
+            const result = await runServiceCommand(runner, "launchctl", ["kickstart", "-k", serviceTarget], timeoutMs);
+            return serviceControlResult(layout, action, result);
+        }
+        if (layout.manager === "systemd") {
+            const systemdAction = action === "status" ? "status" : action;
+            const args = action === "status"
+                ? ["--user", "status", "--no-pager", SYSTEMD_SERVICE_NAME]
+                : ["--user", systemdAction, SYSTEMD_SERVICE_NAME];
+            const result = await runServiceCommand(runner, "systemctl", args, timeoutMs);
+            return serviceControlResult(layout, action, result);
+        }
+        if (layout.manager === "windows-task-scheduler") {
+            const command = action === "status"
+                ? [
+                    `$task = Get-ScheduledTask -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)} -ErrorAction Stop`,
+                    `$info = Get-ScheduledTaskInfo -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)} -ErrorAction Stop`,
+                    "[pscustomobject]@{TaskName=$task.TaskName;State=$task.State;LastRunTime=$info.LastRunTime;LastTaskResult=$info.LastTaskResult} | ConvertTo-Json -Compress"
+                ].join("; ")
+                : action === "restart"
+                    ? `${windowsTaskCommand("Stop-ScheduledTask")} -ErrorAction SilentlyContinue; ${windowsTaskCommand("Start-ScheduledTask")}`
+                    : windowsTaskCommand(action === "start" ? "Start-ScheduledTask" : "Stop-ScheduledTask");
+            const result = await runServiceCommand(runner, "powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", command], timeoutMs);
+            return serviceControlResult(layout, action, result);
+        }
+    }
+    catch (error) {
+        if (action === "status") {
+            return serviceControlResult(layout, action, { stdout: "", stderr: "" }, false, error instanceof Error ? error.message : String(error));
+        }
+        throw error;
+    }
+    throw new Error(`Persistent service control is not supported on ${layout.platform}`);
+}
+export async function uninstallSelfHostedNodeService(options = {}) {
+    const layout = resolveSelfHostedNodeServiceLayout(options);
+    const runner = options.runner || defaultCommandRunner;
+    const timeoutMs = serviceCommandTimeoutMs(options.requestTimeoutMs);
+    if (layout.manager === "launchd") {
+        await runServiceCommand(runner, "launchctl", ["bootout", `${launchdDomain()}/${SERVICE_LABEL}`], timeoutMs).catch(() => undefined);
+        await rm(layout.servicePath, { force: true });
+        return serviceControlResult(layout, "uninstall", { stdout: "", stderr: "" });
+    }
+    if (layout.manager === "systemd") {
+        await runServiceCommand(runner, "systemctl", ["--user", "disable", "--now", SYSTEMD_SERVICE_NAME], timeoutMs).catch(() => undefined);
+        await rm(layout.servicePath, { force: true });
+        await runServiceCommand(runner, "systemctl", ["--user", "daemon-reload"], timeoutMs).catch(() => undefined);
+        return serviceControlResult(layout, "uninstall", { stdout: "", stderr: "" });
+    }
+    if (layout.manager === "windows-task-scheduler") {
+        const command = `${windowsTaskCommand("Stop-ScheduledTask")} -ErrorAction SilentlyContinue; Unregister-ScheduledTask -TaskName ${quotePowerShellValue(WINDOWS_TASK_NAME)} -Confirm:$false -ErrorAction SilentlyContinue`;
+        await runServiceCommand(runner, "powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", command], timeoutMs).catch(() => undefined);
+        await rm(layout.servicePath, { force: true });
+        return serviceControlResult(layout, "uninstall", { stdout: "", stderr: "" });
+    }
+    throw new Error(`Persistent service uninstall is not supported on ${layout.platform}`);
+}
 export async function readSelfHostedNodeConfig(env = process.env) {
     const statePath = optionalText(env.MSWARM_SELF_HOSTED_NODE_STATE_PATH) || defaultStatePath();
     const runtimeTokenPath = optionalText(env.MSWARM_SELF_HOSTED_NODE_KEY_PATH) || defaultRuntimeTokenPath();
@@ -215,11 +668,15 @@ export async function readSelfHostedNodeConfig(env = process.env) {
     return {
         gatewayBaseUrl: trimTrailingSlash(gatewayBaseUrl),
         nodeId,
+        serverName: optionalText(env.MSWARM_SELF_HOSTED_SERVER_NAME) || state.server_name || null,
+        relayMode: parseRelayMode(env.MSWARM_SELF_HOSTED_RELAY_MODE || state.relay_mode),
+        machineFingerprint: state.machine_fingerprint || null,
+        directBaseUrl: optionalText(env.MSWARM_SELF_HOSTED_DIRECT_BASE_URL) || state.direct_base_url || null,
         enrollmentToken: optionalText(env.MSWARM_SELF_HOSTED_ENROLLMENT_TOKEN),
         runtimeToken: optionalText(env.MSWARM_SELF_HOSTED_RUNTIME_TOKEN) || persistedRuntimeToken || state.runtime_token || null,
-        discoveryMode: parseDiscoveryMode(env.MSWARM_SELF_HOSTED_DISCOVERY_MODE),
-        mcodaBin: optionalText(env.MSWARM_SELF_HOSTED_MCODA_BIN) || DEFAULT_MCODA_BIN,
-        mcodaListArgs: parseArgs(env.MSWARM_SELF_HOSTED_MCODA_LIST_ARGS, DEFAULT_MCODA_LIST_ARGS),
+        discoveryMode: parseDiscoveryMode(env.MSWARM_SELF_HOSTED_DISCOVERY_MODE || state.discovery_mode),
+        mcodaBin: optionalText(env.MSWARM_SELF_HOSTED_MCODA_BIN) || state.mcoda_bin || DEFAULT_MCODA_BIN,
+        mcodaListArgs: parseArgs(env.MSWARM_SELF_HOSTED_MCODA_LIST_ARGS || state.mcoda_list_args, DEFAULT_MCODA_LIST_ARGS),
         ollamaBaseUrl: trimTrailingSlash(ollamaBaseUrl),
         statePath,
         runtimeTokenPath,
@@ -227,12 +684,60 @@ export async function readSelfHostedNodeConfig(env = process.env) {
             optionalText(env.MSWARM_SELF_HOSTED_RELAY_SIGNING_SECRET),
         listenHost: optionalText(env.MSWARM_SELF_HOSTED_LISTEN_HOST) || DEFAULT_LISTEN_HOST,
         listenPort: parsePositiveInteger(env.MSWARM_SELF_HOSTED_LISTEN_PORT, DEFAULT_LISTEN_PORT),
-        nodeVersion: optionalText(env.MSWARM_SELF_HOSTED_NODE_VERSION) || "0.1.0",
+        nodeVersion: optionalText(env.MSWARM_SELF_HOSTED_NODE_VERSION) || state.node_version || "0.1.1",
         heartbeatIntervalSeconds: parsePositiveInteger(env.MSWARM_SELF_HOSTED_HEARTBEAT_INTERVAL_SECONDS, state.heartbeat_interval_seconds || DEFAULT_HEARTBEAT_INTERVAL_SECONDS),
+        requestTimeoutMs: parsePositiveInteger(env.MSWARM_SELF_HOSTED_REQUEST_TIMEOUT_MS, state.request_timeout_ms || DEFAULT_REQUEST_TIMEOUT_MS),
+        exposeAllModels: parseBoolean(env.MSWARM_SELF_HOSTED_EXPOSE_ALL_MODELS, typeof state.expose_all_models === "boolean" ? state.expose_all_models : false),
+        modelAllowlist: parseList(env.MSWARM_SELF_HOSTED_MODEL_ALLOWLIST || state.model_allowlist),
+        modelBlocklist: parseList(env.MSWARM_SELF_HOSTED_MODEL_BLOCKLIST || state.model_blocklist)
+    };
+}
+export async function readOwnerSetupConfig(argv = process.argv.slice(3), env = process.env) {
+    const options = parseCliOptions(argv);
+    const statePath = optionalText(env.MSWARM_SELF_HOSTED_NODE_STATE_PATH) || defaultStatePath();
+    const runtimeTokenPath = optionalText(env.MSWARM_SELF_HOSTED_NODE_KEY_PATH) || defaultRuntimeTokenPath();
+    const gatewayBaseUrl = optionalText(options.gateway) ||
+        optionalText(env.MSWARM_GATEWAY_BASE_URL) ||
+        DEFAULT_SETUP_GATEWAY_BASE_URL;
+    const apiKey = optionalText(options["api-key"]) || optionalText(env.MSWARM_API_KEY) || "";
+    if (!apiKey) {
+        throw new Error("--api-key or MSWARM_API_KEY is required");
+    }
+    const relayMode = parseRelayMode(options.mode || env.MSWARM_SELF_HOSTED_RELAY_MODE);
+    const directBaseUrl = optionalText(options["direct-url"]) || optionalText(env.MSWARM_SELF_HOSTED_DIRECT_BASE_URL);
+    if (relayMode === "direct" && !directBaseUrl) {
+        throw new Error("--direct-url is required when --mode direct is used");
+    }
+    if (relayMode === "outbound" && directBaseUrl) {
+        throw new Error("--direct-url can only be used with --mode direct");
+    }
+    const ollamaBaseUrl = optionalText(env.MSWARM_SELF_HOSTED_OLLAMA_BASE_URL) ||
+        optionalText(env.OLLAMA_HOST) ||
+        DEFAULT_OLLAMA_BASE_URL;
+    const allowlist = parseList(options.allow || env.MSWARM_SELF_HOSTED_MODEL_ALLOWLIST);
+    const blocklist = parseList(options.block || env.MSWARM_SELF_HOSTED_MODEL_BLOCKLIST);
+    return {
+        apiKey,
+        gatewayBaseUrl: trimTrailingSlash(gatewayBaseUrl),
+        serverName: normalizeLocalName(optionalText(options["server-name"]) ||
+            optionalText(env.MSWARM_SELF_HOSTED_SERVER_NAME) ||
+            resolveDefaultServerName()),
+        relayMode,
+        directBaseUrl,
+        discoveryMode: parseDiscoveryMode(env.MSWARM_SELF_HOSTED_DISCOVERY_MODE),
+        statePath,
+        runtimeTokenPath,
+        machineIdPath: optionalText(env.MSWARM_SELF_HOSTED_MACHINE_ID_PATH) || defaultMachineIdPath(),
+        mcodaBin: optionalText(env.MSWARM_SELF_HOSTED_MCODA_BIN) || DEFAULT_MCODA_BIN,
+        mcodaListArgs: parseArgs(env.MSWARM_SELF_HOSTED_MCODA_LIST_ARGS, DEFAULT_MCODA_LIST_ARGS),
+        ollamaBaseUrl: trimTrailingSlash(ollamaBaseUrl),
+        nodeVersion: optionalText(env.MSWARM_SELF_HOSTED_NODE_VERSION) || "0.1.1",
+        heartbeatIntervalSeconds: parsePositiveInteger(env.MSWARM_SELF_HOSTED_HEARTBEAT_INTERVAL_SECONDS, DEFAULT_HEARTBEAT_INTERVAL_SECONDS),
         requestTimeoutMs: parsePositiveInteger(env.MSWARM_SELF_HOSTED_REQUEST_TIMEOUT_MS, DEFAULT_REQUEST_TIMEOUT_MS),
-        exposeAllModels: parseBoolean(env.MSWARM_SELF_HOSTED_EXPOSE_ALL_MODELS, false),
-        modelAllowlist: parseList(env.MSWARM_SELF_HOSTED_MODEL_ALLOWLIST),
-        modelBlocklist: parseList(env.MSWARM_SELF_HOSTED_MODEL_BLOCKLIST)
+        exposeAllModels: options["expose-all"] === true || parseBoolean(env.MSWARM_SELF_HOSTED_EXPOSE_ALL_MODELS, false),
+        modelAllowlist: allowlist,
+        modelBlocklist: blocklist,
+        start: options.start === true
     };
 }
 export function mapOllamaModelToSelfHostedModel(model, config) {
@@ -380,10 +885,6 @@ async function defaultCommandRunner(command, args, options) {
     });
 }
 export class McodaAgentInventoryClient {
-    command;
-    args;
-    timeoutMs;
-    runner;
     constructor(input) {
         this.command = input.command || DEFAULT_MCODA_BIN;
         this.args = input.args?.length ? input.args : DEFAULT_MCODA_LIST_ARGS;
@@ -413,9 +914,6 @@ export class McodaAgentInventoryClient {
     }
 }
 export class OllamaClient {
-    baseUrl;
-    fetchImpl;
-    timeoutMs;
     constructor(input) {
         this.baseUrl = trimTrailingSlash(input.baseUrl);
         this.fetchImpl = input.fetchImpl || fetch;
@@ -502,9 +1000,6 @@ function buildOpenAIChatCompletion(input) {
     };
 }
 export class McodaLocalAgentExecutor {
-    command;
-    timeoutMs;
-    runner;
     constructor(input) {
         this.command = input.command || DEFAULT_MCODA_BIN;
         this.timeoutMs = input.timeoutMs || DEFAULT_REQUEST_TIMEOUT_MS;
@@ -534,9 +1029,6 @@ export class McodaLocalAgentExecutor {
     }
 }
 export class MswarmSelfHostedNodeClient {
-    gatewayBaseUrl;
-    fetchImpl;
-    timeoutMs;
     constructor(input) {
         this.gatewayBaseUrl = trimTrailingSlash(input.gatewayBaseUrl);
         this.fetchImpl = input.fetchImpl || fetch;
@@ -549,6 +1041,19 @@ export class MswarmSelfHostedNodeClient {
             body: JSON.stringify({ node_id: nodeId, enrollment_token: enrollmentToken })
         }, this.timeoutMs);
     }
+    async bootstrap(apiKey, payload) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/bootstrap`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                "x-api-key": apiKey
+            },
+            body: JSON.stringify(payload)
+        }, this.timeoutMs);
+    }
+    async health() {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/healthz`, { method: "GET" }, this.timeoutMs);
+    }
     async heartbeat(runtimeToken, payload) {
         return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/heartbeat`, {
             method: "POST",
@@ -569,13 +1074,28 @@ export class MswarmSelfHostedNodeClient {
             body: JSON.stringify(payload)
         }, this.timeoutMs);
     }
+    async pollJob(runtimeToken, payload) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/poll`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${runtimeToken}`
+            },
+            body: JSON.stringify(payload)
+        }, Math.max(this.timeoutMs, (payload.wait_ms || 0) + 5000));
+    }
+    async postJobResult(runtimeToken, jobId, payload) {
+        return fetchJson(this.fetchImpl, `${this.gatewayBaseUrl}/v1/swarm/self-hosted/node/jobs/${encodeURIComponent(jobId)}/result`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Bearer ${runtimeToken}`
+            },
+            body: JSON.stringify(payload)
+        }, this.timeoutMs);
+    }
 }
 export class SelfHostedNodeRuntime {
-    config;
-    gateway;
-    mcoda;
-    mcodaExecutor;
-    ollama;
     constructor(config, deps) {
         this.config = config;
         this.gateway =
@@ -606,6 +1126,96 @@ export class SelfHostedNodeRuntime {
                     timeoutMs: config.requestTimeoutMs
                 });
     }
+    static async setup(setupConfig, deps) {
+        const gateway = deps?.gateway ||
+            new MswarmSelfHostedNodeClient({
+                gatewayBaseUrl: setupConfig.gatewayBaseUrl,
+                fetchImpl: deps?.fetchImpl,
+                timeoutMs: setupConfig.requestTimeoutMs
+            });
+        const machineId = await readOrCreateSelfHostedMachineId(setupConfig.machineIdPath);
+        const machineFingerprint = machineFingerprintFromId(machineId);
+        const bootstrap = await gateway.bootstrap(setupConfig.apiKey, {
+            machine_fingerprint: machineFingerprint,
+            server_name: setupConfig.serverName,
+            label: setupConfig.serverName,
+            relay_mode: setupConfig.relayMode,
+            direct_base_url: setupConfig.directBaseUrl || null,
+            node_version: setupConfig.nodeVersion,
+            discovery_mode: setupConfig.discoveryMode,
+            expose_all_models: setupConfig.exposeAllModels,
+            model_allowlist: setupConfig.modelAllowlist,
+            model_blocklist: setupConfig.modelBlocklist,
+            heartbeat_interval_seconds: setupConfig.heartbeatIntervalSeconds
+        });
+        const nodeId = optionalText(bootstrap.node?.node_id);
+        const runtimeToken = optionalText(bootstrap.runtime_token);
+        if (!nodeId || !runtimeToken) {
+            throw new Error("Bootstrap response did not include node_id and runtime_token");
+        }
+        const heartbeatInterval = bootstrap.heartbeat_interval_seconds || setupConfig.heartbeatIntervalSeconds;
+        const state = {
+            node_id: nodeId,
+            server_name: optionalText(bootstrap.node?.server_name) || setupConfig.serverName,
+            relay_mode: bootstrap.node?.relay_mode || setupConfig.relayMode,
+            machine_fingerprint: machineFingerprint,
+            direct_base_url: setupConfig.directBaseUrl || null,
+            runtime_token: undefined,
+            config_version: bootstrap.config_version,
+            heartbeat_interval_seconds: heartbeatInterval,
+            heartbeat_timeout_seconds: bootstrap.heartbeat_timeout_seconds,
+            enrolled_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            gateway_base_url: setupConfig.gatewayBaseUrl,
+            ollama_base_url: setupConfig.ollamaBaseUrl,
+            discovery_mode: setupConfig.discoveryMode,
+            mcoda_bin: setupConfig.mcodaBin,
+            mcoda_list_args: setupConfig.mcodaListArgs,
+            node_version: setupConfig.nodeVersion,
+            request_timeout_ms: setupConfig.requestTimeoutMs,
+            expose_all_models: setupConfig.exposeAllModels,
+            model_allowlist: setupConfig.modelAllowlist,
+            model_blocklist: setupConfig.modelBlocklist
+        };
+        await writeSelfHostedNodeState(setupConfig.statePath, state);
+        await writeSelfHostedRuntimeToken(setupConfig.runtimeTokenPath, runtimeToken);
+        const runtime = new SelfHostedNodeRuntime({
+            gatewayBaseUrl: setupConfig.gatewayBaseUrl,
+            nodeId,
+            serverName: state.server_name,
+            relayMode: state.relay_mode || setupConfig.relayMode,
+            machineFingerprint,
+            directBaseUrl: setupConfig.directBaseUrl || null,
+            enrollmentToken: null,
+            runtimeToken,
+            discoveryMode: setupConfig.discoveryMode,
+            mcodaBin: setupConfig.mcodaBin,
+            mcodaListArgs: setupConfig.mcodaListArgs,
+            ollamaBaseUrl: setupConfig.ollamaBaseUrl,
+            statePath: setupConfig.statePath,
+            runtimeTokenPath: setupConfig.runtimeTokenPath,
+            invocationSigningSecret: null,
+            listenHost: DEFAULT_LISTEN_HOST,
+            listenPort: DEFAULT_LISTEN_PORT,
+            nodeVersion: setupConfig.nodeVersion,
+            heartbeatIntervalSeconds: heartbeatInterval,
+            requestTimeoutMs: setupConfig.requestTimeoutMs,
+            exposeAllModels: setupConfig.exposeAllModels,
+            modelAllowlist: setupConfig.modelAllowlist,
+            modelBlocklist: setupConfig.modelBlocklist
+        }, { ...deps, gateway });
+        const once = await runtime.runOnce();
+        return {
+            created: bootstrap.created === true,
+            nodeId,
+            serverName: state.server_name || setupConfig.serverName,
+            modelCount: once.model_count,
+            status: once.status,
+            statePath: setupConfig.statePath,
+            runtimeTokenPath: setupConfig.runtimeTokenPath,
+            start: setupConfig.start
+        };
+    }
     async discoverModels() {
         if (this.config.discoveryMode === "ollama") {
             const [version, models] = await Promise.all([
@@ -642,7 +1252,15 @@ export class SelfHostedNodeRuntime {
             enrolled_at: currentState.enrolled_at || new Date().toISOString(),
             updated_at: new Date().toISOString(),
             gateway_base_url: this.config.gatewayBaseUrl,
-            ollama_base_url: this.config.ollamaBaseUrl
+            ollama_base_url: this.config.ollamaBaseUrl,
+            discovery_mode: this.config.discoveryMode,
+            mcoda_bin: this.config.mcodaBin,
+            mcoda_list_args: this.config.mcodaListArgs,
+            node_version: this.config.nodeVersion,
+            request_timeout_ms: this.config.requestTimeoutMs,
+            expose_all_models: this.config.exposeAllModels,
+            model_allowlist: this.config.modelAllowlist,
+            model_blocklist: this.config.modelBlocklist
         };
         await writeSelfHostedNodeState(this.config.statePath, nextState);
         await writeSelfHostedRuntimeToken(this.config.runtimeTokenPath, runtimeToken);
@@ -814,9 +1432,75 @@ export class SelfHostedNodeRuntime {
         });
         return { count: models.length, response };
     }
+    async pollAndExecuteJob(waitMs = DEFAULT_JOB_POLL_WAIT_MS) {
+        const enrollment = await this.ensureEnrolled();
+        const response = await this.gateway.pollJob(enrollment.runtimeToken, {
+            node_id: this.config.nodeId,
+            capacity: { active_jobs: 0, max_jobs: 1 },
+            wait_ms: waitMs
+        });
+        const job = response.job || null;
+        if (!job) {
+            return { executed: false };
+        }
+        const result = await this.executeJob(job);
+        await this.gateway.postJobResult(enrollment.runtimeToken, job.job_id, {
+            ...result,
+            node_id: this.config.nodeId
+        });
+        return { executed: true, job_id: job.job_id, status: result.status };
+    }
+    async doctor() {
+        const checks = [];
+        checks.push({ name: "config", ok: Boolean(this.config.nodeId), message: this.config.nodeId || "missing node id" });
+        const runtimeToken = this.config.runtimeToken || (await readSelfHostedRuntimeToken(this.config.runtimeTokenPath));
+        checks.push({ name: "runtime_token", ok: Boolean(runtimeToken), message: runtimeToken ? "present" : "missing" });
+        try {
+            await this.gateway.health();
+            checks.push({ name: "gateway_health", ok: true });
+        }
+        catch (error) {
+            checks.push({
+                name: "gateway_health",
+                ok: false,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+        try {
+            const once = await this.runOnce();
+            checks.push({ name: "heartbeat", ok: once.status === "online", message: once.status });
+            checks.push({
+                name: "local_agents",
+                ok: once.model_count > 0,
+                message: `${once.model_count} exposed local agent(s)`
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: "heartbeat",
+                ok: false,
+                message: error instanceof Error ? error.message : String(error)
+            });
+        }
+        return { ok: checks.every((check) => check.ok), checks };
+    }
     startDaemon() {
         let stopped = false;
         let timer = null;
+        let polling = false;
+        const poll = () => {
+            if (stopped || polling || this.config.relayMode === "direct")
+                return;
+            polling = true;
+            void this.pollAndExecuteJob()
+                .catch(() => undefined)
+                .finally(() => {
+                polling = false;
+                if (!stopped) {
+                    setTimeout(poll, 0);
+                }
+            });
+        };
         const schedule = () => {
             if (stopped)
                 return;
@@ -828,7 +1512,10 @@ export class SelfHostedNodeRuntime {
         };
         void this.runOnce()
             .catch(() => undefined)
-            .finally(schedule);
+            .finally(() => {
+            schedule();
+            poll();
+        });
         return {
             stop: () => {
                 stopped = true;