patchwarden 0.4.0

package/dist/config.js

@@ -0,0 +1,131 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+// ── Defaults ──────────────────────────────────────────────────────
+const DEFAULT_CONFIG = {
+    workspaceRoot: process.cwd(),
+    plansDir: ".patchwarden/plans",
+    tasksDir: ".patchwarden/tasks",
+    agents: {
+        codex: {
+            command: "codex",
+            args: ["exec", "--cd", "{repo}", "{prompt}"],
+        },
+        opencode: {
+            command: "opencode",
+            args: ["run", "{prompt}"],
+        },
+    },
+    allowedTestCommands: [
+        "npm test",
+        "npm run test",
+        "npm run lint",
+        "npm run format:check",
+        "npm run build",
+        "npm run dist",
+        "npm run doctor",
+        "pnpm test",
+        "pnpm run test",
+        "pnpm run lint",
+        "pnpm run format:check",
+        "pnpm run build",
+        "pnpm run dist",
+        "pnpm run doctor",
+        "pytest",
+        "cargo test",
+    ],
+    maxReadFileBytes: 200_000,
+    defaultTaskTimeoutSeconds: 900,
+    maxTaskTimeoutSeconds: 3600,
+    watcherStaleSeconds: 30,
+    toolProfile: "full",
+};
+// ── Load config ───────────────────────────────────────────────────
+let _config = null;
+export function loadConfig(configPath) {
+    if (_config)
+        return _config;
+    const explicitPath = configPath || process.env.PATCHWARDEN_CONFIG;
+    const candidatePaths = explicitPath
+        ? [explicitPath]
+        : [
+            resolve(process.cwd(), "patchwarden.config.json"),
+            resolve(process.cwd(), ".patchwarden.json"),
+        ];
+    for (const p of candidatePaths) {
+        if (existsSync(p)) {
+            try {
+                const rawText = stripBom(readFileSync(p, "utf-8"));
+                const raw = JSON.parse(rawText);
+                _config = normalizeConfig({ ...DEFAULT_CONFIG, ...raw });
+                return _config;
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                throw new Error(`Failed to load PatchWarden config "${p}": ${message}`);
+            }
+        }
+    }
+    if (explicitPath) {
+        throw new Error(`PatchWarden config not found: "${explicitPath}"`);
+    }
+    _config = normalizeConfig({ ...DEFAULT_CONFIG });
+    return _config;
+}
+export function getConfig() {
+    if (!_config)
+        return loadConfig();
+    return _config;
+}
+/** Resolve workspaceRoot: expand relative paths */
+export function resolveWorkspaceRoot(config) {
+    return resolve(config.workspaceRoot);
+}
+/** Resolve plans/tasks dirs relative to workspaceRoot */
+export function getPlansDir(config) {
+    return resolve(config.workspaceRoot, config.plansDir);
+}
+export function getTasksDir(config) {
+    return resolve(config.workspaceRoot, config.tasksDir);
+}
+function stripBom(value) {
+    return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value;
+}
+function normalizeConfig(config) {
+    if (!config.workspaceRoot || typeof config.workspaceRoot !== "string") {
+        throw new Error("workspaceRoot must be a non-empty string");
+    }
+    if (!config.plansDir || typeof config.plansDir !== "string") {
+        throw new Error("plansDir must be a non-empty string");
+    }
+    if (!config.tasksDir || typeof config.tasksDir !== "string") {
+        throw new Error("tasksDir must be a non-empty string");
+    }
+    if (!config.agents || typeof config.agents !== "object") {
+        throw new Error("agents must be an object");
+    }
+    if (!Array.isArray(config.allowedTestCommands)) {
+        throw new Error("allowedTestCommands must be an array");
+    }
+    if (!Number.isFinite(config.maxReadFileBytes) || config.maxReadFileBytes <= 0) {
+        throw new Error("maxReadFileBytes must be a positive number");
+    }
+    if (!Number.isInteger(config.defaultTaskTimeoutSeconds) || config.defaultTaskTimeoutSeconds <= 0) {
+        throw new Error("defaultTaskTimeoutSeconds must be a positive integer");
+    }
+    if (!Number.isInteger(config.maxTaskTimeoutSeconds) || config.maxTaskTimeoutSeconds <= 0) {
+        throw new Error("maxTaskTimeoutSeconds must be a positive integer");
+    }
+    if (config.defaultTaskTimeoutSeconds > config.maxTaskTimeoutSeconds) {
+        throw new Error("defaultTaskTimeoutSeconds cannot exceed maxTaskTimeoutSeconds");
+    }
+    if (!Number.isInteger(config.watcherStaleSeconds) || config.watcherStaleSeconds < 5 || config.watcherStaleSeconds > 3600) {
+        throw new Error("watcherStaleSeconds must be an integer from 5 to 3600");
+    }
+    if (config.toolProfile !== undefined && config.toolProfile !== "full" && config.toolProfile !== "chatgpt_core") {
+        throw new Error('toolProfile must be "full" or "chatgpt_core"');
+    }
+    return {
+        ...config,
+        workspaceRoot: resolve(config.workspaceRoot),
+    };
+}

package/dist/doctor.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * PatchWarden Doctor — read-only diagnostic checks
+ *
+ * Usage: node dist/doctor.js  or  npm run doctor
+ *
+ * Checks 15 aspects of the environment and configuration.
+ * Never modifies files, installs dependencies, or starts services.
+ */
+export {};

package/dist/doctor.js

@@ -0,0 +1,388 @@
+#!/usr/bin/env node
+/**
+ * PatchWarden Doctor — read-only diagnostic checks
+ *
+ * Usage: node dist/doctor.js  or  npm run doctor
+ *
+ * Checks 15 aspects of the environment and configuration.
+ * Never modifies files, installs dependencies, or starts services.
+ */
+import { existsSync, statSync, readFileSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { isAbsolute, resolve, normalize, join } from "node:path";
+import { execSync } from "node:child_process";
+import { createServer } from "node:net";
+import { getConfig } from "./config.js";
+import { guardPath, guardWorkspacePath } from "./security/pathGuard.js";
+import { isSensitivePath } from "./security/sensitiveGuard.js";
+import { guardPlanContent } from "./security/planGuard.js";
+import { TASK_READ_ONLY_FILES } from "./tools/getTaskFile.js";
+import { getToolDefs } from "./tools/registry.js";
+import { CHATGPT_CORE_TOOL_NAMES, selectToolsForProfile } from "./tools/toolCatalog.js";
+import { PATCHWARDEN_VERSION } from "./version.js";
+// ── State ──────────────────────────────────────────────────────────
+let ok = 0;
+let warn = 0;
+let fail = 0;
+const results = [];
+function check(name, condition, detail) {
+    if (condition) {
+        results.push(`[OK]   ${name}`);
+        ok++;
+    }
+    else {
+        results.push(`[FAIL] ${name}${detail ? " — " + detail : ""}`);
+        fail++;
+    }
+}
+function warnCheck(name, condition, detail) {
+    if (condition) {
+        results.push(`[OK]   ${name}`);
+        ok++;
+    }
+    else {
+        results.push(`[WARN] ${name}${detail ? " — " + detail : ""}`);
+        warn++;
+    }
+}
+function cmd(cmdStr) {
+    try {
+        return execSync(cmdStr, {
+            encoding: "utf-8",
+            timeout: 5000,
+            stdio: ["ignore", "pipe", "ignore"], // suppress stdin and stderr
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+// ══════════════════════════════════════════════════════════════════
+async function main() {
+    console.log("PatchWarden Doctor\n");
+    // 1. Node version
+    const nodeVer = process.version;
+    const nodeMajor = parseInt(nodeVer.slice(1).split(".")[0]);
+    check("Node.js version", nodeMajor >= 18, nodeMajor < 18 ? `v${nodeVer} — need >=18.0.0` : `v${nodeVer}`);
+    // 2. npm
+    const npmVer = cmd("npm --version");
+    check("npm available", npmVer !== "", npmVer || "npm not found in PATH");
+    // 3. Git
+    const gitVer = cmd("git --version");
+    warnCheck("Git available", gitVer !== "", gitVer || "git not found — runner git.diff will not work");
+    // 4. Config file exists
+    const configPaths = [
+        resolve(process.cwd(), "patchwarden.config.json"),
+        process.env.PATCHWARDEN_CONFIG || "",
+    ].filter(Boolean);
+    let configPathUsed = "";
+    for (const p of configPaths) {
+        if (existsSync(p)) {
+            configPathUsed = p;
+            break;
+        }
+    }
+    check("Config file exists", configPathUsed !== "", configPathUsed
+        ? configPathUsed
+        : 'Create one: cp examples/config.example.json patchwarden.config.json');
+    // 5. PATCHWARDEN_CONFIG env
+    if (process.env.PATCHWARDEN_CONFIG) {
+        results.push(`[OK]   PATCHWARDEN_CONFIG = ${process.env.PATCHWARDEN_CONFIG}`);
+        ok++;
+    }
+    else {
+        results.push(`[OK]   PATCHWARDEN_CONFIG not set (using default: patchwarden.config.json)`);
+        ok++;
+    }
+    // Load config (may fail)
+    let config = null;
+    try {
+        config = getConfig();
+        check("Config parseable", true, `workspaceRoot: ${config.workspaceRoot}`);
+    }
+    catch (err) {
+        check("Config parseable", false, err instanceof Error ? err.message : String(err));
+    }
+    // 6. workspaceRoot checks
+    if (config) {
+        const ws = normalize(resolve(config.workspaceRoot));
+        const exists = existsSync(ws);
+        check("workspaceRoot exists", exists, ws);
+        let isDir = false;
+        try {
+            isDir = statSync(ws).isDirectory();
+        }
+        catch { }
+        check("workspaceRoot is directory", isDir, ws);
+        // Danger checks
+        const dangerousRoots = [
+            { pattern: /^[A-Za-z]:\\?$/, label: "drive root" },
+            { pattern: /\\Users\\[^\\]+$/, label: "user home directory" },
+            { pattern: /\\Desktop$/, label: "Desktop" },
+            { pattern: /\\Downloads$/, label: "Downloads" },
+            { pattern: /\\Documents$/, label: "Documents" },
+        ];
+        for (const { pattern, label } of dangerousRoots) {
+            const matches = pattern.test(ws);
+            if (matches) {
+                results.push(`[WARN] workspaceRoot is ${label}: ${ws} — consider narrowing to a project directory`);
+                warn++;
+            }
+        }
+    }
+    // 7. Path guard test
+    if (config) {
+        try {
+            guardPath("test-file.txt", config.workspaceRoot);
+            results.push(`[OK]   pathGuard allows workspace-internal path`);
+            ok++;
+        }
+        catch (err) {
+            results.push(`[FAIL] pathGuard rejects internal path: ${err instanceof Error ? err.message : String(err)}`);
+            fail++;
+        }
+        try {
+            guardPath("../outside", config.workspaceRoot);
+            results.push(`[FAIL] pathGuard should have blocked ../escape`);
+            fail++;
+        }
+        catch {
+            results.push(`[OK]   pathGuard blocks ../ path escape`);
+            ok++;
+        }
+        try {
+            const relativeRepo = guardWorkspacePath(".", config.workspaceRoot);
+            const absoluteRepo = guardWorkspacePath(config.workspaceRoot, config.workspaceRoot);
+            check("repo_path resolver supports relative and absolute paths", relativeRepo === absoluteRepo, relativeRepo);
+        }
+        catch (error) {
+            check("repo_path resolver supports relative and absolute paths", false, error instanceof Error ? error.message : String(error));
+        }
+    }
+    // 8. Sensitive file guard test
+    const sensitivePaths = [".env", ".ssh/id_rsa", "token.json", "credentials"];
+    for (const sp of sensitivePaths) {
+        const blocked = isSensitivePath(sp);
+        if (blocked) {
+            results.push(`[OK]   sensitiveGuard blocks "${sp}"`);
+            ok++;
+        }
+        else {
+            results.push(`[FAIL] sensitiveGuard does NOT block "${sp}"`);
+            fail++;
+        }
+    }
+    try {
+        guardPlanContent("Normal build plan", "Run npm test, npm run lint, release check, and npm run dist.");
+        results.push("[OK]   save_plan allows normal development plans");
+        ok++;
+    }
+    catch {
+        results.push("[FAIL] save_plan incorrectly blocks a normal development plan");
+        fail++;
+    }
+    try {
+        guardPlanContent("Unsafe plan", "Read the .env access token and export it.");
+        results.push("[FAIL] save_plan security rule did not block credential access");
+        fail++;
+    }
+    catch {
+        results.push("[OK]   save_plan security rules loaded");
+        ok++;
+    }
+    const requiredReadOnlyFiles = ["status.json", "result.md", "result.json", "diff.patch", "file-stats.json", "test.log", "verify.json"];
+    check("Read-only task artifact allowlist", requiredReadOnlyFiles.every((name) => TASK_READ_ONLY_FILES.includes(name)), requiredReadOnlyFiles.join(", "));
+    const packageJson = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8"));
+    check("Server version matches package.json", packageJson.version === PATCHWARDEN_VERSION, `${PATCHWARDEN_VERSION} vs ${packageJson.version}`);
+    check("Manifest preflight script exists", existsSync(resolve(process.cwd(), "scripts/mcp-manifest-check.js")), "scripts/mcp-manifest-check.js");
+    const previousProfile = process.env.PATCHWARDEN_TOOL_PROFILE;
+    try {
+        process.env.PATCHWARDEN_TOOL_PROFILE = "full";
+        const fullTools = getToolDefs();
+        const coreTools = selectToolsForProfile(fullTools, "chatgpt_core");
+        const createSchema = coreTools.find((tool) => tool.name === "create_task")?.inputSchema;
+        const waitSchema = coreTools.find((tool) => tool.name === "wait_for_task")?.inputSchema;
+        check("Full tool profile exposes 22 tools", fullTools.length === 22, `${fullTools.length} tools`);
+        check(`chatgpt_core profile exposes the exact ${CHATGPT_CORE_TOOL_NAMES.length}-tool manifest`, JSON.stringify(coreTools.map((tool) => tool.name)) === JSON.stringify(CHATGPT_CORE_TOOL_NAMES), coreTools.map((tool) => tool.name).join(", "));
+        check("Core task schemas expose inline_plan, verify_commands, and wait aliases", Boolean(createSchema?.properties?.inline_plan &&
+            createSchema?.properties?.verify_commands &&
+            waitSchema?.properties?.timeout_seconds &&
+            waitSchema?.properties?.wait_seconds));
+    }
+    finally {
+        if (previousProfile === undefined)
+            delete process.env.PATCHWARDEN_TOOL_PROFILE;
+        else
+            process.env.PATCHWARDEN_TOOL_PROFILE = previousProfile;
+    }
+    // 9. HTTP port check
+    const httpPort = config?.http?.port || 7331;
+    try {
+        const server = createServer();
+        await new Promise((resolvePort, rejectPort) => {
+            server.once("error", rejectPort);
+            server.listen(httpPort, "127.0.0.1", () => {
+                server.close();
+                resolvePort();
+            });
+        });
+        results.push(`[OK]   HTTP port ${httpPort} is free`);
+        ok++;
+    }
+    catch {
+        results.push(`[WARN] HTTP port ${httpPort} is in use — change http.port in config`);
+        warn++;
+    }
+    // 10-12. dist file checks
+    const distChecks = [
+        { file: "dist/index.js", label: "stdio MCP entry", cmd: "npm run build" },
+        { file: "dist/httpServer.js", label: "HTTP MCP entry", cmd: "npm run build" },
+        { file: "dist/runner/watch.js", label: "watcher entry (npm run watch)", cmd: "npm run build" },
+    ];
+    for (const { file, label, cmd: buildCmd } of distChecks) {
+        check(`${label} exists`, existsSync(resolve(process.cwd(), file)), existsSync(resolve(process.cwd(), file)) ? file : `Missing — run: ${buildCmd}`);
+    }
+    // New tool registrations check
+    const newTools = [
+        "listTasks",
+        "listAgents",
+        "cancelTask",
+        "killTask",
+        "retryTask",
+        "getTaskProgress",
+        "getTaskSummary",
+        "waitForTask",
+        "getTaskStdoutTail",
+        "healthCheck",
+        "auditTask",
+    ];
+    for (const t of newTools) {
+        const compiled = resolve(process.cwd(), "dist/tools", `${t}.js`);
+        check(`Tool module: ${t}`, existsSync(compiled), existsSync(compiled) ? "compiled" : "missing");
+    }
+    // Task directory writable
+    if (config) {
+        const tasksDir = resolve(config.workspaceRoot, config.tasksDir);
+        try {
+            mkdirSync(tasksDir, { recursive: true });
+            const testFile = join(tasksDir, ".doctor-write-test");
+            writeFileSync(testFile, "ok", "utf-8");
+            rmSync(testFile);
+            check("Task directory writable", true, tasksDir);
+            const sampleTaskDir = join(tasksDir, ".doctor-sample-task");
+            mkdirSync(sampleTaskDir, { recursive: true });
+            const sampleStatus = join(sampleTaskDir, "status.json");
+            writeFileSync(sampleStatus, JSON.stringify({ status: "doctor" }), "utf-8");
+            const sampleReadable = JSON.parse(readFileSync(sampleStatus, "utf-8")).status === "doctor";
+            rmSync(sampleTaskDir, { recursive: true, force: true });
+            check("Example task directory read/write", sampleReadable, sampleTaskDir);
+        }
+        catch {
+            warnCheck("Task directory writable", false, tasksDir);
+        }
+        // workspaceRoot writable
+        try {
+            const testFile = resolve(config.workspaceRoot, ".doctor-write-test");
+            writeFileSync(testFile, "ok", "utf-8");
+            rmSync(testFile);
+            check("workspaceRoot writable", true, config.workspaceRoot);
+        }
+        catch {
+            warnCheck("workspaceRoot writable", false, config.workspaceRoot);
+        }
+    }
+    if (config) {
+        check("Watcher stale threshold is valid", config.watcherStaleSeconds >= 5 && config.watcherStaleSeconds <= 3600, `${config.watcherStaleSeconds}s`);
+    }
+    // allowedTestCommands has npm test
+    if (config) {
+        const hasNpmTest = config.allowedTestCommands.some((c) => c === "npm test" || c === "npm run test");
+        warnCheck("allowedTestCommands includes npm test", hasNpmTest, hasNpmTest ? "present" : "npm test is missing — add it to allowedTestCommands");
+    }
+    if (config) {
+        check("Task timeout defaults are valid", config.defaultTaskTimeoutSeconds > 0 && config.defaultTaskTimeoutSeconds <= config.maxTaskTimeoutSeconds, `default ${config.defaultTaskTimeoutSeconds}s, max ${config.maxTaskTimeoutSeconds}s`);
+    }
+    // 13. Agent command check
+    if (config) {
+        const agents = config.agents || {};
+        for (const [name, agentCfg] of Object.entries(agents)) {
+            const cmdName = agentCfg.command;
+            const looksLikePath = isAbsolute(cmdName) || cmdName.includes("/") || cmdName.includes("\\");
+            if (looksLikePath) {
+                const agentExists = existsSync(cmdName);
+                warnCheck(`Agent "${name}" command available`, agentExists, agentExists ? `Found: ${cmdName}` : `"${cmdName}" does not exist — agent tasks will fail`);
+                continue;
+            }
+            // Platform-appropriate lookup: 'where' on Windows, 'command -v' on Unix
+            const isWin = process.platform === "win32";
+            const lookupCmd = isWin ? `where ${cmdName}` : `command -v ${cmdName}`;
+            const fallbackCmd = isWin ? `command -v ${cmdName}` : `which ${cmdName}`;
+            const found = cmd(lookupCmd) || cmd(fallbackCmd);
+            warnCheck(`Agent "${name}" command available`, found !== "", found ? `Found: ${found.split("\n")[0]}` : `"${cmdName}" not in PATH — agent tasks will fail`);
+        }
+    }
+    // 14. allowedTestCommands safety check
+    if (config) {
+        const testCmds = config.allowedTestCommands || [];
+        check("allowedTestCommands is non-empty", testCmds.length > 0, testCmds.length > 0 ? `${testCmds.length} commands` : "No test commands configured");
+        const dangerous = ["rm -rf", "del /s", "format", "shutdown", "curl |", "wget |"];
+        for (const cmdStr of testCmds) {
+            for (const danger of dangerous) {
+                if (cmdStr.toLowerCase().includes(danger)) {
+                    results.push(`[WARN] allowedTestCommands contains dangerous pattern: "${cmdStr}"`);
+                    warn++;
+                }
+            }
+        }
+    }
+    // 15. Tunnel example files check
+    const tunnelFiles = [
+        "examples/openai-tunnel/README.md",
+        "examples/openai-tunnel/tunnel-client.example.yaml",
+        "examples/openai-tunnel/chatgpt-test-prompt.md",
+    ];
+    for (const tf of tunnelFiles) {
+        const full = resolve(process.cwd(), tf);
+        const exists = existsSync(full);
+        check(`Tunnel example: ${tf}`, exists, exists ? "present" : "missing");
+        // Check for leaked secrets in example files
+        if (exists) {
+            const content = readFileSync(full, "utf-8");
+            // Only flag actual key-value assignments, not comments/mentions
+            const leaked = /(?:api_key|sk-[a-zA-Z0-9]{10,}|token\s*[:=]\s*\S{4,}|secret\s*[:=]\s*\S{4,}|password\s*[:=]\s*\S{4,})/gi.test(
+            // Strip comment lines first
+            content.split("\n").filter(l => !l.trim().startsWith("#") && !l.trim().startsWith("//")).join("\n"));
+            if (leaked) {
+                results.push(`[WARN] ${tf} may contain secrets`);
+                warn++;
+            }
+            else {
+                results.push(`[OK]   ${tf} — no real secrets`);
+                ok++;
+            }
+        }
+    }
+    // ══════════════════════════════════════════════════════════════════
+    // Summary
+    // ══════════════════════════════════════════════════════════════════
+    console.log(results.join("\n"));
+    console.log(`\n${"=".repeat(50)}`);
+    console.log(`OK: ${ok}  WARN: ${warn}  FAIL: ${fail}`);
+    console.log(`${"=".repeat(50)}`);
+    if (fail > 0) {
+        console.log("\n❌ Doctor found issues that need attention.");
+        console.log("   Fix FAIL items before using PatchWarden.");
+        process.exit(1);
+    }
+    else if (warn > 0) {
+        console.log("\n⚠️  Doctor found warnings — review before production use.");
+        process.exit(0);
+    }
+    else {
+        console.log("\n✅ All checks passed.");
+        process.exit(0);
+    }
+} // end async main
+main().catch((err) => {
+    console.error("Doctor crashed:", err);
+    process.exit(1);
+});

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class PatchWardenError extends Error {
+    readonly reason: string;
+    readonly suggestion: string;
+    readonly blocked: boolean;
+    readonly details: Record<string, unknown>;
+    constructor(reason: string, message: string, suggestion: string, blocked?: boolean, details?: Record<string, unknown>);
+}
+export declare function errorPayload(error: unknown): {
+    blocked: boolean;
+    reason: string;
+    rule_id: string;
+    error: string;
+    suggestion: string;
+} | {
+    error: string;
+};

package/dist/errors.js

@@ -0,0 +1,27 @@
+export class PatchWardenError extends Error {
+    reason;
+    suggestion;
+    blocked;
+    details;
+    constructor(reason, message, suggestion, blocked = true, details = {}) {
+        super(message);
+        this.reason = reason;
+        this.suggestion = suggestion;
+        this.blocked = blocked;
+        this.details = details;
+        this.name = "PatchWardenError";
+    }
+}
+export function errorPayload(error) {
+    if (error instanceof PatchWardenError) {
+        return {
+            blocked: error.blocked,
+            reason: error.reason,
+            rule_id: error.reason,
+            error: error.message,
+            suggestion: error.suggestion,
+            ...error.details,
+        };
+    }
+    return { error: error instanceof Error ? error.message : String(error) };
+}

package/dist/httpServer.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * PatchWarden MCP Server — HTTP (Streamable HTTP) transport
+ *
+ * Binds to 127.0.0.1 only. Never exposes to LAN or public internet.
+ * Use with OpenAI tunnel-client or ChatGPT Connector.
+ *
+ * Each HTTP request gets its own MCP Server + transport instance
+ * to avoid "Already connected" errors from reusing a single Server.
+ *
+ * Config options (in patchwarden.config.json):
+ *   httpPort: number (default 7331)
+ *
+ * Run: node dist/httpServer.js
+ *   or: npm run start:http
+ */
+export {};