auvrynt 1.0.2 → 1.0.5

package/dist/browser-stability.js

@@ -0,0 +1 @@
+export * from "./integrations/playwright/browser-stability.js";

package/dist/cli/commands/help-command.js

@@ -0,0 +1,10 @@
+import { AUVRYNT_COMMANDS } from "../../infrastructure/command-reference.js";
+export function printHelp() {
+    const commandWidth = AUVRYNT_COMMANDS.reduce((width, item) => Math.max(width, item.command.length), 0);
+    console.log([
+        "Auvrynt",
+        "",
+        "Usage:",
+        ...AUVRYNT_COMMANDS.map((item) => `  ${item.command.padEnd(commandWidth)}  ${item.description}`),
+    ].join("\n"));
+}

package/dist/cli/commands/init-command.js

@@ -0,0 +1,190 @@
+import * as prompts from "@clack/prompts";
+import { resolve } from "node:path";
+import { stdin, stdout } from "node:process";
+import { expandHomePath } from "../../roots.js";
+import { generateOwnerToken, loadAuvryntFiles, writeAuvryntAuth, writeAuvryntConfig, } from "../../user-config.js";
+import { httpUrl } from "../runtime-support.js";
+import { isCloudflaredProcessRunning, findCloudflaredExecutable, spawnUserCloudflaredProcess } from "../../tunnels/cloudflared-service.js";
+class SetupCancelledError extends Error {
+}
+async function textPrompt(options) {
+    const result = await prompts.text({
+        ...options,
+        validate: (value) => options.validate?.(value?.trim() ? value : options.defaultValue),
+    });
+    if (prompts.isCancel(result))
+        throw new SetupCancelledError();
+    const value = String(result).trim();
+    return value || options.defaultValue;
+}
+function validatePort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 1 && port <= 65535
+        ? undefined
+        : "Enter a port between 1 and 65535.";
+}
+function validatePublicBaseUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:"
+            ? undefined
+            : "Use an http or https URL.";
+    }
+    catch {
+        return "Enter a valid URL, for example https://your-tunnel-host.example.com.";
+    }
+}
+function validateRequiredPublicBaseUrl(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return "Enter the public URL from your tunnel or reverse proxy.";
+    if (trimmed.endsWith("/mcp"))
+        return "Enter the base URL only, without /mcp.";
+    return validatePublicBaseUrl(trimmed);
+}
+function normalizePublicBaseUrl(value) {
+    const parsed = new URL(value.trim());
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+async function probeCustomUrl(url) {
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000);
+        const res = await fetch(`${url}/healthz`, { signal: controller.signal });
+        clearTimeout(timeout);
+        return res.ok || res.status === 404 || res.status === 401;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureConfigured(options = {}) {
+    const files = loadAuvryntFiles();
+    if (files.configExists && files.authExists)
+        return;
+    if (process.env.AUVRYNT_OAUTH_OWNER_TOKEN)
+        return;
+    if (options.directoryScoped) {
+        const launchRoot = resolve(process.cwd());
+        if (!files.configExists) {
+            writeAuvryntConfig({
+                host: files.config.host ?? "127.0.0.1",
+                port: files.config.port ?? 49321,
+                allowedRoots: [launchRoot],
+                publicBaseUrl: files.config.publicBaseUrl ?? `http://127.0.0.1:${files.config.port ?? 49321}`,
+            });
+        }
+        if (!files.authExists)
+            writeAuvryntAuth({ ownerToken: generateOwnerToken() });
+        return;
+    }
+    if (!stdin.isTTY || !stdout.isTTY) {
+        throw new Error([
+            "Auvrynt is not configured and this terminal is non-interactive.",
+            "",
+            "Run:",
+            "  auvrynt init",
+            "",
+            "Or provide AUVRYNT_OAUTH_OWNER_TOKEN and AUVRYNT_ALLOWED_ROOTS.",
+        ].join("\n"));
+    }
+    await runInitCommand({ force: false });
+}
+export async function runInitCommand({ force }) {
+    const files = loadAuvryntFiles();
+    if (!force && files.configExists && files.authExists) {
+        prompts.log.info(`Auvrynt is already configured at ${files.dir}`);
+        prompts.log.info("Run `auvrynt init --force` to update it.");
+        return;
+    }
+    try {
+        prompts.intro("Auvrynt setup");
+        const defaultRoots = files.config.allowedRoots?.join(", ") || process.cwd();
+        const rootsAnswer = await textPrompt({
+            message: `Where are your projects located? Press Enter to use ${defaultRoots}`,
+            placeholder: defaultRoots,
+            defaultValue: defaultRoots,
+            validate: (value) => value?.trim() ? undefined : "Enter at least one project root.",
+        });
+        const allowedRoots = rootsAnswer.split(",")
+            .map((root) => resolve(expandHomePath(root.trim())))
+            .filter(Boolean);
+        const defaultPort = String(files.config.port ?? 49321);
+        const port = Number(await textPrompt({
+            message: `Which local port should Auvrynt use? Press Enter to use ${defaultPort}`,
+            placeholder: defaultPort,
+            defaultValue: defaultPort,
+            validate: validatePort,
+        }));
+        prompts.note([
+            "Auvrynt needs a public base URL so ChatGPT or Claude can reach this MCP server.",
+            "Create a tunnel or reverse proxy with Cloudflare Tunnel, ngrok, Pinggy, Tailscale Funnel, or your own HTTPS proxy.",
+            "Paste the public origin here, without /mcp.",
+            "",
+            "Example: https://your-tunnel-host.example.com",
+        ].join("\n"), "Public URL required");
+        const publicBaseUrl = normalizePublicBaseUrl(await textPrompt({
+            message: files.config.publicBaseUrl
+                ? `What is the public base URL? Press Enter to keep ${files.config.publicBaseUrl}`
+                : "What is the public base URL?",
+            placeholder: files.config.publicBaseUrl ?? "https://your-tunnel-host.example.com",
+            defaultValue: files.config.publicBaseUrl ?? "",
+            validate: validateRequiredPublicBaseUrl,
+        }));
+        let cloudflareTunnelToken = files.auth.cloudflareTunnelToken;
+        const tokenAnswer = await textPrompt({
+            message: "Cloudflare Named Tunnel token (optional; press Enter to skip if managed externally)",
+            placeholder: "paste token or press Enter to skip",
+            defaultValue: cloudflareTunnelToken ?? "",
+        });
+        if (tokenAnswer)
+            cloudflareTunnelToken = tokenAnswer;
+        const s = prompts.spinner();
+        s.start("Checking tunnel and public URL connectivity...");
+        if (cloudflareTunnelToken && !isCloudflaredProcessRunning() && findCloudflaredExecutable()) {
+            spawnUserCloudflaredProcess(cloudflareTunnelToken);
+        }
+        const isReachable = await probeCustomUrl(publicBaseUrl);
+        if (isReachable) {
+            s.stop("✓ Public URL is reachable and responding.");
+        }
+        else {
+            s.stop("ℹ Public URL not reachable yet. Auvrynt will auto-connect when the tunnel starts.");
+        }
+        const config = {
+            host: files.config.host ?? "127.0.0.1",
+            port,
+            allowedRoots,
+            publicBaseUrl,
+            tunnelProvider: "custom",
+        };
+        const auth = {
+            ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
+            ...(cloudflareTunnelToken ? { cloudflareTunnelToken } : {}),
+        };
+        const configPath = writeAuvryntConfig(config);
+        const authPath = writeAuvryntAuth(auth);
+        prompts.note([
+            `Config: ${configPath}`,
+            `Auth: ${authPath}`,
+            `Local MCP URL: ${httpUrl(config.host ?? "127.0.0.1", config.port ?? 49321, "/mcp")}`,
+            `Public MCP URL: ${publicBaseUrl}/mcp`,
+        ].join("\n"), "Auvrynt configured");
+        prompts.note([
+            `Owner token: ${auth.ownerToken}`,
+            "Use this when ChatGPT or Claude asks you to approve Auvrynt access.",
+            `Stored at: ${authPath}`,
+        ].join("\n"), "Owner token");
+        prompts.outro("Run `auvrynt start` to start the MCP server.");
+    }
+    catch (error) {
+        if (error instanceof SetupCancelledError) {
+            prompts.cancel("Setup cancelled");
+            return;
+        }
+        throw error;
+    }
+}

package/dist/cli/commands/integration-commands.js

@@ -0,0 +1,88 @@
+import * as prompts from "@clack/prompts";
+import { INTEGRATION_KEYS, INTEGRATION_LABELS } from "../../background-lifecycle.js";
+import { loadAuvryntFiles, writeAuvryntConfig, } from "../../user-config.js";
+export function completeIntegrationsConfig(config) {
+    return {
+        godotGdscript: config?.godotGdscript ?? false,
+        godotCsharp: config?.godotCsharp ?? false,
+        blender: config?.blender ?? false,
+        aseprite: config?.aseprite ?? false,
+        serena: config?.serena ?? false,
+        playwright: config?.playwright ?? false,
+        context7: config?.context7 ?? false,
+        obsidian: config?.obsidian ?? false,
+        roblox: config?.roblox ?? false,
+    };
+}
+function writeIntegrationConfig(integrations) {
+    const files = loadAuvryntFiles();
+    writeAuvryntConfig({ ...files.config, integrations });
+}
+export async function ensureIntegrationChoicesConfigured() {
+    const files = loadAuvryntFiles();
+    if (files.config.integrations)
+        return;
+    prompts.intro("  Auvrynt integrations  ");
+    const integrations = completeIntegrationsConfig(undefined);
+    for (const key of INTEGRATION_KEYS) {
+        const answer = await prompts.confirm({
+            message: `Enable ${INTEGRATION_LABELS[key]}?`,
+            initialValue: false,
+        });
+        if (prompts.isCancel(answer)) {
+            prompts.cancel("Integration setup cancelled.");
+            process.exit(1);
+        }
+        integrations[key] = Boolean(answer);
+    }
+    writeAuvryntConfig({ ...files.config, integrations });
+    prompts.outro("Saved integration choices. Change them later with `auvrynt enable` or `auvrynt disable`.");
+}
+async function runToggleCommand(enable) {
+    const files = loadAuvryntFiles();
+    const integrations = completeIntegrationsConfig(files.config.integrations);
+    const verb = enable ? "Enable" : "Disable";
+    prompts.intro(`  ${verb} Auvrynt integrations  `);
+    while (true) {
+        prompts.note([
+            "0. Done",
+            ...INTEGRATION_KEYS.map((key, index) => `${index + 1}. ${INTEGRATION_LABELS[key]}  ${integrations[key] ? "[enabled]" : "[disabled]"}`),
+        ].join("\n"), "Integrations");
+        const picked = await prompts.text({
+            message: `Type numbers to ${enable ? "enable" : "disable"}, or 0 when finished`,
+            placeholder: "1 3 5 or 0",
+            validate: (value) => {
+                const raw = String(value ?? "").trim();
+                if (!raw)
+                    return "Enter one or more numbers, or 0.";
+                const values = raw.split(/[\s,]+/).map(Number);
+                if (values.includes(0))
+                    return values.length === 1 ? undefined : "Use 0 by itself when finished.";
+                if (values.some((value) => !Number.isInteger(value) || value < 1 || value > INTEGRATION_KEYS.length)) {
+                    return `Use 0 or numbers from 1 to ${INTEGRATION_KEYS.length}.`;
+                }
+                const alreadyDesired = values.every((value) => integrations[INTEGRATION_KEYS[value - 1]] === enable);
+                if (alreadyDesired)
+                    return `Choose at least one ${enable ? "disabled" : "enabled"} integration, or type 0.`;
+                return undefined;
+            },
+        });
+        if (prompts.isCancel(picked)) {
+            prompts.cancel(`${verb} cancelled.`);
+            return;
+        }
+        const values = String(picked).trim().split(/[\s,]+/).map(Number);
+        if (values[0] === 0)
+            break;
+        for (const value of new Set(values))
+            integrations[INTEGRATION_KEYS[value - 1]] = enable;
+        writeIntegrationConfig(integrations);
+    }
+    prompts.outro("Integration settings updated. Restart any running Auvrynt server for the change to take effect.");
+}
+export function runEnableCommand() {
+    return runToggleCommand(true);
+}
+export function runDisableCommand() {
+    return runToggleCommand(false);
+}

package/dist/cli/commands/serve-command.js

@@ -0,0 +1,83 @@
+import { resolve } from "node:path";
+import { loadConfig } from "../../config.js";
+import { parseStartRequest } from "../../background-lifecycle.js";
+import { startTunnel } from "../../tunnels/tunnel-manager.js";
+import { applyIntegrationProfile, } from "../lifecycle-manager.js";
+import { selfHealStartIntegrations } from "../integration-bootstrap.js";
+import { acquireInstanceLock } from "../instance-lock.js";
+import { serveForegroundServer } from "../foreground-server.js";
+import { ensureConfigured } from "./init-command.js";
+export async function runServeCommand(rawCommand, args, lifecycle) {
+    const startRequest = rawCommand === "start" ? parseStartRequest(args) : undefined;
+    if (startRequest && !startRequest.backgroundChild) {
+        const launchRoot = setDirectoryScopedRoot();
+        await ensureConfigured({ directoryScoped: true });
+        await lifecycle.start(startRequest, launchRoot);
+        return;
+    }
+    if (rawCommand === "start")
+        setDirectoryScopedRoot();
+    await ensureConfigured({ directoryScoped: rawCommand === "start" });
+    if (startRequest?.profiles)
+        applyIntegrationProfile(startRequest.profiles);
+    const localConfig = loadConfig();
+    exposeConfiguredGodotExecutables(localConfig.executables);
+    const instanceLock = await acquireInstanceLock(localConfig.stateDir, localConfig.host, localConfig.port, startRequest?.profiles, resolve(process.cwd()));
+    let tunnel;
+    let stopTunnel;
+    try {
+        if (rawCommand === "start") {
+            process.env.AUVRYNT_START_MODE = "true";
+            const launchRoot = resolve(process.cwd());
+            if (!startRequest?.backgroundChild) {
+                await selfHealStartIntegrations(launchRoot, localConfig.executables, localConfig.integrations);
+            }
+            const managedTunnelUrl = process.env.AUVRYNT_MANAGED_TUNNEL_URL;
+            if (localConfig.tunnelProvider === "custom" && (process.platform === "win32" || !localConfig.cloudflareTunnelToken)) {
+                process.env.AUVRYNT_PUBLIC_BASE_URL = localConfig.publicBaseUrl;
+            }
+            else if (managedTunnelUrl) {
+                process.env.AUVRYNT_PUBLIC_BASE_URL = managedTunnelUrl;
+            }
+            else {
+                tunnel = await startTunnel(localConfig.tunnelProvider, localConfig.port, {
+                    ngrokAuthtoken: localConfig.ngrokAuthtoken,
+                    ngrokUrl: localConfig.ngrokUrl,
+                    cloudflareTunnelToken: localConfig.cloudflareTunnelToken,
+                    publicUrl: localConfig.publicBaseUrl,
+                });
+                process.env.AUVRYNT_PUBLIC_BASE_URL = tunnel.url;
+                stopTunnel = () => {
+                    if (tunnel && !tunnel.process.killed)
+                        tunnel.process.kill();
+                };
+                process.once("SIGINT", stopTunnel);
+                process.once("SIGTERM", stopTunnel);
+            }
+        }
+        await serveForegroundServer();
+    }
+    finally {
+        if (stopTunnel) {
+            process.removeListener("SIGINT", stopTunnel);
+            process.removeListener("SIGTERM", stopTunnel);
+            stopTunnel();
+        }
+        await instanceLock.release();
+    }
+}
+function setDirectoryScopedRoot() {
+    const launchRoot = resolve(process.cwd());
+    process.env.AUVRYNT_ALLOWED_ROOTS = launchRoot;
+    process.env.AUVRYNT_WORKTREE_ROOT = launchRoot;
+    return launchRoot;
+}
+function exposeConfiguredGodotExecutables(executables) {
+    if (executables.godotCsharp
+        && !process.env.GODOT_DOTNET_EXECUTABLE) {
+        process.env.GODOT_DOTNET_EXECUTABLE = executables.godotCsharp;
+    }
+    if (executables.godot && !process.env.GODOT_EXECUTABLE) {
+        process.env.GODOT_EXECUTABLE = executables.godot;
+    }
+}

package/dist/cli/commands/setup-command.js

@@ -0,0 +1,81 @@
+import * as prompts from "@clack/prompts";
+import { ensureGlobalGodotPlugin } from "../../godot-tools.js";
+import { ensureGlobalAsepriteBridge } from "../../integrations/aseprite/aseprite-live-tools.js";
+import { loadAuvryntFiles, writeAuvryntConfig } from "../../user-config.js";
+const SETUP_TOOL_LABELS = {
+    godot: "Godot        - GDScript game engine",
+    godotCsharp: "Godot C#     - .NET / Mono Godot build",
+    asepriteSource: "Aseprite     - source/build directory",
+};
+const SETUP_TOOL_KEYS = ["godot", "godotCsharp", "asepriteSource"];
+export async function runSetupCommand(args = []) {
+    const files = loadAuvryntFiles();
+    const existingExecs = files.config.executables ?? {};
+    if (args.length >= 2) {
+        const toolKeyMap = {
+            godot: "godot",
+            godotcsharp: "godotCsharp",
+            "godot-csharp": "godotCsharp",
+            aseprite: "asepriteSource",
+            "aseprite-source": "asepriteSource",
+        };
+        const key = toolKeyMap[args[0].toLowerCase()];
+        if (key) {
+            const exePath = args.slice(1).join(" ").trim().replace(/^["']|["']$/g, "").trim();
+            writeAuvryntConfig({ ...files.config, executables: { ...existingExecs, [key]: exePath } });
+            if (key === "asepriteSource") {
+                const bridge = await ensureGlobalAsepriteBridge();
+                console.log(`Installed Aseprite live bridge: ${bridge.targetPath}`);
+            }
+            console.log(`Updated ${key} executable path: ${exePath}`);
+            return;
+        }
+    }
+    prompts.intro("  Auvrynt Setup - configure local tool integrations  ");
+    const picked = await prompts.select({
+        message: "Select integration to configure  (Enter to confirm)",
+        options: SETUP_TOOL_KEYS.map((key) => ({
+            value: key,
+            label: SETUP_TOOL_LABELS[key],
+            hint: existingExecs[key] ? `currently: ${existingExecs[key]}` : "not set",
+        })),
+    });
+    if (prompts.isCancel(picked)) {
+        prompts.cancel("Setup cancelled.");
+        return;
+    }
+    const key = picked;
+    const labelName = SETUP_TOOL_LABELS[key].split(" - ")[0].trim();
+    const placeholder = key === "godot"
+        ? "e.g. C:\\Program Files\\Godot\\Godot.exe"
+        : key === "godotCsharp"
+            ? "e.g. C:\\Program Files\\Godot_v4-mono\\Godot.exe  (.NET build)"
+            : "e.g. C:\\Users\\you\\src\\aseprite  (contains build\\bin\\aseprite.exe)";
+    const answer = await prompts.text({
+        message: `${labelName} executable path`,
+        placeholder,
+        initialValue: existingExecs[key] ?? "",
+        validate: (value) => (value ?? "").trim() ? undefined : "Path cannot be empty.",
+    });
+    if (prompts.isCancel(answer)) {
+        prompts.cancel("Setup cancelled.");
+        return;
+    }
+    const executablePath = String(answer).trim().replace(/^["']|["']$/g, "").trim();
+    writeAuvryntConfig({
+        ...files.config,
+        executables: { ...files.config.executables, [key]: executablePath },
+    });
+    if (key === "godot" || key === "godotCsharp") {
+        const pluginResult = ensureGlobalGodotPlugin();
+        if (pluginResult.installed) {
+            prompts.log.success(`Installed global Godot Editor plugin: ${pluginResult.targetPath}`);
+        }
+    }
+    else if (key === "asepriteSource") {
+        const bridge = await ensureGlobalAsepriteBridge();
+        prompts.log.success(`Installed Aseprite live bridge: ${bridge.targetPath}`);
+    }
+    prompts.note(`${labelName.padEnd(14)} -> ${executablePath}`, "Saved to ~/.auvrynt/config.json");
+    prompts.outro("Setup complete. Run `auvrynt status` to verify.");
+}

package/dist/cli/commands/status-commands.js

@@ -0,0 +1,166 @@
+import { execFileSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { getShellConfig } from "@earendil-works/pi-coding-agent";
+import { satisfies } from "semver";
+import { loadConfig } from "../../config.js";
+import { INTEGRATION_KEYS, INTEGRATION_LABELS } from "../../background-lifecycle.js";
+import { discoverLocalIntegrations, processDetected } from "../../integration-discovery.js";
+import { getGlobalGodotPluginStatus } from "../../godot-tools.js";
+import { getPlaywrightRuntimeStatus } from "../../playwright-runtime.js";
+import { readManagedTunnel } from "../../tunnels/tunnel-manager.js";
+import { loadAuvryntFiles } from "../../user-config.js";
+import { dashboardUrl, httpUrl, localProbeHost, printConsolePanel, RUNNING_COMMAND_HINTS, } from "../runtime-support.js";
+const require = createRequire(import.meta.url);
+const SUPPORTED_NODE_RANGE = ">=20.12 <27";
+export async function runDoctorCommand() {
+    const files = loadAuvryntFiles();
+    const rows = [
+        { label: "Config dir", value: files.dir },
+        { label: "Config", value: files.configExists ? files.configPath : "Missing" },
+        { label: "Auth", value: files.authExists ? files.authPath : "Missing" },
+        { label: "Node", value: `${process.version} (${nodeVersionStatus()}), ABI ${process.versions.modules}` },
+        { label: "Platform", value: `${process.platform} ${process.arch}` },
+        { label: "Git", value: checkGitAvailable() },
+        { label: "Bash", value: checkBashShell() },
+        { label: "SQLite", value: checkSqliteNative() },
+    ];
+    try {
+        const config = loadConfig();
+        rows.push({ label: "Local MCP", value: httpUrl(config.host, config.port, "/mcp") }, { label: "Public MCP", value: new URL("/mcp", config.publicBaseUrl).toString() }, { label: "Roots", value: config.allowedRoots.join(", ") }, { label: "Hosts", value: config.allowedHosts.join(", ") });
+    }
+    catch (error) {
+        rows.push({ label: "Config status", value: error instanceof Error ? error.message : String(error) });
+    }
+    printConsolePanel("Auvrynt doctor", rows);
+}
+export async function runStatusCommand(dependencies) {
+    const files = loadAuvryntFiles();
+    const config = loadConfig();
+    const host = files.config.host ?? "127.0.0.1";
+    const port = files.config.port ?? 49321;
+    const healthUrl = httpUrl(localProbeHost(host), port, "/healthz");
+    const active = await dependencies.readActiveInstance();
+    const tunnel = await readManagedTunnel({
+        stateDir: config.stateDir,
+        port,
+        provider: config.tunnelProvider,
+        ngrokAuthtoken: config.ngrokAuthtoken,
+        ngrokUrl: config.ngrokUrl,
+    });
+    const rows = [];
+    try {
+        const response = await fetch(healthUrl, { signal: AbortSignal.timeout(1500) });
+        const body = await response.json().catch(() => ({}));
+        rows.push({ label: "Local MCP", value: response.ok && body.ok ? "Connected" : "Error" });
+    }
+    catch (error) {
+        rows.push({ label: "Local MCP", value: "Disconnected" });
+        rows.push({ label: "Detail", value: error instanceof Error ? error.message : String(error) });
+    }
+    rows.push({ label: "Health", value: healthUrl });
+    rows.push({ label: "Dashboard", value: dashboardUrl(host, port) });
+    if (active) {
+        rows.push({ label: "Process", value: `PID ${active.record.pid}` });
+        rows.push({ label: "Workspace", value: active.record.launchRoot ?? "unknown" });
+    }
+    else {
+        rows.push({ label: "Process", value: "Not running" });
+    }
+    rows.push({
+        label: "Public MCP",
+        value: config.tunnelProvider === "custom"
+            ? new URL("/mcp", config.publicBaseUrl).toString()
+            : tunnel
+                ? `${tunnel.url}/mcp`
+                : "Not running",
+    });
+    const local = await discoverLocalIntegrations({ pollMs: 1500 });
+    const profileSet = new Set(active?.record.profiles ?? INTEGRATION_KEYS.filter((key) => config.integrations[key]));
+    rows.push({
+        label: "Integrations",
+        value: profileSet.size > 0 ? [...profileSet].map((key) => INTEGRATION_LABELS[key]).join(", ") : "None",
+    });
+    if (profileSet.has("blender")) {
+        const blenderConnected = local.ports.blender_lab_mcp;
+        const blenderDetail = local.ports.blender_lab_mcp
+            ? "Blender MCP connected on 9876"
+            : processDetected(local, "blender")
+                ? "Blender is running; waiting for Blender Lab MCP on 9876"
+                : "Blender is not detected";
+        rows.push({ label: "Blender", value: `${blenderConnected ? "Connected" : "Offline"} - ${blenderDetail}` });
+    }
+    if (profileSet.has("godotGdscript") || profileSet.has("godotCsharp")) {
+        const godotPlugin = getGlobalGodotPluginStatus();
+        const godotConfigured = Boolean(local.executables.godot || local.executables.godotCsharp || godotPlugin.installed);
+        const godotStatusText = local.ports.auvrynt_godot_bridge
+            ? "connected"
+            : processDetected(local, "godot")
+                ? "running, bridge unavailable"
+                : godotConfigured
+                    ? "installed, not running"
+                    : "not detected";
+        rows.push({ label: "Godot", value: godotStatusText });
+    }
+    if (profileSet.has("serena")) {
+        rows.push({
+            label: "Software",
+            value: processDetected(local, "serena") ? "Ready" : local.executables.serena ? "Installed, not running" : "Not detected",
+        });
+    }
+    if (profileSet.has("playwright")) {
+        const playwright = getPlaywrightRuntimeStatus();
+        rows.push({
+            label: "Web",
+            value: playwright.chromiumInstalled ? "Ready" : playwright.packageInstalled ? "Installed, browser unavailable" : "Not installed",
+        });
+    }
+    printConsolePanel("Auvrynt status", rows, active ? RUNNING_COMMAND_HINTS : "Start: auvrynt start");
+}
+export function assertSupportedNode() {
+    if (satisfies(process.versions.node, SUPPORTED_NODE_RANGE))
+        return;
+    throw new Error(`Auvrynt supports Node ${SUPPORTED_NODE_RANGE}. Current runtime: ${process.version}. `
+        + "Use Node 20 LTS, Node 22 LTS, Node 24 LTS, or Node 26.");
+}
+function nodeVersionStatus() {
+    return satisfies(process.versions.node, SUPPORTED_NODE_RANGE)
+        ? `supported (${SUPPORTED_NODE_RANGE})`
+        : `unsupported; expected ${SUPPORTED_NODE_RANGE}`;
+}
+export function checkSqliteNative() {
+    try {
+        const Database = require("better-sqlite3");
+        const database = new Database(":memory:");
+        try {
+            database.prepare("SELECT 1 AS ok").get();
+            return "ok";
+        }
+        finally {
+            database.close();
+        }
+    }
+    catch (error) {
+        return `Unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+function checkGitAvailable() {
+    try {
+        return execFileSync("git", ["--version"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        }).trim();
+    }
+    catch (error) {
+        return `Unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+function checkBashShell() {
+    try {
+        const shell = getShellConfig();
+        return `${shell.shell} ${shell.args.join(" ")}`;
+    }
+    catch (error) {
+        return `Unavailable: ${error instanceof Error ? error.message : String(error)}`;
+    }
+}