@waishnav/devspace 1.0.0

package/README.md

@@ -0,0 +1,146 @@
+<p align="center">
+  <picture>
+    <img src="docs/assets/devspace-logo-light.png" alt="DevSpace logo" width="140">
+  </picture>
+</p>
+
+<h1 align="center">DevSpace</h1>
+
+<p align="center">Bring a Codex-style coding workflow to ChatGPT.</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@waishnav/devspace"><img alt="npm" src="https://img.shields.io/npm/v/%40waishnav%2Fdevspace?style=flat-square" /></a>
+  <a href="https://github.com/Waishnav/devspace/actions/workflows/ci.yml"><img alt="CI" src="https://img.shields.io/github/actions/workflow/status/Waishnav/devspace/ci.yml?style=flat-square&branch=main" /></a>
+  <a href="https://github.com/Waishnav/devspace/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/npm/l/%40waishnav%2Fdevspace?style=flat-square" /></a>
+</p>
+
+[![DevSpace connected to ChatGPT](docs/assets/devspace-screenshot.png)](docs/assets/devspace-screenshot.png)
+
+**Give ChatGPT a secure connection to your own machine and Turn ChatGPT into Codex**
+
+DevSpace is a self-hosted MCP server that lets ChatGPT read, edit, search, and run code in your real local projects — your files, your tools, your terminal — without uploading anything to a third party. You run it on your machine, expose it through a tunnel you control, and approve the connection with a password only you have.
+
+## Quick Start
+
+DevSpace requires Node `>=20.12 <27`. Node 22 LTS is recommended.
+
+```bash
+npx @waishnav/devspace init
+npx @waishnav/devspace serve
+```
+
+During setup, DevSpace asks for:
+
+- the local project folders ChatGPT is allowed to open through DevSpace
+- the local port, usually `7676`
+- your public HTTPS base URL from Cloudflare Tunnel, ngrok, Pinggy, Tailscale Funnel, or
+  another reverse proxy
+
+Use the public origin without `/mcp` during setup:
+
+```text
+https://your-tunnel-host.example.com
+```
+
+Then configure your MCP client with:
+
+```text
+https://your-tunnel-host.example.com/mcp
+```
+
+When the client connects, DevSpace opens an Owner password approval page. Enter
+the Owner password printed by `devspace init`. It is also stored in:
+
+```text
+~/.devspace/auth.json
+```
+
+Keep that password private.
+
+## What ChatGPT Gets
+
+After the MCP client connects, ChatGPT can open a project with
+`open_workspace` and then reuse the returned `workspaceId` for later calls.
+
+DevSpace provides tools for:
+
+- reading, writing, and editing files inside the opened workspace
+- searching files and listing directories
+- running shell commands for tests, builds, git, and package scripts
+- opening isolated Git worktrees when you want parallel work
+- loading `AGENTS.md` and `CLAUDE.md` instructions
+- exposing local agent skills from your skill folders
+- showing ChatGPT Apps review cards for aggregate diffs
+
+The default local endpoint is:
+
+```text
+http://127.0.0.1:7676/mcp
+```
+
+Most users should connect through a public HTTPS tunnel:
+
+```text
+https://your-tunnel-host.example.com/mcp
+```
+
+## Mental Model
+
+DevSpace is remote access to selected local folders.
+
+You decide which roots are allowed. The MCP client still has powerful local
+capabilities inside an opened workspace, including shell execution. Treat a
+connected client like a trusted coding partner with access to your machine.
+
+For a normal ChatGPT coding session:
+
+1. Start your tunnel.
+2. Run `npx @waishnav/devspace serve`.
+3. Connect the MCP client to your public `/mcp` URL.
+4. Approve the connection with the Owner password.
+5. Ask ChatGPT to open a project inside one of your allowed roots.
+
+## Platform Support
+
+DevSpace supports Linux, macOS, and Windows environments with a Bash-compatible
+shell.
+
+| Platform                                          | Status            | Notes                                          |
+| ------------------------------------------------- | ----------------- | ---------------------------------------------- |
+| Linux                                             | Supported         | Requires Node, npm, Git, and Bash.             |
+| macOS                                             | Supported         | Requires Node, npm, Git, and Bash.             |
+| Windows with Git Bash, WSL, MSYS2, or Cygwin Bash | Supported         | Git Bash is the simplest native Windows setup. |
+| Windows PowerShell or `cmd.exe` only              | Not supported yet | Install Git Bash or use WSL.                   |
+
+Run this to inspect your local setup:
+
+```bash
+npx @waishnav/devspace doctor
+```
+
+## Documentation
+
+- [Setup Guide](docs/setup.md)
+- [ChatGPT Coding Workflow](docs/chatgpt-coding-workflow.md)
+- [Configuration Reference](docs/configuration.md)
+- [Security Model](docs/security.md)
+- [Troubleshooting Gotchas](docs/gotchas.md)
+
+## Local Development
+
+For working on DevSpace itself:
+
+```bash
+npm install --include=dev
+npm run typecheck
+npm test
+npm run build
+npm run start
+```
+
+For long-running local server processes, build an immutable release copy:
+
+```bash
+npm run release:build
+npm run release:start
+```

package/dist/cli.js

@@ -0,0 +1,331 @@
+#!/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, 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 "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 = 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() {
+    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 httpServer = app.listen(config.port, config.host, () => {
+        console.log(`devspace 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 DEVSPACE_ALLOWED_HOSTS=*");
+        }
+        console.log("auth: Owner password approval required");
+        console.log(`logging: ${config.logging.level} ${config.logging.format}`);
+    });
+    const shutdown = () => {
+        httpServer.close(() => process.exit(0));
+    };
+    process.once("SIGINT", shutdown);
+    process.once("SIGTERM", shutdown);
+}
+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 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>",
+        "",
+        "For temporary tunnels:",
+        "  DEVSPACE_PUBLIC_BASE_URL=https://example.trycloudflare.com devspace 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([
+        `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/dist/config.js

@@ -0,0 +1,188 @@
+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;
+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) {
+    return env.DEVSPACE_TOOL_MODE === "minimal" || parseBoolean(env.DEVSPACE_MINIMAL_TOOLS);
+}
+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) {
+    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 === "legacy")
+        return "legacy";
+    if (value === "short")
+        return "short";
+    throw new Error(`Invalid DEVSPACE_TOOL_NAMING: ${value}`);
+}
+function parseLoggingConfig(env) {
+    return {
+        level: parseLogLevel(env.DEVSPACE_LOG_LEVEL),
+        format: parseLogFormat(env.DEVSPACE_LOG_FORMAT),
+        requests: env.DEVSPACE_LOG_REQUESTS === undefined ? true : parseBoolean(env.DEVSPACE_LOG_REQUESTS),
+        assets: parseBoolean(env.DEVSPACE_LOG_ASSETS),
+        toolCalls: env.DEVSPACE_LOG_TOOL_CALLS === undefined ? true : parseBoolean(env.DEVSPACE_LOG_TOOL_CALLS),
+        shellCommands: parseBoolean(env.DEVSPACE_LOG_SHELL_COMMANDS),
+        trustProxy: parseBoolean(env.DEVSPACE_TRUST_PROXY),
+    };
+}
+function parseWidgetMode(value) {
+    if (!value || value === "changes")
+        return "changes";
+    if (value === "off" || value === "full")
+        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),
+        toolNaming: parseToolNaming(env.DEVSPACE_TOOL_NAMING),
+        widgets: parseWidgetMode(env.DEVSPACE_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 ? true : parseBoolean(env.DEVSPACE_SKILLS),
+        skillPaths: parsePathList(env.DEVSPACE_SKILL_PATHS),
+        agentDir: resolve(expandHomePath(env.DEVSPACE_AGENT_DIR ?? files.config.agentDir ?? defaultAgentDir())),
+        logging: parseLoggingConfig(env),
+    };
+}
+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/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, "devspace.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 });
+}