patchwarden 0.4.0

package/scripts/watcher-supervisor-smoke.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from "node:child_process";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { setTimeout as sleep } from "node:timers/promises";
+import { fileURLToPath } from "node:url";
+
+if (process.platform !== "win32") {
+  console.log("ok - watcher supervisor smoke skipped outside Windows");
+  process.exit(0);
+}
+
+const root = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const temp = mkdtempSync(join(tmpdir(), "patchwarden-watcher-supervisor-"));
+const children = [];
+
+try {
+  await runScenario("owned watcher exit triggers a controlled restart", "exit_once", 1, 9_000, (state) => {
+    if (state.attempts < 2 || state.status.restart_attempts !== 1) {
+      throw new Error(`Expected one owned restart: ${JSON.stringify(state)}`);
+    }
+  });
+
+  await runScenario("frozen owned heartbeat reaches the restart limit", "freeze", 1, 22_000, (state) => {
+    if (state.status.status !== "restart_limit_reached" || state.status.restart_attempts !== 2) {
+      throw new Error(`Expected restart_limit_reached: ${JSON.stringify(state)}`);
+    }
+  });
+
+  await runExternalScenario();
+  console.log("ok - watcher supervisor handles exit, stale heartbeat, retry limit, and external ownership");
+} finally {
+  for (const child of children) {
+    if (child.exitCode === null) child.kill("SIGKILL");
+  }
+  rmSync(temp, { recursive: true, force: true });
+}
+
+async function runScenario(label, mode, maxRestarts, lifetimeMs, assertState) {
+  const fixture = createFixture(label.replace(/[^a-z0-9]+/gi, "-"));
+  const result = runLauncher(fixture, mode, maxRestarts, lifetimeMs);
+  if (result.error && result.error.code === "ETIMEDOUT") throw result.error;
+  if (!existsSync(fixture.watcherStatusPath)) {
+    throw new Error(`Watcher status was not created. exit=${result.status} stdout=${result.stdout} stderr=${result.stderr}`);
+  }
+  const status = readJson(fixture.watcherStatusPath);
+  const attempts = Number(readFileSync(fixture.watcherAttemptPath, "utf-8")) || 0;
+  assertState({ status, attempts, stdout: result.stdout, stderr: result.stderr });
+}
+
+async function runExternalScenario() {
+  const fixture = createFixture("external");
+  const env = fixtureEnv(fixture, "healthy", 7_000);
+  const external = spawn(process.execPath, [fixture.watcherPath], {
+    cwd: fixture.project,
+    env: {
+      ...env,
+      PATCHWARDEN_CONFIG: fixture.configPath,
+      PATCHWARDEN_WATCHER_INSTANCE_ID: "external-fixture",
+      PATCHWARDEN_WATCHER_LAUNCHER_PID: "999999",
+    },
+    stdio: "ignore",
+  });
+  children.push(external);
+  for (let attempt = 0; attempt < 40 && !existsSync(fixture.heartbeatPath); attempt++) await sleep(100);
+  if (!existsSync(fixture.heartbeatPath)) throw new Error("External watcher heartbeat was not created");
+
+  const result = runLauncher(fixture, "healthy", 1, 7_000);
+  if (result.error && result.error.code === "ETIMEDOUT") throw result.error;
+  if (external.exitCode !== null) throw new Error("Launcher stopped an external watcher");
+  const status = readJson(fixture.watcherStatusPath);
+  if (status.managed !== false || status.status !== "external_healthy") {
+    throw new Error(`External watcher ownership mismatch: ${JSON.stringify(status)}`);
+  }
+}
+
+function createFixture(name) {
+  const project = join(temp, name, "patchwarden-fixture");
+  const scripts = join(project, "scripts");
+  const runner = join(project, "dist", "runner");
+  const workspace = join(project, "workspace");
+  mkdirSync(scripts, { recursive: true });
+  mkdirSync(runner, { recursive: true });
+  mkdirSync(workspace, { recursive: true });
+  cpSync(join(root, "scripts", "start-patchwarden-tunnel.ps1"), join(scripts, "start-patchwarden-tunnel.ps1"));
+  writeFileSync(join(scripts, "patchwarden-mcp-stdio.cmd"), "@echo off\r\nexit /b 0\r\n", "utf-8");
+  const manifestFixture = JSON.stringify({
+    ok: true,
+    server_version: "0.4.0",
+    schema_epoch: "2026-06-20-v2",
+    tool_profile: "chatgpt_core",
+    tool_count: 16,
+    tool_names: [],
+    tool_manifest_sha256: "a".repeat(64),
+  });
+  writeFileSync(join(scripts, "mcp-manifest-check.js"), `process.stdout.write(${JSON.stringify(manifestFixture)});\n`, "utf-8");
+  writeFileSync(join(project, "dist", "index.js"), "", "utf-8");
+  const watcherAttemptPath = join(project, "watcher-attempt.txt");
+  const watcherPath = join(runner, "watch.js");
+  writeFileSync(watcherPath, watcherFixtureSource(watcherAttemptPath), "utf-8");
+  const configPath = join(project, "patchwarden.config.json");
+  writeFileSync(configPath, JSON.stringify({
+    workspaceRoot: workspace,
+    plansDir: ".patchwarden/plans",
+    tasksDir: ".patchwarden/tasks",
+    watcherStaleSeconds: 5,
+    agents: {},
+    allowedTestCommands: [],
+    maxReadFileBytes: 200000,
+    defaultTaskTimeoutSeconds: 30,
+    maxTaskTimeoutSeconds: 60,
+  }, null, 2), "utf-8");
+  const mockJs = join(project, "mock-tunnel-client.js");
+  const mockCmd = join(project, "mock-tunnel-client.cmd");
+  writeFileSync(mockCmd, `@echo off\r\nnode "${mockJs}" %*\r\n`, "utf-8");
+  writeFileSync(mockJs, tunnelFixtureSource(), "utf-8");
+  const localAppData = join(project, "localappdata");
+  return {
+    project,
+    configPath,
+    watcherPath,
+    watcherAttemptPath,
+    heartbeatPath: join(workspace, ".patchwarden", "watcher-heartbeat.json"),
+    watcherStatusPath: join(localAppData, "patchwarden", "runtime", "watcher-status.json"),
+    mockCmd,
+    localAppData,
+    appData: join(project, "appdata"),
+  };
+}
+
+function runLauncher(fixture, mode, maxRestarts, lifetimeMs) {
+  return spawnSync("powershell.exe", [
+    "-NoProfile", "-ExecutionPolicy", "Bypass", "-File", join(fixture.project, "scripts", "start-patchwarden-tunnel.ps1"),
+    "-TunnelId", "tunnel_watcher_fixture",
+    "-TunnelClientExe", fixture.mockCmd,
+    "-ProxyUrl", "http://127.0.0.1:1",
+    "-MaxReconnectAttempts", "1",
+    "-WatcherMaxRestartAttempts", String(maxRestarts),
+    "-WatcherHealthyResetSeconds", "60",
+  ], {
+    cwd: fixture.project,
+    env: fixtureEnv(fixture, mode, lifetimeMs),
+    encoding: "utf-8",
+    timeout: lifetimeMs + 20_000,
+  });
+}
+
+function fixtureEnv(fixture, mode, lifetimeMs) {
+  return {
+    ...process.env,
+    APPDATA: fixture.appData,
+    LOCALAPPDATA: fixture.localAppData,
+    CONTROL_PLANE_API_KEY: "watcher-supervisor-smoke-secret",
+    WATCHER_FIXTURE_MODE: mode,
+    TUNNEL_FIXTURE_LIFETIME_MS: String(lifetimeMs),
+  };
+}
+
+function watcherFixtureSource(attemptPath) {
+  return `
+const fs=require('fs');const path=require('path');
+let attempt=0;try{attempt=Number(fs.readFileSync(${JSON.stringify(attemptPath)},'utf8'))||0}catch{}
+attempt++;fs.writeFileSync(${JSON.stringify(attemptPath)},String(attempt));
+const cfg=JSON.parse(fs.readFileSync(process.env.PATCHWARDEN_CONFIG,'utf8'));
+const heartbeat=path.join(cfg.workspaceRoot,'.patchwarden','watcher-heartbeat.json');fs.mkdirSync(path.dirname(heartbeat),{recursive:true});
+const write=()=>{const temp=heartbeat+'.'+process.pid+'.tmp';fs.writeFileSync(temp,JSON.stringify({status:'running',pid:process.pid,instance_id:process.env.PATCHWARDEN_WATCHER_INSTANCE_ID,launcher_pid:Number(process.env.PATCHWARDEN_WATCHER_LAUNCHER_PID),started_at:new Date().toISOString(),last_heartbeat_at:new Date().toISOString()}));fs.renameSync(temp,heartbeat)};
+write();const mode=process.env.WATCHER_FIXTURE_MODE;
+if(mode==='exit_once'&&attempt===1)setTimeout(()=>process.exit(7),100);
+else if(mode==='freeze')setInterval(()=>{},1000);
+else setInterval(write,250);
+`;
+}
+
+function tunnelFixtureSource() {
+  return `
+const fs=require('fs');const args=process.argv.slice(2);const command=args[0]||'';
+const flag=(name)=>{const i=args.indexOf(name);return i>=0?args[i+1]:''};
+if(command==='init'||command==='doctor'){console.log('{}');process.exit(0)}
+if(command==='health'){console.log(JSON.stringify({healthz:{ok:true},readyz:{ok:true}}));process.exit(0)}
+if(command==='run'){const url=flag('--health.url-file'),pid=flag('--pid.file');fs.mkdirSync(require('path').dirname(url),{recursive:true});fs.writeFileSync(url,'http://127.0.0.1:18889');fs.writeFileSync(pid,String(process.pid));setTimeout(()=>process.exit(9),Number(process.env.TUNNEL_FIXTURE_LIFETIME_MS)||9000)}
+`;
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, "utf-8").replace(/^\uFEFF/, ""));
+}

package/src/config.ts

@@ -0,0 +1,165 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+
+// ── Type definitions ──────────────────────────────────────────────
+
+export interface AgentConfig {
+  command: string;
+  args: string[];
+}
+
+export interface PatchWardenConfig {
+  workspaceRoot: string;
+  plansDir: string;
+  tasksDir: string;
+  agents: Record<string, AgentConfig>;
+  allowedTestCommands: string[];
+  maxReadFileBytes: number;
+  defaultTaskTimeoutSeconds: number;
+  maxTaskTimeoutSeconds: number;
+  watcherStaleSeconds: number;
+  toolProfile?: "full" | "chatgpt_core";
+  repoAliases?: Record<string, string>;
+}
+
+// ── Defaults ──────────────────────────────────────────────────────
+
+const DEFAULT_CONFIG: PatchWardenConfig = {
+  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: PatchWardenConfig | null = null;
+
+export function loadConfig(configPath?: string): PatchWardenConfig {
+  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 } as PatchWardenConfig);
+        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(): PatchWardenConfig {
+  if (!_config) return loadConfig();
+  return _config;
+}
+
+/** Resolve workspaceRoot: expand relative paths */
+export function resolveWorkspaceRoot(config: PatchWardenConfig): string {
+  return resolve(config.workspaceRoot);
+}
+
+/** Resolve plans/tasks dirs relative to workspaceRoot */
+export function getPlansDir(config: PatchWardenConfig): string {
+  return resolve(config.workspaceRoot, config.plansDir);
+}
+
+export function getTasksDir(config: PatchWardenConfig): string {
+  return resolve(config.workspaceRoot, config.tasksDir);
+}
+
+function stripBom(value: string): string {
+  return value.charCodeAt(0) === 0xfeff ? value.slice(1) : value;
+}
+
+function normalizeConfig(config: PatchWardenConfig): PatchWardenConfig {
+  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),
+  };
+}