patchwarden 1.5.0 → 1.6.1

package/dist/control/shared.js

@@ -0,0 +1,341 @@
+/**
+ * PatchWarden Control Center — shared infrastructure.
+ *
+ * Holds the fault-tolerant config bootstrap, path constants, the in-memory
+ * control token, port resolution, and the generic HTTP/file helpers reused by
+ * every route module. Importing this module performs the same bootstrap side
+ * effects the original monolithic controlCenter.ts did (config load, token
+ * generation, port resolution) so that a single import wires up the runtime.
+ */
+import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash, randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { loadConfig } from "../config.js";
+import { logger } from "../logging.js";
+import { readTextFilePrefixSync, readTextFileTailLinesSync } from "../utils/boundedFile.js";
+import { redactSensitiveContent, redactSensitiveValue } from "../security/contentRedaction.js";
+import { guardPath } from "../security/pathGuard.js";
+// ── Paths ─────────────────────────────────────────────────────────
+export const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
+export const uiRoot = join(projectRoot, "ui");
+export const manageScriptPath = join(projectRoot, "scripts", "control", "manage-patchwarden.ps1");
+function resolveActiveConfigPath() {
+    if (process.env.PATCHWARDEN_CONFIG)
+        return resolve(process.env.PATCHWARDEN_CONFIG);
+    for (const name of ["patchwarden.config.json", ".patchwarden.json"]) {
+        const candidate = resolve(process.cwd(), name);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return resolve(process.cwd(), "patchwarden.config.json");
+}
+export const activeConfigPath = resolveActiveConfigPath();
+export const configIdentitySha256 = createHash("sha256")
+    .update(process.platform === "win32" ? activeConfigPath.toLowerCase() : activeConfigPath)
+    .digest("hex");
+export const PAGE_ALIASES = {
+    "/getting-started.html": "pages/getting-started.html",
+    "/dashboard.html": "pages/dashboard.html",
+    "/tasks.html": "pages/tasks.html",
+    "/workspace.html": "pages/workspace.html",
+    "/audit.html": "pages/audit.html",
+    "/task-detail.html": "pages/task-detail.html",
+    "/direct-sessions.html": "pages/direct-sessions.html",
+    "/logs.html": "pages/logs.html",
+    "/settings.html": "pages/settings.html",
+};
+// ── Config (fault-tolerant bootstrap) ─────────────────────────────
+export function createFallbackConfig() {
+    return {
+        // Fault-tolerant dashboard mode must not widen a rejected workspace to the
+        // caller's cwd (which could be a home or drive root). The package root is
+        // bounded and all execution capabilities remain disabled below.
+        workspaceRoot: projectRoot,
+        plansDir: ".patchwarden/plans",
+        tasksDir: ".patchwarden/tasks",
+        assessmentsDir: ".patchwarden/assessments",
+        assessmentTtlSeconds: 3600,
+        agents: {},
+        allowedTestCommands: [],
+        repoAllowedTestCommands: {},
+        maxReadFileBytes: 200_000,
+        defaultTaskTimeoutSeconds: 900,
+        maxTaskTimeoutSeconds: 3600,
+        watcherStaleSeconds: 30,
+        toolProfile: "full",
+        enableDirectProfile: false,
+        directSessionsDir: ".patchwarden/direct-sessions",
+        directSessionTtlSeconds: 3600,
+        directMaxPatchBytes: 200_000,
+        directMaxFileBytes: 500_000,
+    };
+}
+export let config;
+try {
+    config = loadConfig();
+}
+catch (err) {
+    logger.warn(`[control-center] WARNING: Failed to load config. Using fallback defaults.`, {
+        error: errorMessage(err),
+    });
+    config = createFallbackConfig();
+}
+// ── Control token (in-memory only) ────────────────────────────────
+export const controlToken = randomUUID();
+// ── Port resolution ───────────────────────────────────────────────
+export function resolvePort() {
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--port" && i + 1 < argv.length) {
+            const n = parseInt(argv[i + 1], 10);
+            if (Number.isFinite(n) && n >= 0)
+                return n;
+        }
+        const m = arg.match(/^--port=(\d+)$/);
+        if (m) {
+            const n = parseInt(m[1], 10);
+            if (Number.isFinite(n) && n >= 0)
+                return n;
+        }
+    }
+    const envPort = parseInt(process.env.PATCHWARDEN_CONTROL_PORT || "", 10);
+    if (Number.isFinite(envPort) && envPort >= 0)
+        return envPort;
+    return 8090;
+}
+export const port = resolvePort();
+export const host = "127.0.0.1";
+// Core/Direct probe base URLs — overridable for tests so the smoke test does
+// not depend on the real 8080/8081 ports being free on the host.
+export const CORE_BASE_URL = process.env.PATCHWARDEN_CORE_URL || "http://127.0.0.1:8080";
+export const DIRECT_BASE_URL = process.env.PATCHWARDEN_DIRECT_URL || "http://127.0.0.1:8081";
+export const CONTROL_CENTER_FAVICON = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <rect width="64" height="64" rx="14" fill="#0a0e14"/>
+  <path d="M32 52s17-8 17-27V14L32 8 15 14v11c0 19 17 27 17 27z" fill="#111820" stroke="#2dd4a8" stroke-width="4" stroke-linejoin="round"/>
+  <path d="M24 32l6 6 12-14" fill="none" stroke="#2dd4a8" stroke-width="5" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>`;
+// ── Helpers ───────────────────────────────────────────────────────
+export function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+export function getRuntimeRoot(direct) {
+    const base = process.platform === "win32" && process.env.LOCALAPPDATA
+        ? join(process.env.LOCALAPPDATA, "patchwarden")
+        : join(homedir(), ".patchwarden");
+    return join(base, direct ? "runtime-direct" : "runtime");
+}
+export function getControlCenterLogDir() {
+    // Test/local override: when set to an absolute path, use it directly so the
+    // smoke test can redirect status/events/log files into a sandbox-writable
+    // directory under the project root instead of LOCALAPPDATA.
+    const override = process.env.PATCHWARDEN_CONTROL_LOG_DIR;
+    if (override && isAbsolute(override))
+        return override;
+    const base = process.platform === "win32" && process.env.LOCALAPPDATA
+        ? join(process.env.LOCALAPPDATA, "patchwarden")
+        : join(homedir(), ".patchwarden");
+    return join(base, "control-center");
+}
+// Status + events files live alongside the control-center logs so the launcher
+// can discover a running instance without probing the port blindly.
+export const controlCenterStatusPath = join(getControlCenterLogDir(), "control-center-status.json");
+export const controlCenterEventsPath = join(getControlCenterLogDir(), "control-center-events.jsonl");
+export const MAX_EVENT_LINES = 2000;
+export const ALLOWED_LOG_TAILS = new Set([100, 300, 1000]);
+export function resolveTailParam(value) {
+    if (value === null)
+        return 100;
+    const n = parseInt(value, 10);
+    if (Number.isFinite(n) && ALLOWED_LOG_TAILS.has(n))
+        return n;
+    return 100;
+}
+export const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".svg": "image/svg+xml",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".map": "application/json; charset=utf-8",
+    ".txt": "text/plain; charset=utf-8",
+};
+export function sendJson(res, status, body) {
+    let payload;
+    try {
+        payload = JSON.stringify(body);
+    }
+    catch (err) {
+        payload = JSON.stringify({ error: `serialization failed: ${errorMessage(err)}` });
+        status = 500;
+    }
+    res.writeHead(status, {
+        "Content-Type": "application/json; charset=utf-8",
+        "Cache-Control": "no-store",
+        "X-Content-Type-Options": "nosniff",
+    });
+    res.end(payload);
+}
+export function readBody(req) {
+    return new Promise((resolve) => {
+        let total = 0;
+        const chunks = [];
+        let aborted = false;
+        req.on("data", (chunk) => {
+            if (aborted)
+                return;
+            total += chunk.length;
+            if (total > 1024 * 1024) {
+                aborted = true;
+                try {
+                    req.destroy();
+                }
+                catch { /* ignore */ }
+                resolve(null);
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on("end", () => {
+            if (aborted)
+                return;
+            if (chunks.length === 0) {
+                resolve(null);
+                return;
+            }
+            const text = Buffer.concat(chunks).toString("utf-8");
+            try {
+                resolve(JSON.parse(text));
+            }
+            catch {
+                resolve(null);
+            }
+        });
+        req.on("error", () => resolve(null));
+    });
+}
+export function readJsonFileSafe(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const size = statSync(filePath).size;
+        if (size > Math.max(1, config.maxReadFileBytes))
+            return null;
+        const raw = readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
+        return redactSensitiveValue(parsed).value;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPathInside(root, target) {
+    const rel = relative(root, target);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+export function readJsonFileSafeUnder(root, relPath) {
+    const base = resolve(root);
+    const target = resolve(base, relPath);
+    if (!isPathInside(base, target) || !existsSync(target))
+        return null;
+    try {
+        const realBase = realpathSync(base);
+        const realTarget = realpathSync(target);
+        if (!isPathInside(realBase, realTarget))
+            return null;
+        return readJsonFileSafe(realTarget);
+    }
+    catch {
+        return null;
+    }
+}
+export function readTextFileSafe(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const bounded = readTextFilePrefixSync(filePath, Math.max(1, config.maxReadFileBytes));
+        return redactSensitiveContent(bounded.content).content;
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve a Control Center artifact path and reject symlink/junction escapes. */
+export function guardControlPath(path, allowedPrefix) {
+    try {
+        return guardPath(path, config.workspaceRoot, allowedPrefix);
+    }
+    catch {
+        return null;
+    }
+}
+export function readFileTail(filePath, lines = 100) {
+    try {
+        return readTextFileTailLinesSync(filePath, lines);
+    }
+    catch {
+        return "";
+    }
+}
+export function findLatestLog(dir, pattern) {
+    if (!existsSync(dir))
+        return null;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return null;
+    }
+    const files = entries.filter((e) => e.isFile() && pattern.test(e.name));
+    if (files.length === 0)
+        return null;
+    let latestName = files[0].name;
+    let latestMtime = -1;
+    for (const f of files) {
+        try {
+            const m = statSync(join(dir, f.name)).mtimeMs;
+            if (m > latestMtime) {
+                latestMtime = m;
+                latestName = f.name;
+            }
+        }
+        catch {
+            /* keep current */
+        }
+    }
+    return join(dir, latestName);
+}
+/**
+ * Safely decode a path capture group, falling back to the raw value if the
+ * percent-encoding is malformed. Accepts the raw `RegExpMatchArray` or the
+ * sliced `string[]` params passed to a Route handler — both are readable by
+ * numeric index. Note: under `lib: es2024+` `RegExpMatchArray` is a tuple
+ * `[string, ...string[]]`, so we widen the parameter to `readonly string[]` to
+ * accept both shapes without forcing callers to cast.
+ */
+export function decodeParam(match, index) {
+    if (!match)
+        return "";
+    const raw = match[index] || "";
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+// Re-export widely-used node primitives so route modules have a single import
+// surface for path/delimiter helpers that are also needed alongside the shared
+// helpers above.
+export { delimiter, extname, join, resolve, isAbsolute, relative };

package/dist/controlCenter.d.ts

@@ -10,5 +10,11 @@
  *   or: npm run start:control
  *
  * Port override: PATCHWARDEN_CONTROL_PORT=<n>  or  --port <n>
+ *
+ * This file is a thin entry shell. All routing, middleware, and server
+ * lifecycle live in `src/control/` (server.ts, routes/*.ts, middleware/*.ts,
+ * shared.ts, runtime.ts). Importing `startServer` triggers the fault-tolerant
+ * config bootstrap, control-token generation, and port resolution as side
+ * effects of loading `shared.ts`.
  */
 export {};