auvrynt 1.0.2 → 1.0.5

package/dist/cli/dashboard-native-actions.js

@@ -0,0 +1,282 @@
+import { spawn } from "node:child_process";
+const MAX_COMMAND_LENGTH = 512;
+const MAX_OUTPUT_BYTES = 64 * 1024;
+const COMMAND_TIMEOUT_MS = 30_000;
+export async function selectNativeWorkspaceFolder(initialPath) {
+    if (process.platform === "win32")
+        return selectWindowsFolder(initialPath);
+    if (process.platform === "darwin") {
+        const script = 'POSIX path of (choose folder with prompt "Choose Auvrynt workspace")';
+        return cleanSelectedPath(await runPicker("osascript", ["-e", script], initialPath));
+    }
+    try {
+        const zenity = await runPicker("zenity", ["--file-selection", "--directory", "--title=Choose Auvrynt workspace", `--filename=${withTrailingSeparator(initialPath)}`], initialPath);
+        return cleanSelectedPath(zenity);
+    }
+    catch (error) {
+        if (!isMissingExecutable(error))
+            throw error;
+    }
+    try {
+        const kdialog = await runPicker("kdialog", ["--getexistingdirectory", initialPath, "--title", "Choose Auvrynt workspace"], initialPath);
+        return cleanSelectedPath(kdialog);
+    }
+    catch (error) {
+        if (!isMissingExecutable(error))
+            throw error;
+    }
+    throw new Error("No native folder picker is available. Install zenity or kdialog.");
+}
+export function parseAuvryntDashboardCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed)
+        throw new Error("Enter an Auvrynt command.");
+    if (trimmed.length > MAX_COMMAND_LENGTH)
+        throw new Error(`Command exceeds ${MAX_COMMAND_LENGTH} characters.`);
+    const tokens = [];
+    let current = "";
+    let quote;
+    for (let index = 0; index < trimmed.length; index++) {
+        const char = trimmed[index];
+        const next = trimmed[index + 1];
+        if (char === "\\" && quote !== "'" && next) {
+            const escapable = next === "\\"
+                || next === '"'
+                || (!quote && (next === "'" || /\s/.test(next)));
+            if (escapable) {
+                current += next;
+                index++;
+                continue;
+            }
+        }
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else
+                current += char;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current)
+                tokens.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    if (quote)
+        throw new Error("Command contains an unclosed quote.");
+    if (current)
+        tokens.push(current);
+    const auvryntIndex = tokens.findIndex((token) => token.toLowerCase() === "auvrynt");
+    if (auvryntIndex < 0) {
+        throw new Error("Only Auvrynt CLI commands are allowed here. Include `auvrynt` after any AUVRYNT_ environment assignments.");
+    }
+    const commandEnv = {};
+    for (const assignment of tokens.slice(0, auvryntIndex)) {
+        const match = assignment.match(/^(AUVRYNT_[A-Z0-9_]+)=(.*)$/);
+        if (!match)
+            throw new Error("Only AUVRYNT_ environment assignments may appear before `auvrynt`.");
+        if (isSensitiveName(match[1])) {
+            throw new Error("Sensitive token, authentication, and password environment values are not allowed in the dashboard terminal.");
+        }
+        commandEnv[match[1]] = match[2];
+    }
+    return { args: tokens.slice(auvryntIndex + 1), env: commandEnv };
+}
+export function assertDashboardCommandSupported(args) {
+    const command = args[0]?.toLowerCase() ?? "";
+    if (!command)
+        throw new Error("Choose a specific non-interactive Auvrynt subcommand, such as `auvrynt status`.");
+    const blocked = new Map([
+        ["serve", "`auvrynt serve` cannot run inside the already-running dashboard server."],
+        ["token", "Token commands are hidden from the dashboard for security. Run them in a local terminal."],
+        ["uninstall", "Uninstall is not available from the dashboard terminal."],
+        ["init", "Interactive setup commands must run in a local terminal."],
+        ["setup", "Interactive setup commands must run in a local terminal."],
+        ["enable", "Use the Connectivity tab or a local terminal for interactive integration selection."],
+        ["disable", "Use the Connectivity tab or a local terminal for interactive integration selection."],
+        ["tunnel", "Interactive tunnel selection must run in a local terminal."],
+        ["change", "Use the Connectivity workspace picker so the selected folder is applied safely."],
+        ["restart", "Use the dashboard Restart button so reconnection is handled correctly."],
+        ["stop", "Use the dashboard Stop button so shutdown is handled correctly."],
+    ]);
+    const reason = blocked.get(command);
+    if (reason)
+        throw new Error(reason);
+    if (command === "config" && args[1]?.toLowerCase() === "get") {
+        throw new Error("Configuration output may contain local secrets. Run `auvrynt config get` in a local terminal.");
+    }
+    if (command === "config" && args[1]?.toLowerCase() === "set" && isSensitiveName(args[2] ?? "")) {
+        throw new Error("Sensitive configuration values must be changed from a local terminal.");
+    }
+}
+export async function runAuvryntDashboardCommand(command, cwd, entrypoint = process.argv[1]) {
+    if (!entrypoint)
+        throw new Error("Auvrynt CLI entrypoint is unavailable.");
+    const parsed = parseAuvryntDashboardCommand(command);
+    assertDashboardCommandSupported(parsed.args);
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [entrypoint, ...parsed.args], {
+            cwd,
+            env: { ...process.env, ...parsed.env, NO_COLOR: "1", FORCE_COLOR: "0" },
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let output = "";
+        let timedOut = false;
+        const append = (chunk) => {
+            if (Buffer.byteLength(output) >= MAX_OUTPUT_BYTES)
+                return;
+            output += String(chunk);
+            if (Buffer.byteLength(output) > MAX_OUTPUT_BYTES) {
+                output = Buffer.from(output).subarray(0, MAX_OUTPUT_BYTES).toString("utf8") + "\n… output truncated …\n";
+            }
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill();
+        }, COMMAND_TIMEOUT_MS);
+        timer.unref();
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (exitCode) => {
+            clearTimeout(timer);
+            resolve({
+                command: command.trim(),
+                output: output.trimEnd() || (timedOut ? "Command timed out." : "Command completed with no output."),
+                exitCode,
+                timedOut,
+            });
+        });
+    });
+}
+async function selectWindowsFolder(initialPath) {
+    // Modern Vista+ folder picker (IFileOpenDialog + FOS_PICKFOLDERS).
+    // Avoids the classic tree-style FolderBrowserDialog ("Browse For Folder").
+    const csharp = [
+        "using System;",
+        "using System.Runtime.InteropServices;",
+        "public static class AuvryntFolderPicker {",
+        "  [DllImport(\"shell32.dll\", CharSet = CharSet.Unicode)]",
+        "  static extern int SHCreateItemFromParsingName([MarshalAs(UnmanagedType.LPWStr)] string path, IntPtr pbc, ref Guid riid, out IShellItem item);",
+        "  [ComImport, Guid(\"DC1C5A9C-E88A-4dde-A5A1-60F82A20AEF7\")] class FileOpenDialogRCW {}",
+        "  [ComImport, Guid(\"42f85136-db7e-439e-9acc-46061d997987\"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]",
+        "  interface IFileOpenDialog {",
+        "    [PreserveSig] int Show(IntPtr parent); void SetFileTypes(uint c, IntPtr rg); void SetFileTypeIndex(uint i);",
+        "    void GetFileTypeIndex(out uint i); void Advise(IntPtr pfde, out uint cookie); void Unadvise(uint cookie);",
+        "    void SetOptions(uint fos); void GetOptions(out uint fos); void SetDefaultFolder(IShellItem psi);",
+        "    void SetFolder(IShellItem psi); void GetFolder(out IShellItem psi); void GetCurrentSelection(out IShellItem psi);",
+        "    void SetFileName([MarshalAs(UnmanagedType.LPWStr)] string name); void GetFileName([MarshalAs(UnmanagedType.LPWStr)] out string name);",
+        "    void SetTitle([MarshalAs(UnmanagedType.LPWStr)] string title); void SetOkButtonLabel([MarshalAs(UnmanagedType.LPWStr)] string label);",
+        "    void SetFileNameLabel([MarshalAs(UnmanagedType.LPWStr)] string label); void GetResult(out IShellItem psi);",
+        "    void AddPlace(IShellItem psi, int fdap); void SetDefaultExtension([MarshalAs(UnmanagedType.LPWStr)] string ext);",
+        "    void Close(int hr); void SetClientGuid(ref Guid guid); void ClearClientData(); void SetFilter(IntPtr pFilter);",
+        "    void GetResults(out IntPtr ppenum); void GetSelectedItems(out IntPtr ppsai);",
+        "  }",
+        "  [ComImport, Guid(\"43826D1E-E718-42EE-BC55-A1E261C37BFE\"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]",
+        "  interface IShellItem {",
+        "    void BindToHandler(IntPtr pbc, ref Guid bhid, ref Guid riid, out IntPtr ppv);",
+        "    void GetParent(out IShellItem ppsi);",
+        "    void GetDisplayName(uint sigdn, [MarshalAs(UnmanagedType.LPWStr)] out string ppszName);",
+        "    void GetAttributes(uint sfgaoMask, out uint psfgaoAttribs);",
+        "    void Compare(IShellItem psi, uint hint, out int piOrder);",
+        "  }",
+        "  const uint FOS_PICKFOLDERS = 0x20; const uint FOS_FORCEFILESYSTEM = 0x40; const uint FOS_PATHMUSTEXIST = 0x1000; const uint SIGDN_FILESYSPATH = 0x80058000;",
+        "  public static string Select(string title, string initial) {",
+        "    var dialog = (IFileOpenDialog)new FileOpenDialogRCW();",
+        "    uint options; dialog.GetOptions(out options);",
+        "    dialog.SetOptions(options | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST);",
+        "    dialog.SetTitle(title ?? \"Choose Auvrynt workspace\");",
+        "    if (!string.IsNullOrWhiteSpace(initial)) {",
+        "      try {",
+        "        Guid iid = typeof(IShellItem).GUID; IShellItem folder;",
+        "        if (SHCreateItemFromParsingName(initial, IntPtr.Zero, ref iid, out folder) == 0) dialog.SetFolder(folder);",
+        "      } catch {}",
+        "    }",
+        "    if (dialog.Show(IntPtr.Zero) != 0) return null;",
+        "    IShellItem result; dialog.GetResult(out result); string path; result.GetDisplayName(SIGDN_FILESYSPATH, out path); return path;",
+        "  }",
+        "}",
+    ].join("\n");
+    const script = [
+        `$code = @'\n${csharp}\n'@`,
+        "Add-Type -TypeDefinition $code -Language CSharp",
+        "$initial = $env:AUVRYNT_PICKER_INITIAL",
+        "if (-not $initial -or -not (Test-Path -LiteralPath $initial)) { $initial = [Environment]::GetFolderPath('Desktop') }",
+        "$path = [AuvryntFolderPicker]::Select('Choose Auvrynt workspace', $initial)",
+        "if ($path) { [Console]::Out.Write($path) }",
+    ].join("; ");
+    try {
+        return cleanSelectedPath(await runPicker("powershell.exe", ["-NoProfile", "-STA", "-Command", script], initialPath));
+    }
+    catch (error) {
+        if (isMissingExecutable(error)) {
+            throw new Error("Windows PowerShell is unavailable, so the native workspace picker cannot be opened.");
+        }
+        throw error;
+    }
+}
+function runPicker(executable, args, initialPath) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, args, {
+            env: { ...process.env, AUVRYNT_PICKER_INITIAL: initialPath },
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => { stdout += String(chunk); });
+        child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+        let settled = false;
+        const finish = (result, error) => {
+            if (settled)
+                return;
+            settled = true;
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        child.once("error", (error) => finish(undefined, error));
+        child.once("close", (code) => {
+            if (code === 0) {
+                finish(stdout);
+                return;
+            }
+            if (pickerWasCanceled(code, stdout, stderr)) {
+                finish(undefined);
+                return;
+            }
+            finish(undefined, new Error(stderr.trim() || `${executable} exited with code ${code}.`));
+        });
+    });
+}
+function cleanSelectedPath(value) {
+    const path = value?.trim();
+    return path || undefined;
+}
+function pickerWasCanceled(code, stdout, stderr) {
+    if (stdout.trim())
+        return false;
+    if (code === 1 && !stderr.trim())
+        return true;
+    return /user canceled|user cancelled|\(-128\)/i.test(stderr);
+}
+function isMissingExecutable(error) {
+    return error?.code === "ENOENT";
+}
+function withTrailingSeparator(path) {
+    return /[\\/]$/.test(path) ? path : `${path}/`;
+}
+function isSensitiveName(value) {
+    return /(TOKEN|SECRET|PASSWORD|OWNER|AUTH|PRIVATE|CREDENTIAL)/i.test(value);
+}

package/dist/cli/foreground-server.js

@@ -0,0 +1,270 @@
+import { timingSafeEqual } from "node:crypto";
+import { loadConfig } from "../config.js";
+import { hardenHttpServer } from "../http-server-hardening.js";
+import { isLoopbackRequest, logEvent } from "../logger.js";
+import { discoverLocalIntegrations, processDetected, } from "../integration-discovery.js";
+import { getGlobalGodotPluginStatus } from "../godot-tools.js";
+import { getPlaywrightRuntimeStatus } from "../playwright-runtime.js";
+import { loadAuvryntFiles } from "../user-config.js";
+import { INTEGRATION_KEYS, } from "../background-lifecycle.js";
+import { tunnelProviderLabel } from "../tunnels/tunnel-manager.js";
+import { dashboardUrl, httpUrl, RUNNING_COMMAND_HINTS, scheduleCrashRecovery, writeFatalLog, } from "./runtime-support.js";
+import { checkSqliteNative } from "./commands/status-commands.js";
+import { registerDashboardActions } from "./dashboard-actions.js";
+import { applyDetectedSerenaDefault } from "./serena-detected-default.js";
+import { startTunnelHealthMonitor } from "./tunnel-health-monitor.js";
+export async function serveForegroundServer() {
+    const sqliteStatus = checkSqliteNative();
+    if (sqliteStatus !== "ok") {
+        throw new Error([
+            "better-sqlite3 could not load for this Node runtime.",
+            sqliteStatus,
+            "",
+            "Try reinstalling or rebuilding dependencies under the active Node version:",
+            "  npm rebuild better-sqlite3",
+        ].join("\n"));
+    }
+    const { createServer } = await import("../server.js");
+    const config = loadConfig();
+    const integrationStatus = await discoverLocalIntegrations().catch(() => ({
+        processes: [], executables: {}, ports: {},
+    }));
+    applyDetectedSerenaDefault(config, integrationStatus, loadAuvryntFiles().config);
+    const runningServer = createServer(config);
+    const { app } = runningServer;
+    const startMode = process.env.AUVRYNT_START_MODE === "true";
+    let fatalExitStarted = false;
+    const exitAfterFatalError = (type, error) => {
+        if (fatalExitStarted)
+            return;
+        fatalExitStarted = true;
+        writeFatalLog(config.stateDir, type, error);
+        scheduleCrashRecovery(config.stateDir, type);
+        process.exitCode = 1;
+        setImmediate(() => process.exit(1));
+    };
+    process.once("uncaughtException", (error, origin) => {
+        exitAfterFatalError(`uncaughtException:${origin}`, error);
+    });
+    process.once("unhandledRejection", (reason) => {
+        exitAfterFatalError("unhandledRejection", reason);
+    });
+    const publicMcpUrl = config.publicBaseUrl
+        ? `${config.publicBaseUrl.replace(/\/$/, "")}/mcp`
+        : httpUrl(config.host, config.port, "/mcp");
+    const godotPlugin = getGlobalGodotPluginStatus();
+    const godotIsSetup = Boolean(config.executables.godot || config.executables.godotCsharp);
+    const controlToken = process.env.AUVRYNT_CONTROL_TOKEN;
+    let requestShutdown;
+    const controlAuthorized = (authorization) => {
+        if (!controlToken || !authorization?.startsWith("Bearer "))
+            return false;
+        const provided = Buffer.from(authorization.slice("Bearer ".length));
+        const expected = Buffer.from(controlToken);
+        return provided.length === expected.length
+            && timingSafeEqual(provided, expected);
+    };
+    registerDashboardActions({
+        runningServer,
+        config,
+        requestShutdown: () => { void requestShutdown?.(); },
+    });
+    if (controlToken) {
+        app.post("/__auvrynt/control/profiles", async (req, res) => {
+            if (!isLoopbackRequest(req)
+                || !controlAuthorized(req.header("authorization"))) {
+                res.status(404).end();
+                return;
+            }
+            const body = req.body;
+            const integrations = body?.integrations;
+            if (!integrations
+                || typeof integrations !== "object"
+                || !INTEGRATION_KEYS.every((key) => typeof integrations[key] === "boolean")) {
+                res.status(400).json({ error: "Invalid integration profile." });
+                return;
+            }
+            const result = await runningServer.updateIntegrations(integrations, typeof body.serenaExecutable === "string"
+                ? { serenaExecutable: body.serenaExecutable }
+                : undefined);
+            if (!result.updated) {
+                res.status(409).json({
+                    error: "An MCP request is active; retry after it finishes.",
+                    ...result,
+                });
+                return;
+            }
+            res.json(result);
+        });
+        app.post("/__auvrynt/control/shutdown", (req, res) => {
+            if (!isLoopbackRequest(req)
+                || !controlAuthorized(req.header("authorization"))) {
+                res.status(404).end();
+                return;
+            }
+            res.status(202).json({ stopping: true });
+            setImmediate(() => void requestShutdown?.());
+        });
+    }
+    await new Promise((resolveServer, rejectServer) => {
+        const httpServer = app.listen(config.port, config.host, () => {
+            if (startMode) {
+                printManagedStartBanner(config, publicMcpUrl, godotPlugin.installed, godotIsSetup, integrationStatus);
+            }
+            else {
+                printForegroundStartBanner(config);
+            }
+            hardenHttpServer(httpServer);
+            startTunnelHealthMonitor(config);
+            logEvent(config.logging, "info", "server_started", {
+                pid: process.pid,
+                host: config.host,
+                port: config.port,
+                publicMcpUrl,
+                integrations: config.integrations,
+            });
+        });
+        let shutdownPromise;
+        const removeSignalHandlers = () => {
+            process.removeListener("SIGINT", shutdown);
+            process.removeListener("SIGTERM", shutdown);
+        };
+        const shutdown = () => {
+            if (shutdownPromise)
+                return shutdownPromise;
+            clearRuntimeIndicators();
+            shutdownPromise = new Promise((resolveShutdown, rejectShutdown) => {
+                const forceClose = setTimeout(() => httpServer.closeAllConnections(), 15_000);
+                forceClose.unref();
+                httpServer.close((error) => {
+                    clearTimeout(forceClose);
+                    if (error) {
+                        rejectShutdown(error);
+                        return;
+                    }
+                    void runningServer.close().then(() => {
+                        removeSignalHandlers();
+                        resolveServer();
+                        resolveShutdown();
+                    }, rejectShutdown);
+                });
+            });
+            return shutdownPromise;
+        };
+        requestShutdown = shutdown;
+        httpServer.once("error", (error) => {
+            removeSignalHandlers();
+            void runningServer.close()
+                .catch((closeError) => {
+                writeFatalLog(config.stateDir, "serverErrorCleanup", closeError);
+            })
+                .finally(() => rejectServer(error));
+        });
+        process.once("SIGINT", () => {
+            void shutdown().catch(() => {
+                process.exitCode = 1;
+            });
+        });
+        process.once("SIGTERM", () => {
+            void shutdown().catch(() => {
+                process.exitCode = 1;
+            });
+        });
+    });
+}
+function printManagedStartBanner(config, publicMcpUrl, godotPluginInstalled, godotIsSetup, integrationStatus) {
+    console.clear();
+    console.log("");
+    console.log("  \x1b[36m\x1b[1mAuvrynt: Webkit Arsenal is ready\x1b[0m");
+    console.log("");
+    const godotBridgeUp = integrationStatus.ports.auvrynt_godot_bridge;
+    const blenderBridgeUp = integrationStatus.ports.auvrynt_blender_bridge
+        || integrationStatus.ports.blender_lab_mcp;
+    const godotConfigured = godotIsSetup || godotPluginInstalled;
+    const godotCsharpConfigured = Boolean(config.executables.godotCsharp);
+    const serenaConfigured = Boolean(process.env.AUVRYNT_SERENA_EXECUTABLE
+        || integrationStatus.executables.serena
+        || processDetected(integrationStatus, "serena"));
+    const playwrightReady = getPlaywrightRuntimeStatus().chromiumInstalled;
+    console.log(integrationLine("Godot GDScript:", godotBridgeUp, godotConfigured, config.integrations.godotGdscript));
+    console.log(integrationLine("Godot C#:", godotBridgeUp, godotCsharpConfigured, config.integrations.godotCsharp));
+    console.log(integrationLine("Blender:", blenderBridgeUp, true, config.integrations.blender));
+    console.log(integrationLine("Serena:", serenaConfigured, serenaConfigured, config.integrations.serena));
+    console.log(integrationLine("Playwright:", playwrightReady, playwrightReady, config.integrations.playwright));
+    console.log("");
+    console.log("  \x1b[90mDashboard:\x1b[0m");
+    console.log(`    \x1b[36m${dashboardUrl(config.host, config.port)}\x1b[0m`);
+    console.log("  \x1b[90mWeb Agent connector URL:\x1b[0m");
+    console.log(`    \x1b[36m${publicMcpUrl}\x1b[0m`);
+    console.log("  \x1b[90mAuthorization page:\x1b[0m");
+    console.log(`    \x1b[36m${config.publicBaseUrl.replace(/\/$/, "")}/authorize\x1b[0m`);
+    console.log("  \x1b[90mOwner token:\x1b[0m");
+    console.log("    \x1b[33mhidden — run `auvrynt token` locally to view\x1b[0m");
+    console.log("");
+    console.log("  \x1b[90mNote:\x1b[0m");
+    console.log(`    Web-agent workspace: ${config.allowedRoots.join(", ")}`);
+    if (config.tunnelProvider === "ngrok" && config.ngrokUrl) {
+        console.log(`    Stable ngrok URL: ${config.ngrokUrl}`);
+    }
+    else {
+        console.log(`    The ${tunnelProviderLabel(config.tunnelProvider)} URL is temporary.`);
+        console.log("    Server restarts preserve this URL while the managed tunnel remains healthy.");
+    }
+    console.log("");
+    for (const hint of RUNNING_COMMAND_HINTS)
+        console.log(`  \x1b[90m${hint}\x1b[0m`);
+    console.log("");
+    if (!process.stdout.isTTY) {
+        console.log("[auvrynt] Background logging active.");
+        return;
+    }
+    const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    let frameIndex = 0;
+    let mcpEventsCount = 0;
+    let lastEvent = "Started successfully";
+    global.auvryntLogEmitter = (level, event) => {
+        mcpEventsCount++;
+        lastEvent = `${event} (${level})`;
+    };
+    const interval = setInterval(() => {
+        const frame = frames[frameIndex];
+        frameIndex = (frameIndex + 1) % frames.length;
+        process.stdout.write(`\r\x1b[K  \x1b[32m${frame}\x1b[0m Logs active... (${mcpEventsCount} requests handled | Last: ${lastEvent})`);
+    }, 100);
+    global.auvryntStartInterval = interval;
+}
+function printForegroundStartBanner(config) {
+    console.log(`auvrynt listening on ${httpUrl(config.host, config.port, "/mcp")}`);
+    console.log(`public base url: ${config.publicBaseUrl}`);
+    console.log(`allowed roots: ${config.allowedRoots.join(", ")}`);
+    console.log(`allowed hosts: ${config.allowedHosts.join(", ")}`);
+    if (config.allowedHosts.includes("*")) {
+        console.warn("warning: Host header allowlist is disabled because AUVRYNT_ALLOWED_HOSTS=*");
+    }
+    console.log("auth: Owner token approval required");
+    console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+}
+function integrationLine(label, reachable, configured, enabled = true) {
+    const padded = label.padEnd(20);
+    if (!enabled) {
+        return `  \x1b[90m${padded}\x1b[0m  \x1b[90mdisabled\x1b[0m`;
+    }
+    if (reachable) {
+        return `  \x1b[90m${padded}\x1b[0m  \x1b[32m200 OK\x1b[0m`;
+    }
+    if (configured) {
+        return `  \x1b[90m${padded}\x1b[0m  \x1b[33moffline\x1b[0m`;
+    }
+    return `  \x1b[90m${padded}\x1b[0m  \x1b[90mnot configured\x1b[0m`;
+}
+function clearRuntimeIndicators() {
+    if (global.auvryntStartInterval) {
+        clearInterval(global.auvryntStartInterval);
+        delete global.auvryntStartInterval;
+    }
+    if (global.auvryntTunnelCheckInterval) {
+        clearInterval(global.auvryntTunnelCheckInterval);
+        delete global.auvryntTunnelCheckInterval;
+    }
+    delete global.auvryntLogEmitter;
+}

package/dist/cli/instance-control.js

@@ -0,0 +1,21 @@
+import { retryControlRequest } from "../control-retry.js";
+import { INTEGRATION_KEYS, } from "../background-lifecycle.js";
+import { httpUrl, localProbeHost } from "./runtime-support.js";
+export function integrationsForProfiles(profiles) {
+    const enabled = new Set(profiles);
+    return Object.fromEntries(INTEGRATION_KEYS.map((key) => [key, enabled.has(key)]));
+}
+export async function postInstanceControl(active, path, body) {
+    if (!active.record.controlToken) {
+        throw new Error("The running Auvrynt instance predates live management. Run `auvrynt stop`, then start it again.");
+    }
+    return retryControlRequest(() => fetch(httpUrl(localProbeHost(active.record.host), active.record.port, path), {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${active.record.controlToken}`,
+            ...(body === undefined ? {} : { "content-type": "application/json" }),
+        },
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: AbortSignal.timeout(10_000),
+    }), { maxAttempts: 20, maxDelayMs: 2_000 });
+}