auvrynt 1.0.1

package/dist/cli.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { stdin as input, stdout as output } from "node:process";
+import { resolve } from "node:path";
+import * as prompts from "@clack/prompts";
+import { getShellConfig } from "@earendil-works/pi-coding-agent";
+import { satisfies } from "semver";
+import { loadConfig } from "./config.js";
+import { generateOwnerToken, loadAuvryntFiles, writeAuvryntAuth, writeAuvryntConfig, } from "./user-config.js";
+import { expandHomePath } from "./roots.js";
+const require = createRequire(import.meta.url);
+const SUPPORTED_NODE_RANGE = ">=20.12 <27";
+async function main(argv) {
+    assertSupportedNode();
+    const [rawCommand, ...args] = argv;
+    const command = normalizeCommand(rawCommand);
+    switch (command) {
+        case "serve":
+            await ensureConfigured();
+            if (rawCommand === "start") {
+                process.env.AUVRYNT_START_MODE = "true";
+            }
+            await serve();
+            return;
+        case "init":
+            await runInit({ force: args.includes("--force") });
+            return;
+        case "doctor":
+            await runDoctor();
+            return;
+        case "config":
+            runConfigCommand(args);
+            return;
+        case "help":
+            printHelp();
+            return;
+    }
+}
+function normalizeCommand(command) {
+    if (!command || command === "serve" || command === "start")
+        return "serve";
+    if (command === "init" || command === "doctor" || command === "config")
+        return command;
+    if (command === "help" || command === "--help" || command === "-h")
+        return "help";
+    throw new Error(`Unknown command: ${command}`);
+}
+async function ensureConfigured() {
+    const files = loadAuvryntFiles();
+    if (files.configExists && files.authExists)
+        return;
+    if (process.env.AUVRYNT_OAUTH_OWNER_TOKEN)
+        return;
+    if (!input.isTTY || !output.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 runInit({ force: false });
+}
+async function runInit({ 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 portAnswer = await textPrompt({
+            message: `Which local port should Auvrynt use? Press Enter to use ${defaultPort}`,
+            placeholder: defaultPort,
+            defaultValue: defaultPort,
+            validate: validatePort,
+        });
+        const port = Number(portAnswer);
+        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,
+        }));
+        const config = {
+            host: files.config.host ?? "127.0.0.1",
+            port,
+            allowedRoots,
+            publicBaseUrl,
+        };
+        const auth = {
+            ownerToken: files.auth.ownerToken ?? generateOwnerToken(),
+        };
+        const configPath = writeAuvryntConfig(config);
+        const authPath = writeAuvryntAuth(auth);
+        const lines = [
+            `Config: ${configPath}`,
+            `Auth: ${authPath}`,
+            `Local MCP URL: http://${config.host}:${config.port}/mcp`,
+            ...(publicBaseUrl ? [`Public MCP URL: ${publicBaseUrl}/mcp`] : []),
+        ];
+        prompts.note(lines.join("\n"), "Auvrynt configured");
+        prompts.note([
+            `Owner password: ${auth.ownerToken}`,
+            "Use this when ChatGPT or Claude asks you to approve Auvrynt access.",
+            `Stored at: ${authPath}`,
+        ].join("\n"), "Owner password");
+        prompts.outro("Run `auvrynt serve` to start the MCP server.");
+    }
+    catch (error) {
+        if (error instanceof SetupCancelledError) {
+            prompts.cancel("Setup cancelled");
+            return;
+        }
+        throw error;
+    }
+}
+async function serve() {
+    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 { app } = createServer(config);
+    const startMode = process.env.AUVRYNT_START_MODE === "true";
+    const files = loadAuvryntFiles();
+    const ownerToken = files.auth.ownerToken || "not_configured";
+    const publicMcpUrl = config.publicBaseUrl
+        ? `${config.publicBaseUrl.replace(/\/$/, "")}/mcp`
+        : `http://${config.host}:${config.port}/mcp`;
+    const httpServer = app.listen(config.port, config.host, () => {
+        if (startMode) {
+            console.clear();
+            console.log("Auvrynt is running!");
+            console.log("");
+            console.log(`  Public URL:     \x1b[36m${publicMcpUrl}\x1b[0m`);
+            console.log(`  Owner Password: \x1b[33m${ownerToken}\x1b[0m`);
+            console.log("");
+            console.log("  # CTRL + C to stop");
+            console.log("");
+            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;
+        }
+        else {
+            console.log(`auvrynt listening on http://${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 password approval required");
+            console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+        }
+    });
+    const shutdown = () => {
+        if (global.auvryntStartInterval) {
+            clearInterval(global.auvryntStartInterval);
+        }
+        httpServer.close(() => process.exit(0));
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+async function runDoctor() {
+    const files = loadAuvryntFiles();
+    console.log(`Config dir: ${files.dir}`);
+    console.log(`Config file: ${files.configExists ? files.configPath : "missing"}`);
+    console.log(`Auth file: ${files.authExists ? files.authPath : "missing"}`);
+    console.log(`Node: ${process.version} (${nodeVersionStatus()})`);
+    console.log(`Node ABI: ${process.versions.modules}`);
+    console.log(`Platform: ${process.platform} ${process.arch}`);
+    console.log(`Git: ${checkGitAvailable()}`);
+    console.log(`Bash shell: ${checkBashShell()}`);
+    console.log(`SQLite native dependency: ${checkSqliteNative()}`);
+    try {
+        const config = loadConfig();
+        console.log(`Local MCP URL: http://${config.host}:${config.port}/mcp`);
+        console.log(`Public MCP URL: ${new URL("/mcp", config.publicBaseUrl).toString()}`);
+        console.log(`Allowed roots: ${config.allowedRoots.join(", ")}`);
+        console.log(`Allowed hosts: ${config.allowedHosts.join(", ")}`);
+    }
+    catch (error) {
+        console.log(`Config status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function runConfigCommand(args) {
+    const [subcommand, key, ...rest] = args;
+    const files = loadAuvryntFiles();
+    if (!subcommand || subcommand === "get") {
+        console.log(JSON.stringify(files.config, null, 2));
+        return;
+    }
+    if (subcommand !== "set") {
+        throw new Error(`Unknown config command: ${subcommand}`);
+    }
+    if (key !== "publicBaseUrl") {
+        throw new Error("Only `auvrynt config set publicBaseUrl <url|null>` is supported right now.");
+    }
+    const value = rest.join(" ").trim();
+    if (!value) {
+        throw new Error("Missing publicBaseUrl value.");
+    }
+    writeAuvryntConfig({
+        ...files.config,
+        publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
+    });
+    console.log(`Updated ${files.configPath}`);
+}
+function printHelp() {
+    console.log([
+        "Auvrynt",
+        "",
+        "Usage:",
+        "  auvrynt                 Run first-time setup if needed, then start the server",
+        "  auvrynt start           Start the server with an animated logs indicator (clean UI)",
+        "  auvrynt serve           Start the server with verbose console logs",
+        "  auvrynt init            Create or update ~/.auvrynt/config.json and auth.json",
+        "  auvrynt doctor          Show config, runtime, and native dependency status",
+        "  auvrynt config get      Print persisted config",
+        "  auvrynt config set publicBaseUrl <url|null>",
+        "",
+        "For temporary tunnels:",
+        "  AUVRYNT_PUBLIC_BASE_URL=https://example.trycloudflare.com auvrynt serve",
+    ].join("\n"));
+}
+function normalizeOptionalPublicBaseUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "null" || trimmed === "none")
+        return null;
+    return normalizePublicBaseUrl(trimmed);
+}
+function normalizePublicBaseUrl(value) {
+    const trimmed = value.trim();
+    const parsed = new URL(trimmed);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+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 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 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 assertSupportedNode() {
+    if (satisfies(process.versions.node, SUPPORTED_NODE_RANGE))
+        return;
+    throw new Error([
+        `Auvrynt requires Node ${SUPPORTED_NODE_RANGE}.`,
+        `Current Node: ${process.version}`,
+        "",
+        "Install Node 22 LTS or use a version manager such as nvm, fnm, or mise.",
+    ].join("\n"));
+}
+function nodeVersionStatus() {
+    return satisfies(process.versions.node, SUPPORTED_NODE_RANGE)
+        ? `supported ${SUPPORTED_NODE_RANGE}`
+        : `unsupported, requires ${SUPPORTED_NODE_RANGE}`;
+}
+class SetupCancelledError extends Error {
+}
+function checkSqliteNative() {
+    try {
+        const Database = require("better-sqlite3");
+        const db = new Database(":memory:");
+        db.close();
+        return "ok";
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+function checkGitAvailable() {
+    try {
+        const { execFileSync } = require("node:child_process");
+        return execFileSync("git", ["--version"], { encoding: "utf8" }).trim();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}
+function checkBashShell() {
+    try {
+        const { shell, args } = getShellConfig();
+        return `${shell} ${args.join(" ")}`;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}
+main(process.argv.slice(2)).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/config.js

@@ -0,0 +1,211 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { expandHomePath } from "./roots.js";
+import { loadAuvryntFiles } from "./user-config.js";
+const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
+const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
+function parsePort(value) {
+    if (value === undefined || value === "")
+        return 49321;
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid PORT: ${value}`);
+    }
+    return port;
+}
+function parseAllowedRoots(value) {
+    if (Array.isArray(value)) {
+        const roots = value.map((entry) => entry.trim()).filter(Boolean);
+        return (roots.length > 0 ? roots : [process.cwd()]).map((root) => resolve(expandHomePath(root)));
+    }
+    const rawRoots = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? [];
+    const roots = rawRoots.length > 0 ? rawRoots : [process.cwd()];
+    return roots.map((root) => resolve(expandHomePath(root)));
+}
+function parseAllowedHosts(value, derivedHosts) {
+    if (Array.isArray(value)) {
+        return normalizeAllowedHosts(value, derivedHosts);
+    }
+    const rawHosts = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean) ?? [];
+    return normalizeAllowedHosts(rawHosts, derivedHosts);
+}
+function normalizeAllowedHosts(rawHosts, derivedHosts) {
+    const hosts = rawHosts.length > 0 ? rawHosts : derivedHosts;
+    if (hosts.includes("*"))
+        return ["*"];
+    return Array.from(new Set(hosts.map((host) => host.trim()).filter(Boolean)));
+}
+function parseBoolean(value) {
+    return ["1", "true", "yes", "on"].includes(value?.toLowerCase() ?? "");
+}
+function parseMinimalTools(env) {
+    if (env.AUVRYNT_TOOL_MODE === "minimal")
+        return true;
+    if (env.AUVRYNT_TOOL_MODE === "full")
+        return false;
+    if (env.AUVRYNT_TOOL_MODE) {
+        throw new Error(`Invalid AUVRYNT_TOOL_MODE: ${env.AUVRYNT_TOOL_MODE}`);
+    }
+    if (env.AUVRYNT_MINIMAL_TOOLS !== undefined)
+        return parseBoolean(env.AUVRYNT_MINIMAL_TOOLS);
+    return true;
+}
+function parseLogLevel(value) {
+    if (!value || value === "info")
+        return "info";
+    if (["silent", "error", "warn", "debug"].includes(value))
+        return value;
+    throw new Error(`Invalid AUVRYNT_LOG_LEVEL: ${value}`);
+}
+function parseLogFormat(value) {
+    if (!value || value === "json")
+        return "json";
+    if (value === "pretty")
+        return "pretty";
+    throw new Error(`Invalid AUVRYNT_LOG_FORMAT: ${value}`);
+}
+function parsePathList(value) {
+    return (value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => resolve(expandHomePath(entry))) ?? []);
+}
+function parseStringList(value, fallback) {
+    const entries = value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    return entries && entries.length > 0 ? entries : fallback;
+}
+function parsePositiveInteger(value, fallback, name) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1) {
+        throw new Error(`Invalid ${name}: ${value}`);
+    }
+    return parsed;
+}
+function parseToolNaming(value) {
+    if (!value || value === "short")
+        return "short";
+    if (value === "legacy")
+        return "legacy";
+    throw new Error(`Invalid AUVRYNT_TOOL_NAMING: ${value}`);
+}
+function parseLoggingConfig(env) {
+    return {
+        level: parseLogLevel(env.AUVRYNT_LOG_LEVEL),
+        format: parseLogFormat(env.AUVRYNT_LOG_FORMAT),
+        requests: env.AUVRYNT_LOG_REQUESTS === undefined ? true : parseBoolean(env.AUVRYNT_LOG_REQUESTS),
+        assets: parseBoolean(env.AUVRYNT_LOG_ASSETS),
+        toolCalls: env.AUVRYNT_LOG_TOOL_CALLS === undefined ? true : parseBoolean(env.AUVRYNT_LOG_TOOL_CALLS),
+        shellCommands: parseBoolean(env.AUVRYNT_LOG_SHELL_COMMANDS),
+        trustProxy: parseBoolean(env.AUVRYNT_TRUST_PROXY),
+    };
+}
+function parseWidgetMode(value) {
+    if (!value || value === "full")
+        return "full";
+    if (value === "off" || value === "changes")
+        return value;
+    throw new Error(`Invalid AUVRYNT_WIDGETS: ${value}`);
+}
+function parseRequiredSecret(value, name) {
+    const secret = value?.trim();
+    if (!secret) {
+        throw new Error(`${name} is required for Auvrynt OAuth. Run: auvrynt init`);
+    }
+    if (secret.length < 16) {
+        throw new Error(`${name} must be at least 16 characters long.`);
+    }
+    return secret;
+}
+function parseOAuthConfig(env, ownerToken) {
+    return {
+        ownerToken: parseRequiredSecret(env.AUVRYNT_OAUTH_OWNER_TOKEN ?? ownerToken, "AUVRYNT_OAUTH_OWNER_TOKEN"),
+        accessTokenTtlSeconds: parsePositiveInteger(env.AUVRYNT_OAUTH_ACCESS_TOKEN_TTL_SECONDS, DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS, "AUVRYNT_OAUTH_ACCESS_TOKEN_TTL_SECONDS"),
+        refreshTokenTtlSeconds: parsePositiveInteger(env.AUVRYNT_OAUTH_REFRESH_TOKEN_TTL_SECONDS, DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS, "AUVRYNT_OAUTH_REFRESH_TOKEN_TTL_SECONDS"),
+        scopes: parseStringList(env.AUVRYNT_OAUTH_SCOPES, ["auvrynt"]),
+        allowedRedirectHosts: parseStringList(env.AUVRYNT_OAUTH_ALLOWED_REDIRECT_HOSTS, [
+            "chatgpt.com",
+            "localhost",
+            "127.0.0.1",
+        ]),
+    };
+}
+function defaultStateDir() {
+    return join(homedir(), ".local", "share", "auvrynt");
+}
+function defaultWorktreeRoot() {
+    return join(homedir(), ".auvrynt", "worktrees");
+}
+function defaultAgentDir() {
+    return join(homedir(), ".codex");
+}
+function parseSerenaConfig(env, filesConfig) {
+    const filesSerena = filesConfig.serena ?? {};
+    return {
+        enabled: parseBoolean(env.AUVRYNT_SERENA_ENABLED ?? filesSerena.enabled),
+        executable: env.AUVRYNT_SERENA_EXECUTABLE ?? filesSerena.executable ?? "serena",
+        backend: (env.AUVRYNT_SERENA_BACKEND ?? filesSerena.backend ?? "LSP"),
+        context: env.AUVRYNT_SERENA_CONTEXT ?? filesSerena.context ?? "desktop-app",
+        startupTimeoutMs: parsePositiveInteger(env.AUVRYNT_SERENA_STARTUP_TIMEOUT ?? filesSerena.startupTimeoutMs, 30_000, "AUVRYNT_SERENA_STARTUP_TIMEOUT"),
+        requestTimeoutMs: parsePositiveInteger(env.AUVRYNT_SERENA_REQUEST_TIMEOUT ?? filesSerena.requestTimeoutMs, 60_000, "AUVRYNT_SERENA_REQUEST_TIMEOUT"),
+        idleTimeoutMinutes: parsePositiveInteger(env.AUVRYNT_SERENA_IDLE_TIMEOUT ?? filesSerena.idleTimeoutMinutes, 30, "AUVRYNT_SERENA_IDLE_TIMEOUT"),
+        maxInstances: parsePositiveInteger(env.AUVRYNT_SERENA_MAX_INSTANCES ?? filesSerena.maxInstances, 3, "AUVRYNT_SERENA_MAX_INSTANCES"),
+    };
+}
+export function loadConfig(env = process.env) {
+    const files = loadAuvryntFiles(env);
+    const host = env.HOST ?? files.config.host ?? "127.0.0.1";
+    const port = parsePort(env.PORT ?? files.config.port);
+    const publicBaseUrl = parsePublicBaseUrl(env.AUVRYNT_PUBLIC_BASE_URL ?? files.config.publicBaseUrl ?? localPublicBaseUrl(host, port));
+    const derivedAllowedHosts = [
+        "localhost",
+        "127.0.0.1",
+        "::1",
+        host,
+        new URL(publicBaseUrl).hostname,
+        ...(files.config.allowedHosts ?? []),
+    ];
+    return {
+        host,
+        port,
+        oauth: parseOAuthConfig(env, files.auth.ownerToken),
+        allowedRoots: parseAllowedRoots(env.AUVRYNT_ALLOWED_ROOTS ?? files.config.allowedRoots),
+        allowedHosts: parseAllowedHosts(env.AUVRYNT_ALLOWED_HOSTS, derivedAllowedHosts),
+        publicBaseUrl,
+        minimalTools: parseMinimalTools(env),
+        toolNaming: parseToolNaming(env.AUVRYNT_TOOL_NAMING),
+        widgets: parseWidgetMode(env.AUVRYNT_WIDGETS),
+        stateDir: resolve(expandHomePath(env.AUVRYNT_STATE_DIR ?? files.config.stateDir ?? defaultStateDir())),
+        worktreeRoot: resolve(expandHomePath(env.AUVRYNT_WORKTREE_ROOT ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
+        skillsEnabled: env.AUVRYNT_SKILLS === undefined ? true : parseBoolean(env.AUVRYNT_SKILLS),
+        skillPaths: parsePathList(env.AUVRYNT_SKILL_PATHS),
+        agentDir: resolve(expandHomePath(env.AUVRYNT_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
+        logging: parseLoggingConfig(env),
+        serena: parseSerenaConfig(env, files.config),
+    };
+}
+function parsePublicBaseUrl(value) {
+    const parsed = new URL(value);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+function localPublicBaseUrl(host, port) {
+    const publicHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+    const formattedHost = publicHost.includes(":") && !publicHost.startsWith("[")
+        ? `[${publicHost}]`
+        : publicHost;
+    return `http://${formattedHost}:${port}`;
+}

package/dist/connection-status.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+import { getBlenderClient } from "./blender-client.js";
+import { godotEditorStatus } from "./godot-editor-bridge.js";
+const require = createRequire(import.meta.url);
+function checkedAt() {
+    return new Date().toISOString();
+}
+function browserStatus() {
+    const timestamp = checkedAt();
+    for (const packageName of ["playwright", "playwright-core"]) {
+        try {
+            require.resolve(packageName);
+            return {
+                state: "available",
+                provider: "Playwright",
+                detail: "Browser support is installed and will connect on demand per request.",
+                checkedAt: timestamp,
+            };
+        }
+        catch { }
+    }
+    return {
+        state: "unavailable",
+        provider: "Playwright",
+        detail: "Install Playwright to enable browser inspection and screenshots.",
+        checkedAt: timestamp,
+    };
+}
+export async function getConnectionStatus(registry, processManager, workspaceId) {
+    const workspace = registry.getWorkspace(workspaceId);
+    const timestamp = checkedAt();
+    const blender = {
+        state: "disconnected",
+        provider: "Auvrynt Blender bridge",
+        endpoint: "127.0.0.1:49323",
+        detail: "No response from the local Blender bridge.",
+        checkedAt: timestamp,
+    };
+    try {
+        const response = await getBlenderClient(workspaceId).sendExecute("import bpy\nresult = {'version': bpy.app.version_string, 'scene': bpy.context.scene.name}\n");
+        blender.state = "connected";
+        blender.detail = "Blender bridge responded.";
+        blender.metadata = response;
+    }
+    catch (error) {
+        blender.detail = error instanceof Error ? error.message : String(error);
+    }
+    let godot;
+    try {
+        const response = await godotEditorStatus({ workspaceId });
+        godot = {
+            state: response.connected ? "connected" : "disconnected",
+            provider: "Auvrynt Godot editor bridge",
+            endpoint: "127.0.0.1:49322",
+            detail: response.connected ? "Godot editor bridge responded." : "Godot editor bridge is not connected.",
+            checkedAt: timestamp,
+            metadata: response.connected ? response : undefined,
+        };
+    }
+    catch (error) {
+        godot = {
+            state: "error",
+            provider: "Auvrynt Godot editor bridge",
+            endpoint: "127.0.0.1:49322",
+            detail: error instanceof Error ? error.message : String(error),
+            checkedAt: timestamp,
+        };
+    }
+    return {
+        checkedAt: timestamp,
+        workspace: { id: workspace.id, root: workspace.root, mode: workspace.mode },
+        connections: {
+            mcp: {
+                state: "connected",
+                provider: "Auvrynt MCP server",
+                detail: "This status request was received through the authenticated MCP connection.",
+                checkedAt: timestamp,
+            },
+            blender,
+            godot,
+            browser: browserStatus(),
+            chrome_mcp: {
+                state: "not_configured",
+                provider: "Chrome MCP",
+                detail: "No Chrome MCP adapter is registered in this Auvrynt build.",
+                checkedAt: timestamp,
+            },
+        },
+        processes: processManager.listProcesses({ workspaceId }),
+    };
+}

package/dist/db/client.js

@@ -0,0 +1,22 @@
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import * as schema from "./schema.js";
+export function databasePath(stateDir) {
+    return join(stateDir, "auvrynt.sqlite");
+}
+export function openDatabase(stateDir) {
+    mkdirSync(stateDir, { recursive: true });
+    const sqlite = new Database(databasePath(stateDir));
+    sqlite.pragma("journal_mode = WAL");
+    sqlite.pragma("foreign_keys = ON");
+    return {
+        sqlite,
+        db: createDrizzleDatabase(sqlite),
+        close: () => sqlite.close(),
+    };
+}
+function createDrizzleDatabase(sqlite) {
+    return drizzle(sqlite, { schema });
+}