patchwork-os 0.2.0-alpha.0

package/dist/config.js

@@ -0,0 +1,720 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { loadConfig as loadPatchworkConfig, defaultConfigPath as patchworkConfigPath, } from "./patchworkConfig.js";
+const DEFAULT_ALLOWLIST = [
+    "git",
+    "npm",
+    "cargo",
+    "go",
+    "pytest",
+    "jest",
+    "vitest",
+    "tsc",
+    "eslint",
+    "biome",
+];
+/**
+ * Extra commands enabled by --vps flag for headless server deployments.
+ * Not interpreter commands — safe to allowlist when no GUI IDE is attached.
+ */
+export const VPS_ALLOWLIST_EXTRAS = [
+    "curl",
+    "systemctl",
+    "journalctl",
+    "service",
+    "nginx",
+    "pm2",
+    "docker",
+    "docker-compose",
+    "certbot",
+    "ufw",
+    "htop",
+    "top",
+    "ss",
+    "lsof",
+    "tar",
+    "gzip",
+    "gunzip",
+    "rsync",
+    "dig",
+    "openssl",
+    "prisma",
+];
+/**
+ * Extra commands enabled by --db flag for database development.
+ * Not interpreter commands — safe to allowlist for DB workflows.
+ */
+export const DB_ALLOWLIST_EXTRAS = [
+    "psql",
+    "pg_dump",
+    "pg_restore",
+    "createdb",
+    "dropdb",
+    "mysql",
+    "mysqldump",
+    "sqlite3",
+    "redis-cli",
+    "mongosh",
+];
+/** Commands that can execute arbitrary code via flags like -e, -c, --eval.
+ *  These are blocked from the default allowlist but can be added via --allow-command. */
+export const INTERPRETER_COMMANDS = new Set([
+    "node",
+    "python",
+    "python3",
+    "make",
+    "bash",
+    "sh",
+    "zsh",
+    "dash",
+    "fish",
+    "ksh",
+    "csh",
+    "tcsh",
+    "ruby",
+    "perl",
+    "lua",
+    "php",
+]);
+const EDITOR_IDE_NAMES = {
+    windsurf: "Windsurf",
+    cursor: "Cursor",
+    antigravity: "Antigravity",
+    ag: "Antigravity",
+    code: "VS Code",
+};
+export function findEditor() {
+    const whichCmd = process.platform === "win32" ? "where" : "which";
+    for (const cmd of ["windsurf", "cursor", "antigravity", "ag", "code"]) {
+        try {
+            execFileSync(whichCmd, [cmd], { stdio: "ignore", timeout: 3000 });
+            return cmd;
+        }
+        catch {
+            // not found
+        }
+    }
+    return null;
+}
+/** Exported for testing. Maps an editor CLI command to its human-readable IDE name. */
+export function ideNameFromEditor(editorCommand) {
+    return EDITOR_IDE_NAMES[editorCommand] ?? editorCommand;
+}
+const KNOWN_CONFIG_FILE_KEYS = new Set([
+    "workspace",
+    "port",
+    "logLevel",
+    "linters",
+    "commandAllowlist",
+    "vscodeCommandAllowlist",
+    "commandTimeout",
+    "maxResultSize",
+    "gracePeriodMs",
+    "bindAddress",
+    "editorCommand",
+    "ideName",
+    "autoTmux",
+    "claudeDriver",
+    "claudeBinary",
+    "antBinary",
+    "automationEnabled",
+    "automationPolicyPath",
+    "plugins",
+    "pluginWatch",
+    "fixedToken",
+    "issuerUrl",
+    "oauthTokenTtlDays",
+    "corsOrigins",
+    "fullMode",
+    "maxSessions",
+    "githubDefaultRepo",
+    "lspVerbosity",
+]);
+/**
+ * Load a config file and return its contents as a partial Config.
+ * Discovery order: $CLAUDE_IDE_BRIDGE_CONFIG → ./claude-ide-bridge.config.json → ~/.claude/ide/config.json
+ * On any error (file not found, parse failure) logs a warning and returns {}.
+ */
+export function loadConfigFile(configPath) {
+    const candidates = [];
+    if (configPath) {
+        candidates.push(configPath);
+    }
+    else {
+        if (process.env.CLAUDE_IDE_BRIDGE_CONFIG) {
+            candidates.push(process.env.CLAUDE_IDE_BRIDGE_CONFIG);
+        }
+        candidates.push(path.join(process.cwd(), "claude-ide-bridge.config.json"));
+        const claudeDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+        candidates.push(path.join(claudeDir, "ide", "config.json"));
+    }
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            const raw = fs.readFileSync(candidate, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed !== "object" ||
+                parsed === null ||
+                Array.isArray(parsed)) {
+                console.warn(`Warning: Config file ${candidate} is not a JSON object — ignored`);
+                return {};
+            }
+            const obj = parsed;
+            for (const key of Object.keys(obj)) {
+                if (!KNOWN_CONFIG_FILE_KEYS.has(key)) {
+                    console.warn(`Warning: Unknown config file key "${key}" in ${candidate} — check for typos or update the bridge. Key ignored.`);
+                }
+            }
+            // Coerce numeric fields (JSON stringifies may convert to strings)
+            for (const numKey of [
+                "port",
+                "commandTimeout",
+                "maxResultSize",
+                "gracePeriodMs",
+                "maxSessions",
+                "oauthTokenTtlDays",
+            ]) {
+                if (numKey in obj && typeof obj[numKey] === "string") {
+                    const parsed = Number.parseInt(obj[numKey], 10);
+                    if (Number.isInteger(parsed))
+                        obj[numKey] = parsed;
+                }
+            }
+            return obj;
+        }
+        catch (err) {
+            console.warn(`Warning: Failed to parse config file ${candidate}: ${err instanceof Error ? err.message : String(err)} — ignored`);
+            return {};
+        }
+    }
+    return {};
+}
+function requireArg(args, i, flag) {
+    const value = args[i];
+    if (value === undefined || value.startsWith("--")) {
+        throw new Error(`Missing value for ${flag}`);
+    }
+    return value;
+}
+export function parseConfig(argv) {
+    const args = argv.slice(2);
+    // Find --config path before the main arg parse (lowest priority: loaded first)
+    let configFilePath;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--config") {
+            if (i + 1 >= args.length) {
+                throw new Error("--config requires a path argument");
+            }
+            configFilePath = args[++i];
+            if (configFilePath.length > 4096) {
+                throw new Error("--config path is too long (max 4096 chars)");
+            }
+            break;
+        }
+    }
+    const fileConfig = loadConfigFile(configFilePath);
+    // Defaults — config file values fill in where CLI/env don't override
+    let workspace = fileConfig.workspace
+        ? path.resolve(fileConfig.workspace)
+        : process.cwd();
+    let ideName = fileConfig.ideName ?? "External";
+    let editorCommand = fileConfig.editorCommand ?? null;
+    let port = fileConfig.port ?? null;
+    let verbose = false;
+    let jsonl = false;
+    let linters = fileConfig.linters ?? [];
+    for (const cmd of fileConfig.commandAllowlist ?? []) {
+        if (INTERPRETER_COMMANDS.has(cmd)) {
+            throw new Error(`"${cmd}" is an interpreter and cannot be added via commandAllowlist in config file (arbitrary code execution risk)`);
+        }
+    }
+    const commandAllowlist = [
+        ...DEFAULT_ALLOWLIST,
+        ...(fileConfig.commandAllowlist ?? []),
+    ];
+    const vscodeCommandAllowlist = fileConfig.vscodeCommandAllowlist ?? [];
+    let bindAddress = process.env.BRIDGE_BIND_ADDRESS ?? fileConfig.bindAddress ?? "127.0.0.1";
+    let commandTimeout = fileConfig.commandTimeout ?? 30_000;
+    let maxResultSize = fileConfig.maxResultSize ?? 512;
+    let gracePeriodMs = fileConfig.gracePeriodMs ?? 120_000;
+    let autoTmux = fileConfig.autoTmux ?? false;
+    let watch = false;
+    let vps = false;
+    let db = false;
+    let allowPrivateHttp = false;
+    let pluginWatch = fileConfig.pluginWatch ?? false;
+    let fixedToken = fileConfig.fixedToken ?? null;
+    let issuerUrl = fileConfig.issuerUrl ?? null;
+    const rawTtlDays = fileConfig.oauthTokenTtlDays;
+    const oauthTokenTtlMs = typeof rawTtlDays === "number" && rawTtlDays > 0
+        ? Math.min(Math.max(rawTtlDays, 1), 90) * 24 * 60 * 60 * 1_000
+        : 24 * 60 * 60 * 1_000; // default 24h
+    let corsOrigins = fileConfig.corsOrigins ?? [];
+    let claudeDriver = fileConfig.claudeDriver ?? "none";
+    let claudeBinary = fileConfig.claudeBinary ?? "claude";
+    let antBinary = fileConfig.antBinary ?? "ant";
+    let automationEnabled = fileConfig.automationEnabled ?? false;
+    let automationPolicyPath = fileConfig.automationPolicyPath ?? null;
+    let approvalGate = fileConfig.approvalGate ??
+        "off";
+    let managedSettingsPath = null;
+    // Read approvalWebhookUrl and approvalGate from patchwork config (non-fatal, CLI flag takes precedence)
+    const approvalWebhookUrl = (() => {
+        try {
+            const pw = loadPatchworkConfig(patchworkConfigPath());
+            if (pw.approvalGate &&
+                !fileConfig.approvalGate) {
+                approvalGate = pw.approvalGate;
+            }
+            return pw.dashboard?.webhookUrl ?? null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    let toolRateLimit = 60;
+    const plugins = [...(fileConfig.plugins ?? [])];
+    let auditLogPath = null;
+    let fullMode = fileConfig.fullMode ?? true;
+    let maxSessions = fileConfig.maxSessions ?? 5;
+    if (fileConfig.maxSessions !== undefined &&
+        (typeof fileConfig.maxSessions !== "number" ||
+            fileConfig.maxSessions < 1 ||
+            fileConfig.maxSessions > 100)) {
+        throw new Error(`Invalid maxSessions in config file: ${fileConfig.maxSessions}. Must be a number between 1 and 100.`);
+    }
+    let analyticsEnabled = null;
+    const githubDefaultRepo = fileConfig.githubDefaultRepo ?? null;
+    let lspVerbosity = fileConfig.lspVerbosity ?? "normal";
+    for (let i = 0; i < args.length; i++) {
+        switch (args[i]) {
+            case "--workspace":
+                workspace = path.resolve(requireArg(args, ++i, "--workspace"));
+                break;
+            case "--ide-name":
+                ideName = requireArg(args, ++i, "--ide-name");
+                if (ideName.length > 256)
+                    throw new Error("--ide-name value too long (max 256 chars)");
+                break;
+            case "--editor":
+                editorCommand = requireArg(args, ++i, "--editor");
+                if (editorCommand.length > 4096)
+                    throw new Error("--editor value too long (max 4096 chars)");
+                break;
+            case "--bind":
+                bindAddress = requireArg(args, ++i, "--bind");
+                if (bindAddress.length > 64)
+                    throw new Error("--bind value too long (max 64 chars)");
+                break;
+            case "--port": {
+                const portStr = requireArg(args, ++i, "--port");
+                port = Number.parseInt(portStr, 10);
+                if (!Number.isInteger(port) || port < 1024 || port > 65535) {
+                    throw new Error(`Invalid port: ${portStr}. Must be an integer between 1024 and 65535.`);
+                }
+                break;
+            }
+            case "--verbose":
+                verbose = true;
+                break;
+            case "--jsonl":
+                jsonl = true;
+                break;
+            case "--linter": {
+                const linter = requireArg(args, ++i, "--linter");
+                if (linter.length > 256)
+                    throw new Error("--linter value too long (max 256 chars)");
+                linters.push(linter);
+                break;
+            }
+            case "--allow-command": {
+                const cmd = requireArg(args, ++i, "--allow-command");
+                if (cmd.length > 256)
+                    throw new Error("--allow-command value too long (max 256 chars)");
+                if (INTERPRETER_COMMANDS.has(cmd)) {
+                    throw new Error(`"${cmd}" is an interpreter and cannot be added via --allow-command (arbitrary code execution risk)`);
+                }
+                commandAllowlist.push(cmd);
+                break;
+            }
+            case "--vscode-allow-command": {
+                const vcmd = requireArg(args, ++i, "--vscode-allow-command");
+                if (vcmd.length > 256)
+                    throw new Error("--vscode-allow-command value too long (max 256 chars)");
+                vscodeCommandAllowlist.push(vcmd);
+                break;
+            }
+            case "--timeout": {
+                const tStr = requireArg(args, ++i, "--timeout");
+                commandTimeout = Number.parseInt(tStr, 10);
+                if (!Number.isInteger(commandTimeout) ||
+                    commandTimeout < 1000 ||
+                    commandTimeout > 600_000) {
+                    throw new Error(`Invalid timeout: ${tStr}. Must be between 1000 and 600000 ms.`);
+                }
+                break;
+            }
+            case "--config":
+                // Already consumed above to load config file; skip the value
+                i++;
+                break;
+            case "--vps":
+                vps = true;
+                commandAllowlist.push(...VPS_ALLOWLIST_EXTRAS);
+                break;
+            case "--db":
+                db = true;
+                commandAllowlist.push(...DB_ALLOWLIST_EXTRAS);
+                break;
+            case "--allow-private-http":
+                allowPrivateHttp = true;
+                break;
+            case "--watch":
+                watch = true;
+                break;
+            case "--auto-tmux":
+                autoTmux = true;
+                break;
+            case "--claude-driver": {
+                const driverVal = requireArg(args, ++i, "--claude-driver");
+                if (driverVal !== "subprocess" &&
+                    driverVal !== "api" &&
+                    driverVal !== "none") {
+                    throw new Error(`Invalid --claude-driver value: "${driverVal}". Must be "subprocess", "api", or "none".`);
+                }
+                claudeDriver = driverVal;
+                break;
+            }
+            case "--claude-binary":
+                claudeBinary = requireArg(args, ++i, "--claude-binary");
+                if (claudeBinary.length > 4096)
+                    throw new Error("--claude-binary value too long (max 4096 chars)");
+                break;
+            case "--ant-binary":
+                antBinary = requireArg(args, ++i, "--ant-binary");
+                if (antBinary.length > 4096)
+                    throw new Error("--ant-binary value too long (max 4096 chars)");
+                break;
+            case "--approval-gate": {
+                const val = requireArg(args, ++i, "--approval-gate");
+                if (val !== "off" && val !== "high" && val !== "all") {
+                    throw new Error(`--approval-gate must be one of: off, high, all (got "${val}")`);
+                }
+                approvalGate = val;
+                break;
+            }
+            case "--managed-settings": {
+                const mp = requireArg(args, ++i, "--managed-settings");
+                if (mp.length > 4096)
+                    throw new Error("--managed-settings path too long (max 4096 chars)");
+                managedSettingsPath = path.resolve(mp);
+                break;
+            }
+            case "--automation":
+                automationEnabled = true;
+                break;
+            case "--automation-policy":
+                automationPolicyPath = path.resolve(requireArg(args, ++i, "--automation-policy"));
+                break;
+            case "--plugin": {
+                const pluginPath = requireArg(args, ++i, "--plugin");
+                if (pluginPath.length > 4096)
+                    throw new Error("--plugin path too long (max 4096 chars)");
+                plugins.push(pluginPath);
+                break;
+            }
+            case "--fixed-token": {
+                const tok = requireArg(args, ++i, "--fixed-token");
+                if (!/^[0-9a-f-]{36}$/.test(tok))
+                    throw new Error("--fixed-token must be a valid UUID (e.g. from uuidgen or crypto.randomUUID())");
+                fixedToken = tok;
+                break;
+            }
+            case "--issuer-url": {
+                issuerUrl = requireArg(args, ++i, "--issuer-url");
+                if (!/^https?:\/\/.+/.test(issuerUrl))
+                    throw new Error("--issuer-url must be a valid http/https URL");
+                break;
+            }
+            case "--cors-origin": {
+                const origin = requireArg(args, ++i, "--cors-origin");
+                corsOrigins.push(origin);
+                break;
+            }
+            case "--full":
+                fullMode = true;
+                break;
+            case "--slim":
+                fullMode = false;
+                break;
+            case "--max-sessions": {
+                const msStr = requireArg(args, ++i, "--max-sessions");
+                const ms = Number.parseInt(msStr, 10);
+                if (Number.isNaN(ms) || ms < 1 || ms > 100) {
+                    throw new Error(`Invalid max-sessions: ${msStr}. Must be between 1 and 100.`);
+                }
+                maxSessions = ms;
+                break;
+            }
+            case "--plugin-watch":
+                pluginWatch = true;
+                break;
+            case "--audit-log": {
+                const logPath = requireArg(args, ++i, "--audit-log");
+                if (logPath.length > 4096)
+                    throw new Error("--audit-log path too long (max 4096 chars)");
+                auditLogPath = path.resolve(logPath);
+                break;
+            }
+            case "--lsp-verbosity": {
+                const lv = requireArg(args, ++i, "--lsp-verbosity");
+                if (lv !== "minimal" && lv !== "normal" && lv !== "verbose") {
+                    throw new Error(`Invalid --lsp-verbosity: "${lv}". Must be "minimal", "normal", or "verbose".`);
+                }
+                lspVerbosity = lv;
+                break;
+            }
+            case "--analytics": {
+                const val = requireArg(args, ++i, "--analytics");
+                if (val !== "on" && val !== "off")
+                    throw new Error('--analytics must be "on" or "off"');
+                analyticsEnabled = val === "on";
+                break;
+            }
+            case "--tool-rate-limit": {
+                const tlStr = requireArg(args, ++i, "--tool-rate-limit");
+                toolRateLimit = Number.parseInt(tlStr, 10);
+                if (!Number.isInteger(toolRateLimit) ||
+                    toolRateLimit < 1 ||
+                    toolRateLimit > 10_000) {
+                    throw new Error(`Invalid --tool-rate-limit: ${tlStr}. Must be between 1 and 10000.`);
+                }
+                break;
+            }
+            case "--grace-period": {
+                const gStr = requireArg(args, ++i, "--grace-period");
+                gracePeriodMs = Number.parseInt(gStr, 10);
+                if (!Number.isInteger(gracePeriodMs) ||
+                    gracePeriodMs < 5000 ||
+                    gracePeriodMs > 600_000) {
+                    throw new Error(`Invalid grace-period: ${gStr}. Must be between 5000 and 600000 ms.`);
+                }
+                break;
+            }
+            case "--max-result-size": {
+                const mStr = requireArg(args, ++i, "--max-result-size");
+                maxResultSize = Number.parseInt(mStr, 10);
+                if (!Number.isInteger(maxResultSize) ||
+                    maxResultSize < 1 ||
+                    maxResultSize > 4096) {
+                    throw new Error(`Invalid max-result-size: ${mStr}. Must be between 1 and 4096 KB.`);
+                }
+                break;
+            }
+            case "--help": {
+                console.log(`claude-ide-bridge - Standalone MCP bridge for Claude Code IDE integration
+
+Usage: claude-ide-bridge [options]
+
+Options:
+  --workspace <path>        Workspace folder (default: cwd)
+  --ide-name <name>         IDE name shown to Claude (default: "External")
+  --editor <cmd>            Editor CLI command (default: auto-detect windsurf/cursor/antigravity/code)
+  --port <number>           Force specific port (default: random)
+  --bind <addr>             Bind address (default: 127.0.0.1, env: BRIDGE_BIND_ADDRESS)
+  --fixed-token <uuid>      Use a stable auth token (default: random UUID on each start)
+  --issuer-url <url>        Public URL for OAuth 2.0 (e.g. https://abc.ngrok-free.app)
+  --linter <name>           Enable specific linter (repeatable; default: auto-detect)
+  --allow-command <cmd>     Add command to execution allowlist (repeatable)
+  --vscode-allow-command <cmd>  Add VS Code command to invocation allowlist (repeatable)
+  --timeout <ms>            Command timeout in ms (default: 30000, max: 600000)
+  --max-result-size <KB>    Max output size in KB (default: 512, max: 4096)
+  --grace-period <ms>       Reconnect grace period in ms (default: 30000, max: 600000)
+  --watch                   Supervisor mode: auto-restart bridge on crash (exponential backoff, max 30s)
+  --max-sessions <n>        Max concurrent Claude sessions (default: 5, max: 100)
+  --lsp-verbosity <level>   Hover/LSP output verbosity: "minimal" (type sig only, ~60% smaller),
+                            "normal" (default), "verbose" (all fields)
+  --slim                    Register only the ~60 IDE-exclusive tools (LSP, debugger, editor state).
+                            Default is full mode (~140 tools: adds git, terminal, file ops, HTTP, GitHub).
+  --full                    (default — flag retained for backward compatibility) Explicitly request full tool set.
+  --vps                     VPS/headless mode: expands allowlist with curl, systemctl, docker, tar, dig, openssl, etc.
+  --db                      Database mode: expands allowlist with psql, pg_dump, mysql, sqlite3, redis-cli, mongosh, etc.
+  --allow-private-http      Allow sendHttpRequest to reach localhost/private IPs (for VPS where bridge runs alongside services)
+  --auto-tmux               Auto-wrap in tmux session if not already inside one
+  --config <path>           Load config file (default: ./claude-ide-bridge.config.json)
+  --verbose                 Enable debug logging
+  --jsonl                   Emit structured JSONL events to stderr
+  --version, -v             Print version and exit
+  --analytics <on|off>      Enable or disable anonymous usage analytics
+  --help                    Show this help
+
+Patchwork:
+  --approval-gate <level>   Gate tool calls via oversight dashboard: "off" | "high" | "all" (default: "off")
+  --managed-settings <path> Admin-controlled settings file (highest rule precedence, cannot be overridden by users)
+
+Automation:
+  --claude-driver <mode>    Enable Claude subprocess driver: "subprocess" | "api" | "none" (default: "none")
+  --claude-binary <path>    Path to claude binary (default: "claude")
+  --automation              Enable event-driven automation hooks (requires --claude-driver != none and --automation-policy)
+  --automation-policy <path>  Path to JSON automation policy file
+
+Plugins:
+  --plugin <path-or-package>  Load a plugin (repeatable). Accepts a local path (./my-plugin) or
+                              an npm package name (claude-ide-bridge-plugin-jira).
+                              Plugins must contain a claude-ide-bridge-plugin.json manifest.
+  --plugin-watch         Re-load plugins automatically on file change (requires --plugin)
+
+Subcommands:
+  shim                        stdio relay that auto-discovers the running bridge/orchestrator
+                              and connects Claude Code to it. Add to ~/.claude.json once and
+                              bridge tools are available in every claude session:
+                                { "mcpServers": { "claude-ide-bridge":
+                                    { "command": "claude-ide-bridge", "args": ["shim"] } } }
+  orchestrator                Start the orchestrator bridge — discovers all running IDE bridge
+                              instances and exposes them as a single MCP server. Claude can then
+                              work across multiple IDEs / workspaces in one session.
+                              Options: --port <port> (default 4746)
+                                       --bind <address> (default 127.0.0.1)
+                                       --lock-dir <dir> (default ~/.claude/ide)
+                                       --health-interval <ms> (default 10000)
+  gen-plugin-stub <dir>       Scaffold a new plugin directory with manifest + entrypoint.
+                              Options: --name <org/name>  --prefix <toolPrefix>
+  gen-claude-md               Generate a CLAUDE.md bridge workflow section.
+                              Options: --write [--workspace <path>]
+  print-token                 Print the auth token from the active bridge lock file.
+                              Options: --port <port>
+  install-extension [editor]  Install the VS Code extension into the given editor.
+  init                        One-command setup: install extension + write CLAUDE.md + register
+                              MCP shim + print next steps.
+                              Options: --workspace <path>
+  start-all                   Launch tmux session with bridge + extension watcher panes.
+  status                      Check bridge health and extension connectivity.
+                              Options: --port <port> --json
+
+Environment Variables:
+  CLAUDE_IDE_BRIDGE_EDITOR           Editor command override
+  CLAUDE_IDE_BRIDGE_LINTERS          Comma-separated linter list
+  CLAUDE_IDE_BRIDGE_TIMEOUT          Command timeout in ms
+  CLAUDE_IDE_BRIDGE_MAX_RESULT_SIZE  Max output size in KB
+  CLAUDE_IDE_BRIDGE_GRACE_PERIOD     Reconnect grace period in ms
+  CLAUDE_CONFIG_DIR                  Override ~/.claude directory
+  CLAUDE_IDE_BRIDGE_CONFIG           Path to config file (overrides auto-discovery)`);
+                return process.exit(0);
+            }
+            default: {
+                const arg = args[i];
+                if (arg?.startsWith("--")) {
+                    throw new Error(`Unknown option: ${arg}. Run with --help for usage.`);
+                }
+            }
+        }
+    }
+    // Auto-detect editor
+    editorCommand =
+        editorCommand || process.env.CLAUDE_IDE_BRIDGE_EDITOR || findEditor();
+    // Auto-derive ideName from editor if not explicitly provided
+    if (ideName === "External" && editorCommand) {
+        ideName = ideNameFromEditor(editorCommand);
+    }
+    // Env var overrides
+    if (process.env.CLAUDE_IDE_BRIDGE_TOKEN) {
+        const envTok = process.env.CLAUDE_IDE_BRIDGE_TOKEN;
+        if (/^[0-9a-f-]{36}$/.test(envTok)) {
+            fixedToken = envTok;
+        }
+        else {
+            console.warn("Warning: CLAUDE_IDE_BRIDGE_TOKEN is not a valid UUID — ignored.");
+        }
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_ISSUER_URL) {
+        issuerUrl = process.env.CLAUDE_IDE_BRIDGE_ISSUER_URL;
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_CORS_ORIGINS) {
+        corsOrigins = process.env.CLAUDE_IDE_BRIDGE_CORS_ORIGINS.split(",").map((s) => s.trim());
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_LINTERS) {
+        linters = process.env.CLAUDE_IDE_BRIDGE_LINTERS.split(",").map((s) => s.trim());
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_TIMEOUT) {
+        const envTimeout = Number.parseInt(process.env.CLAUDE_IDE_BRIDGE_TIMEOUT, 10);
+        if (Number.isInteger(envTimeout) &&
+            envTimeout >= 1000 &&
+            envTimeout <= 600_000) {
+            commandTimeout = envTimeout;
+        }
+        else {
+            // console.warn rather than logger — Logger is constructed after parseConfig() returns
+            console.warn(`Warning: CLAUDE_IDE_BRIDGE_TIMEOUT=${process.env.CLAUDE_IDE_BRIDGE_TIMEOUT} is invalid (must be 1000-600000). Using default ${commandTimeout}.`);
+        }
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_MAX_RESULT_SIZE) {
+        const envSize = Number.parseInt(process.env.CLAUDE_IDE_BRIDGE_MAX_RESULT_SIZE, 10);
+        if (Number.isInteger(envSize) && envSize >= 1 && envSize <= 4096) {
+            maxResultSize = envSize;
+        }
+        else {
+            // console.warn rather than logger — Logger is constructed after parseConfig() returns
+            console.warn(`Warning: CLAUDE_IDE_BRIDGE_MAX_RESULT_SIZE=${process.env.CLAUDE_IDE_BRIDGE_MAX_RESULT_SIZE} is invalid (must be 1-4096). Using default ${maxResultSize}.`);
+        }
+    }
+    if (process.env.CLAUDE_IDE_BRIDGE_GRACE_PERIOD) {
+        const envGrace = Number.parseInt(process.env.CLAUDE_IDE_BRIDGE_GRACE_PERIOD, 10);
+        if (Number.isInteger(envGrace) && envGrace >= 5000 && envGrace <= 600_000) {
+            gracePeriodMs = envGrace;
+        }
+        else {
+            console.warn(`Warning: CLAUDE_IDE_BRIDGE_GRACE_PERIOD=${process.env.CLAUDE_IDE_BRIDGE_GRACE_PERIOD} is invalid (must be 5000-600000). Using default ${gracePeriodMs}.`);
+        }
+    }
+    if (pluginWatch && plugins.length === 0) {
+        process.stderr.write("Warning: --plugin-watch has no effect without --plugin\n");
+    }
+    return {
+        workspace,
+        workspaceFolders: [workspace],
+        ideName,
+        editorCommand,
+        port,
+        bindAddress,
+        verbose,
+        jsonl,
+        linters,
+        commandAllowlist,
+        commandTimeout,
+        maxResultSize,
+        vscodeCommandAllowlist,
+        activeWorkspaceFolder: workspace,
+        gracePeriodMs,
+        autoTmux,
+        claudeDriver,
+        claudeBinary,
+        antBinary,
+        automationEnabled,
+        automationPolicyPath,
+        approvalGate,
+        managedSettingsPath,
+        approvalWebhookUrl,
+        toolRateLimit,
+        watch,
+        plugins,
+        pluginWatch,
+        fixedToken,
+        issuerUrl,
+        oauthTokenTtlMs,
+        corsOrigins,
+        vps,
+        db,
+        allowPrivateHttp,
+        auditLogPath,
+        fullMode,
+        maxSessions,
+        analyticsEnabled,
+        githubDefaultRepo,
+        wsPingIntervalMs: 10_000,
+        lspVerbosity,
+    };
+}
+//# sourceMappingURL=config.js.map