@zoer7788/mcp-nexus-node 0.1.5 → 0.1.7

package/cli.js

@@ -197,6 +197,7 @@ function findProject(name) {
 function devspaceCommand() {
   const explicit = process.env.DEVSPACE_CLI;
   if (explicit && existsSync(explicit)) return ["node", explicit];
+  try { return ["node", require.resolve("@zoer7788/devspace/dist/cli.js")]; } catch {}
   try { return ["node", require.resolve("@waishnav/devspace/dist/cli.js")]; } catch {}
   const bundled = join(packageDir, "vendor", "devspace", "dist", "cli.js");
   if (existsSync(bundled)) return ["node", bundled];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zoer7788/mcp-nexus-node",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Remote node for MCP Nexus pairing and DevSpace project control.",
   "license": "MIT",
   "type": "module",
@@ -9,14 +9,13 @@
   },
   "files": [
     "cli.js",
-    "README.md"
+    "README.md",
+    "vendor"
   ],
   "scripts": {
     "check": "node --check cli.js"
   },
-  "dependencies": {
-    "@waishnav/devspace": "^1.0.3"
-  },
+  "dependencies": {},
   "publishConfig": {
     "access": "public"
   }

package/vendor/devspace/dist/cli.js

@@ -0,0 +1,374 @@
+#!/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 { localDashboardUrl } from "./dashboard.js";
+import { generateOwnerToken, loadDevspaceFiles, writeDevspaceAuth, writeDevspaceConfig, } 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();
+            await serve();
+            return;
+        case "ui":
+            await ensureConfigured();
+            await serve({ openDashboard: true });
+            return;
+        case "init":
+            await runInit({ force: args.includes("--force") });
+            return;
+        case "doctor":
+            await runDoctor();
+            return;
+        case "config":
+            runConfigCommand(args);
+            return;
+        case "help":
+            printHelp();
+            return;
+        case "version":
+            printVersion();
+            return;
+    }
+}
+function normalizeCommand(command) {
+    if (!command || command === "serve" || command === "start")
+        return "serve";
+    if (command === "ui" || command === "dashboard" || command === "app")
+        return "ui";
+    if (command === "init" || command === "doctor" || command === "config")
+        return command;
+    if (command === "help" || command === "--help" || command === "-h")
+        return "help";
+    if (command === "version" || command === "--version" || command === "-v")
+        return "version";
+    throw new Error(`Unknown command: ${command}`);
+}
+async function ensureConfigured() {
+    const files = loadDevspaceFiles();
+    if (files.configExists && files.authExists)
+        return;
+    if (process.env.DEVSPACE_OAUTH_OWNER_TOKEN)
+        return;
+    if (!input.isTTY || !output.isTTY) {
+        throw new Error([
+            "DevSpace is not configured and this terminal is non-interactive.",
+            "",
+            "Run:",
+            "  devspace init",
+            "",
+            "Or provide DEVSPACE_OAUTH_OWNER_TOKEN and DEVSPACE_ALLOWED_ROOTS.",
+        ].join("\n"));
+    }
+    await runInit({ force: false });
+}
+async function runInit({ force }) {
+    const files = loadDevspaceFiles();
+    if (!force && files.configExists && files.authExists) {
+        prompts.log.info(`DevSpace is already configured at ${files.dir}`);
+        prompts.log.info("Run `devspace init --force` to update it.");
+        return;
+    }
+    try {
+        prompts.intro("DevSpace 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 ?? 7676);
+        const portAnswer = await textPrompt({
+            message: `Which local port should DevSpace use? Press Enter to use ${defaultPort}`,
+            placeholder: defaultPort,
+            defaultValue: defaultPort,
+            validate: validatePort,
+        });
+        const port = Number(portAnswer);
+        prompts.note([
+            "DevSpace 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 = writeDevspaceConfig(config);
+        const authPath = writeDevspaceAuth(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"), "DevSpace configured");
+        prompts.note([
+            `Owner password: ${auth.ownerToken}`,
+            "Use this when ChatGPT or Claude asks you to approve DevSpace access.",
+            `Stored at: ${authPath}`,
+        ].join("\n"), "Owner password");
+        prompts.outro("Run `devspace serve` to start the MCP server.");
+    }
+    catch (error) {
+        if (error instanceof SetupCancelledError) {
+            prompts.cancel("Setup cancelled");
+            return;
+        }
+        throw error;
+    }
+}
+async function serve(options = {}) {
+    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, close } = createServer(config);
+    const httpServer = app.listen(config.port, config.host, () => {
+        const dashboardUrl = localDashboardUrl(config);
+        console.log(`devspace listening on http://${config.host}:${config.port}/mcp`);
+        console.log(`dashboard: ${dashboardUrl}`);
+        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 DEVSPACE_ALLOWED_HOSTS=*");
+        }
+        console.log("auth: Owner password approval required");
+        console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+        if (options.openDashboard) {
+            void openUrl(dashboardUrl).catch((error) => {
+                console.warn(`unable to open dashboard automatically: ${error instanceof Error ? error.message : String(error)}`);
+                console.warn(`open this URL manually: ${dashboardUrl}`);
+            });
+        }
+    });
+    const shutdown = () => {
+        httpServer.close(() => {
+            close();
+            process.exit(0);
+        });
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+async function openUrl(url) {
+    const { spawn } = await import("node:child_process");
+    const command = process.platform === "darwin"
+        ? "open"
+        : process.platform === "win32"
+            ? "cmd"
+            : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    const child = spawn(command, args, { detached: true, stdio: "ignore" });
+    child.unref();
+}
+async function runDoctor() {
+    const files = loadDevspaceFiles();
+    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 = loadDevspaceFiles();
+    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 `devspace config set publicBaseUrl <url|null>` is supported right now.");
+    }
+    const value = rest.join(" ").trim();
+    if (!value) {
+        throw new Error("Missing publicBaseUrl value.");
+    }
+    writeDevspaceConfig({
+        ...files.config,
+        publicBaseUrl: normalizeOptionalPublicBaseUrl(value),
+    });
+    console.log(`Updated ${files.configPath}`);
+}
+function printHelp() {
+    console.log([
+        "DevSpace",
+        "",
+        "Usage:",
+        "  devspace                 Run first-time setup if needed, then start the server",
+        "  devspace serve           Start the server",
+        "  devspace ui              Start the server and open the visual dashboard",
+        "  devspace init            Create or update ~/.devspace/config.json and auth.json",
+        "  devspace doctor          Show config, runtime, and native dependency status",
+        "  devspace config get      Print persisted config",
+        "  devspace config set publicBaseUrl <url|null>",
+        "  devspace -v, --version   Print the installed version",
+        "",
+        "For temporary tunnels:",
+        "  DEVSPACE_PUBLIC_BASE_URL=https://example.trycloudflare.com devspace serve",
+    ].join("\n"));
+}
+function printVersion() {
+    const packageJson = require("../package.json");
+    if (typeof packageJson.version !== "string") {
+        throw new Error("Unable to read DevSpace package version.");
+    }
+    console.log(packageJson.version);
+}
+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([
+        `DevSpace 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/vendor/devspace/dist/config.js

@@ -0,0 +1,253 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { expandHomePath } from "./roots.js";
+import { loadDevspaceFiles, } from "./user-config.js";
+const DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS = 60 * 60;
+const DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS = 30 * 24 * 60 * 60;
+const ROUTE_TUNNEL_MODES = ["manual", "cloudflare-named", "ngrok"];
+function parsePort(value) {
+    if (value === undefined || value === "")
+        return 7676;
+    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, persisted) {
+    if (env.DEVSPACE_TOOL_MODE === "minimal")
+        return true;
+    if (env.DEVSPACE_TOOL_MODE === "full")
+        return false;
+    if (env.DEVSPACE_TOOL_MODE) {
+        throw new Error(`Invalid DEVSPACE_TOOL_MODE: ${env.DEVSPACE_TOOL_MODE}`);
+    }
+    if (env.DEVSPACE_MINIMAL_TOOLS !== undefined)
+        return parseBoolean(env.DEVSPACE_MINIMAL_TOOLS);
+    return persisted ?? true;
+}
+function parseLogLevel(value) {
+    if (!value || value === "info")
+        return "info";
+    if (["silent", "error", "warn", "debug"].includes(value))
+        return value;
+    throw new Error(`Invalid DEVSPACE_LOG_LEVEL: ${value}`);
+}
+function parseLogFormat(value) {
+    if (!value || value === "json")
+        return "json";
+    if (value === "pretty")
+        return "pretty";
+    throw new Error(`Invalid DEVSPACE_LOG_FORMAT: ${value}`);
+}
+function parsePathList(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => resolve(expandHomePath(entry.trim()))).filter(Boolean);
+    }
+    return (value
+        ?.split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => resolve(expandHomePath(entry))) ?? []);
+}
+function parseRouteTunnelMode(value) {
+    if (typeof value !== "string" || !ROUTE_TUNNEL_MODES.includes(value)) {
+        throw new Error(`Invalid route tunnel mode: ${String(value)}`);
+    }
+    return value;
+}
+function parseRoutes(value) {
+    if (!value)
+        return [];
+    if (!Array.isArray(value))
+        throw new Error("Invalid routes: expected an array.");
+    return value.map((route, index) => {
+        if (!route || typeof route !== "object") {
+            throw new Error(`Invalid routes[${index}]: expected an object.`);
+        }
+        const name = typeof route.name === "string" ? route.name.trim() : "";
+        const root = typeof route.root === "string" ? route.root.trim() : "";
+        const hostname = typeof route.hostname === "string" ? route.hostname.trim() : "";
+        const port = Number(route.port);
+        if (!name)
+            throw new Error(`Invalid routes[${index}].name: required.`);
+        if (!root)
+            throw new Error(`Invalid routes[${index}].root: required.`);
+        if (!hostname)
+            throw new Error(`Invalid routes[${index}].hostname: required.`);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new Error(`Invalid routes[${index}].port: expected 1-65535.`);
+        }
+        const publicBaseUrl = route.publicBaseUrl?.trim() || `https://${hostname}`;
+        return {
+            name,
+            root: resolve(expandHomePath(root)),
+            port,
+            hostname,
+            tunnel: parseRouteTunnelMode(route.tunnel ?? "manual"),
+            publicBaseUrl,
+            subdomain: route.subdomain?.trim() || undefined,
+            tunnelName: route.tunnelName?.trim() || undefined,
+            tunnelId: route.tunnelId?.trim() || undefined,
+            cloudflareConfig: route.cloudflareConfig?.trim()
+                ? resolve(expandHomePath(route.cloudflareConfig.trim()))
+                : undefined,
+            enabled: route.enabled ?? true,
+        };
+    });
+}
+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 DEVSPACE_TOOL_NAMING: ${value}`);
+}
+function parseBooleanSetting(value, persisted, fallback) {
+    return value === undefined ? persisted ?? fallback : parseBoolean(value);
+}
+function parseLoggingConfig(env, persisted) {
+    return {
+        level: parseLogLevel(env.DEVSPACE_LOG_LEVEL ?? persisted?.level),
+        format: parseLogFormat(env.DEVSPACE_LOG_FORMAT ?? persisted?.format),
+        requests: parseBooleanSetting(env.DEVSPACE_LOG_REQUESTS, persisted?.requests, true),
+        assets: parseBooleanSetting(env.DEVSPACE_LOG_ASSETS, persisted?.assets, false),
+        toolCalls: parseBooleanSetting(env.DEVSPACE_LOG_TOOL_CALLS, persisted?.toolCalls, true),
+        shellCommands: parseBooleanSetting(env.DEVSPACE_LOG_SHELL_COMMANDS, persisted?.shellCommands, false),
+        trustProxy: parseBooleanSetting(env.DEVSPACE_TRUST_PROXY, persisted?.trustProxy, false),
+    };
+}
+function parseWidgetMode(value) {
+    if (!value || value === "full")
+        return "full";
+    if (value === "off" || value === "changes")
+        return value;
+    throw new Error(`Invalid DEVSPACE_WIDGETS: ${value}`);
+}
+function parseRequiredSecret(value, name) {
+    const secret = value?.trim();
+    if (!secret) {
+        throw new Error(`${name} is required for DevSpace OAuth. Run: devspace 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.DEVSPACE_OAUTH_OWNER_TOKEN ?? ownerToken, "DEVSPACE_OAUTH_OWNER_TOKEN"),
+        accessTokenTtlSeconds: parsePositiveInteger(env.DEVSPACE_OAUTH_ACCESS_TOKEN_TTL_SECONDS, DEFAULT_OAUTH_ACCESS_TOKEN_TTL_SECONDS, "DEVSPACE_OAUTH_ACCESS_TOKEN_TTL_SECONDS"),
+        refreshTokenTtlSeconds: parsePositiveInteger(env.DEVSPACE_OAUTH_REFRESH_TOKEN_TTL_SECONDS, DEFAULT_OAUTH_REFRESH_TOKEN_TTL_SECONDS, "DEVSPACE_OAUTH_REFRESH_TOKEN_TTL_SECONDS"),
+        scopes: parseStringList(env.DEVSPACE_OAUTH_SCOPES, ["devspace"]),
+        allowedRedirectHosts: parseStringList(env.DEVSPACE_OAUTH_ALLOWED_REDIRECT_HOSTS, [
+            "chatgpt.com",
+            "localhost",
+            "127.0.0.1",
+        ]),
+    };
+}
+function defaultStateDir() {
+    return join(homedir(), ".local", "share", "devspace");
+}
+function defaultWorktreeRoot() {
+    return join(homedir(), ".devspace", "worktrees");
+}
+function defaultAgentDir() {
+    return join(homedir(), ".codex");
+}
+export function loadConfig(env = process.env) {
+    const files = loadDevspaceFiles(env);
+    const host = env.HOST ?? files.config.host ?? "127.0.0.1";
+    const port = parsePort(env.PORT ?? files.config.port);
+    const publicBaseUrl = parsePublicBaseUrl(env.DEVSPACE_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.DEVSPACE_ALLOWED_ROOTS ?? files.config.allowedRoots),
+        allowedHosts: parseAllowedHosts(env.DEVSPACE_ALLOWED_HOSTS, derivedAllowedHosts),
+        publicBaseUrl,
+        minimalTools: parseMinimalTools(env, files.config.minimalTools),
+        toolNaming: parseToolNaming(env.DEVSPACE_TOOL_NAMING ?? files.config.toolNaming),
+        widgets: parseWidgetMode(env.DEVSPACE_WIDGETS ?? files.config.widgets),
+        stateDir: resolve(expandHomePath(env.DEVSPACE_STATE_DIR ?? files.config.stateDir ?? defaultStateDir())),
+        worktreeRoot: resolve(expandHomePath(env.DEVSPACE_WORKTREE_ROOT ?? files.config.worktreeRoot ?? defaultWorktreeRoot())),
+        skillsEnabled: env.DEVSPACE_SKILLS === undefined
+            ? files.config.skillsEnabled ?? true
+            : parseBoolean(env.DEVSPACE_SKILLS),
+        skillPaths: parsePathList(env.DEVSPACE_SKILL_PATHS ?? files.config.skillPaths),
+        agentDir: resolve(expandHomePath(env.DEVSPACE_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
+        logging: parseLoggingConfig(env, files.config.logging),
+        routes: parseRoutes(files.config.routes),
+    };
+}
+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}`;
+}