patchwarden 0.4.0

package/src/httpServer.ts

@@ -0,0 +1,277 @@
+#!/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
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from "node:http";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { loadConfig, getTasksDir } from "./config.js";
+import { registerTools } from "./tools/registry.js";
+import { healthCheck } from "./tools/healthCheck.js";
+import { getToolCatalogSnapshot } from "./tools/registry.js";
+import { PATCHWARDEN_VERSION } from "./version.js";
+
+// ── Bootstrap ─────────────────────────────────────────────────────
+
+const config = loadConfig();
+const port = parseInt(process.env.PATCHWARDEN_HTTP_PORT || "") ||
+  (config as any).httpPort ||
+  7331;
+const host = "127.0.0.1";
+
+console.error(`[patchwarden-http] Workspace: ${config.workspaceRoot}`);
+console.error(`[patchwarden-http] Listening:  http://${host}:${port}/mcp`);
+console.error(`[patchwarden-http] ⚠️  Bound to 127.0.0.1 only — not exposed to network`);
+
+// ── Owner token (optional) ────────────────────────────────────────
+
+const httpCfg = (config as any).http || {};
+const ownerTokenEnv = httpCfg.ownerTokenEnv || "PATCHWARDEN_OWNER_TOKEN";
+const ownerToken = process.env[ownerTokenEnv] || "";
+
+if (ownerToken) {
+  console.error(`[patchwarden-http] 🔒 Owner token required (env: ${ownerTokenEnv})`);
+} else {
+  console.error(`[patchwarden-http] ⚠️  No owner token set — all local requests accepted`);
+}
+
+function checkOwnerToken(req: IncomingMessage): boolean {
+  if (!ownerToken) return true; // no token configured — allow all
+
+  const authHeader = req.headers["authorization"] || "";
+  const customHeader = req.headers["x-patchwarden-token"] || "";
+
+  if (authHeader.startsWith("Bearer ")) {
+    return authHeader.slice(7) === ownerToken;
+  }
+
+  if (typeof customHeader === "string" && customHeader.length > 0) {
+    return customHeader === ownerToken;
+  }
+
+  return false;
+}
+
+// ── Acceptance helpers ────────────────────────────────────────────
+
+function getAcceptancePath(taskId: string): string {
+  const tasksDir = getTasksDir(config);
+  return join(resolve(tasksDir, taskId), "acceptance.json");
+}
+
+function handleAcceptance(taskId: string, status: "accepted" | "rejected", body: string): object {
+  const filePath = getAcceptancePath(taskId);
+  const taskDir = join(resolve(getTasksDir(config), taskId));
+  if (!existsSync(taskDir)) {
+    throw Object.assign(new Error(`Task "${taskId}" not found.`), { statusCode: 404 });
+  }
+  let notes = "";
+  try {
+    const parsed = JSON.parse(body || "{}");
+    notes = String(parsed.notes || parsed.reason || "");
+  } catch {
+    // no body or invalid JSON — notes stays empty
+  }
+  const acceptance = {
+    status,
+    reviewed_at: new Date().toISOString(),
+    reviewer: "human",
+    notes,
+  };
+  writeFileSync(filePath, JSON.stringify(acceptance, null, 2), "utf-8");
+
+  // Also update the task's status.json with acceptance_status
+  const statusFile = join(taskDir, "status.json");
+  if (existsSync(statusFile)) {
+    try {
+      const current = JSON.parse(readFileSync(statusFile, "utf-8"));
+      current.acceptance_status = status;
+      current.acceptance_reviewed_at = acceptance.reviewed_at;
+      writeFileSync(statusFile, JSON.stringify(current, null, 2), "utf-8");
+    } catch {
+      // status.json update is best-effort
+    }
+  }
+  return acceptance;
+}
+
+function readAcceptance(taskId: string): object {
+  const filePath = getAcceptancePath(taskId);
+  if (!existsSync(filePath)) {
+    return { status: "pending", reviewed_at: null, reviewer: null, notes: null };
+  }
+  return JSON.parse(readFileSync(filePath, "utf-8"));
+}
+
+// ── Helpers ───────────────────────────────────────────────────────
+
+/** Create a fresh MCP Server with tools registered */
+function createMcpServer(): Server {
+  const server = new Server(
+    { name: "patchwarden", version: PATCHWARDEN_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  registerTools(server);
+  return server;
+}
+
+/** Handle one MCP request with its own server+transport lifecycle */
+async function handleMcpRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+  // Fresh instances per request — no shared state, no "already connected" errors
+  const mcpServer = createMcpServer();
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: undefined, // stateless
+  });
+
+  try {
+    await mcpServer.connect(transport);
+    await transport.handleRequest(req, res);
+  } catch (err) {
+    console.error("[patchwarden-http] Request error:", err);
+    if (!res.headersSent) {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Internal server error" }));
+    }
+  } finally {
+    // Always close to free resources
+    try {
+      await transport.close();
+    } catch {
+      // best effort
+    }
+    try {
+      await mcpServer.close();
+    } catch {
+      // best effort
+    }
+  }
+}
+
+// ── Parse URL for admin routes ────────────────────────────────────
+
+function parseAdminUrl(url: string) {
+  // Match: /admin/tasks/:id/accept, /admin/tasks/:id/reject, /admin/tasks/:id/acceptance
+  const acceptMatch = url.match(/^\/admin\/tasks\/(task_\w+)\/accept$/);
+  if (acceptMatch) return { taskId: acceptMatch[1], action: "accept" as const };
+  const rejectMatch = url.match(/^\/admin\/tasks\/(task_\w+)\/reject$/);
+  if (rejectMatch) return { taskId: rejectMatch[1], action: "reject" as const };
+  const readMatch = url.match(/^\/admin\/tasks\/(task_\w+)\/acceptance$/);
+  if (readMatch) return { taskId: readMatch[1], action: "get_acceptance" as const };
+  return null;
+}
+
+// ── HTTP server ───────────────────────────────────────────────────
+
+const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+  // Health check endpoints
+  if (req.method === "GET" && (req.url === "/healthz" || req.url === "/readyz")) {
+    const health = healthCheck(getToolCatalogSnapshot());
+    const ready = health.mcp_server.available && health.workspace_root.available && health.tasks_dir.available;
+    res.writeHead(req.url === "/readyz" && !ready ? 503 : 200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ ...health, ready }));
+    return;
+  }
+
+  // Admin acceptance endpoints
+  const admin = parseAdminUrl(req.url || "");
+  if (admin) {
+    if (!checkOwnerToken(req)) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Unauthorized — invalid or missing owner token" }));
+      return;
+    }
+    try {
+      if (admin.action === "get_acceptance" && req.method === "GET") {
+        const acceptance = readAcceptance(admin.taskId);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(acceptance, null, 2));
+        return;
+      }
+      if ((admin.action === "accept" || admin.action === "reject") && req.method === "POST") {
+        const chunks: Buffer[] = [];
+        for await (const chunk of req) { chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)); }
+        const body = Buffer.concat(chunks).toString("utf-8");
+        const acceptance = handleAcceptance(admin.taskId, admin.action === "accept" ? "accepted" : "rejected", body);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(acceptance, null, 2));
+        return;
+      }
+      res.writeHead(405, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Method not allowed for this admin endpoint." }));
+    } catch (err: any) {
+      const statusCode = err.statusCode || 500;
+      res.writeHead(statusCode, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: err.message || "Internal server error" }));
+    }
+    return;
+  }
+
+  // MCP endpoint
+  if (req.url !== "/mcp" && req.url !== "/mcp/") {
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({
+      error_code: "mcp_endpoint_not_found",
+      error: "PatchWarden MCP endpoint not found.",
+      expected_path: "/mcp",
+      health_path: "/healthz",
+      admin_paths: {
+        accept: "POST /admin/tasks/:id/accept",
+        reject: "POST /admin/tasks/:id/reject",
+        get_acceptance: "GET /admin/tasks/:id/acceptance",
+      },
+      suggestion: "Use POST /mcp for MCP requests, GET /healthz for local diagnostics, or /admin/tasks/:id/accept for human review.",
+    }));
+    return;
+  }
+
+  // Owner token check (if configured)
+  if (!checkOwnerToken(req)) {
+    res.writeHead(401, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Unauthorized — invalid or missing owner token" }));
+    return;
+  }
+
+  await handleMcpRequest(req, res);
+});
+
+// ── Start ─────────────────────────────────────────────────────────
+
+httpServer.on("error", (err: NodeJS.ErrnoException) => {
+  if (err.code === "EADDRINUSE") {
+    console.error(`[patchwarden-http] Fatal: port ${port} is already in use on ${host}.`);
+    console.error("[patchwarden-http] Stop the other PatchWarden HTTP instance or change httpPort in patchwarden.config.json.");
+  } else {
+    console.error(`[patchwarden-http] Fatal: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+httpServer.listen(port, host, () => {
+  console.error(`[patchwarden-http] ✅ Ready`);
+  console.error(`[patchwarden-http] Admin:    http://${host}:${port}/admin/tasks/:id/accept`);
+});
+
+// Graceful shutdown
+process.on("SIGINT", () => {
+  console.error("[patchwarden-http] Shutting down...");
+  httpServer.close(() => process.exit(0));
+});
+
+process.on("SIGTERM", () => {
+  httpServer.close(() => process.exit(0));
+});

package/src/index.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * PatchWarden MCP Server — stdio transport
+ *
+ * Run: node dist/index.js
+ * Used by OpenAI tunnel-client via `--mcp.command`:
+ *   tunnel-client ... --mcp.command "node" --mcp.args "dist/index.js"
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.js";
+import { registerTools } from "./tools/registry.js";
+import { PATCHWARDEN_VERSION } from "./version.js";
+
+const config = loadConfig();
+
+console.error(`[patchwarden] Workspace: ${config.workspaceRoot}`);
+console.error(`[patchwarden] Transport: stdio`);
+
+const server = new Server(
+  { name: "patchwarden", version: PATCHWARDEN_VERSION },
+  { capabilities: { tools: {} } }
+);
+
+registerTools(server);
+
+const transport = new StdioServerTransport();
+server.connect(transport).catch((err) => {
+  console.error("[patchwarden] Fatal:", err);
+  process.exit(1);
+});
+
+console.error("[patchwarden] MCP server ready on stdio");

package/src/runner/changeCapture.ts

@@ -0,0 +1,304 @@
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  lstatSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { isSensitivePath } from "../security/sensitiveGuard.js";
+
+const MAX_HASH_BYTES = 5 * 1024 * 1024;
+const MAX_SNAPSHOT_FILES = 5000;
+const MAX_DIFF_BYTES = 20 * 1024 * 1024;
+const SKIP_DIRECTORIES = new Set([".git", ".patchwarden", "node_modules"]);
+
+export interface FileFingerprint {
+  size: number;
+  sha256: string;
+}
+
+export interface RepoSnapshot {
+  captured_at: string;
+  is_git: boolean;
+  head: string | null;
+  status: string;
+  workspace_dirty: boolean;
+  files: Record<string, FileFingerprint>;
+  warnings: string[];
+}
+
+export interface ChangedFile {
+  path: string;
+  change: "added" | "modified" | "deleted" | "renamed";
+  old_path?: string;
+  before_sha256: string | null;
+  after_sha256: string | null;
+}
+
+export interface ChangeArtifacts {
+  changed_files: ChangedFile[];
+  diff: string;
+  diff_available: boolean;
+  diff_truncated: boolean;
+  diff_size_bytes: number;
+  additions: number;
+  deletions: number;
+  file_stats: Array<{
+    path: string;
+    status: ChangedFile["change"];
+    additions: number;
+    deletions: number;
+  }>;
+  workspace_dirty_before: boolean;
+  workspace_dirty_after: boolean;
+  patch_mode: "textual" | "no_changes" | "hash_only";
+  unavailable_reason: string | null;
+}
+
+export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
+  const warnings: string[] = [];
+  const isGit = runGit(repoPath, ["rev-parse", "--is-inside-work-tree"]).stdout.trim() === "true";
+  let head: string | null = null;
+  let status = "";
+  let paths: string[] = [];
+
+  if (isGit) {
+    const headResult = runGit(repoPath, ["rev-parse", "HEAD"]);
+    if (headResult.status === 0) head = headResult.stdout.trim() || null;
+    status = runGit(repoPath, ["status", "--porcelain=v1", "-uall"]).stdout.trimEnd();
+    const listed = runGit(repoPath, ["ls-files", "-co", "--exclude-standard", "-z"]);
+    if (listed.status === 0) {
+      paths = [...new Set([
+        ...listed.stdout.split("\0").filter(Boolean),
+        ...walkWorkspace(repoPath),
+      ])];
+    } else {
+      warnings.push("git ls-files failed; using bounded filesystem scan");
+      paths = walkWorkspace(repoPath);
+    }
+  } else {
+    warnings.push("repository is not a Git worktree; diff will contain file-change evidence only");
+    paths = walkWorkspace(repoPath);
+  }
+
+  if (paths.length > MAX_SNAPSHOT_FILES) {
+    warnings.push(`snapshot limited to ${MAX_SNAPSHOT_FILES} files`);
+    paths = paths.slice(0, MAX_SNAPSHOT_FILES);
+  }
+
+  const files: Record<string, FileFingerprint> = {};
+  for (const inputPath of paths.sort()) {
+    const normalized = inputPath.replace(/\\/g, "/");
+    if (!normalized || normalized.startsWith(".patchwarden/") || isSensitivePath(normalized)) continue;
+    const absolutePath = resolve(repoPath, inputPath);
+    try {
+      const stat = lstatSync(absolutePath);
+      if (!stat.isFile()) continue;
+      const sha256 = stat.size <= MAX_HASH_BYTES
+        ? createHash("sha256").update(readFileSync(absolutePath)).digest("hex")
+        : `large-file:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+      files[normalized] = { size: stat.size, sha256 };
+    } catch {
+      warnings.push(`could not fingerprint: ${normalized}`);
+    }
+  }
+
+  return {
+    captured_at: new Date().toISOString(),
+    is_git: isGit,
+    head,
+    status,
+    workspace_dirty: status.trim().length > 0,
+    files,
+    warnings,
+  };
+}
+
+export function writeSnapshot(taskDir: string, filename: string, snapshot: RepoSnapshot): void {
+  writeFileSync(join(taskDir, filename), JSON.stringify(snapshot, null, 2), "utf-8");
+}
+
+export function buildChangeArtifacts(
+  repoPath: string,
+  before: RepoSnapshot,
+  after: RepoSnapshot
+): ChangeArtifacts {
+  const changedFiles = compareSnapshots(before, after);
+  const sections: string[] = [];
+  const scopedPaths = [...new Set(changedFiles.flatMap((file) => file.old_path ? [file.old_path, file.path] : [file.path]))];
+
+  if (before.is_git && after.is_git && scopedPaths.length > 0) {
+    if (before.head && after.head && before.head !== after.head) {
+      const committed = runGit(repoPath, ["diff", "--no-color", "--binary", before.head, after.head, "--", ...scopedPaths]);
+      if (committed.stdout.trim()) sections.push("# Changes committed during task\n", committed.stdout.trimEnd());
+    }
+
+    const base = after.head || "HEAD";
+    const working = runGit(repoPath, ["diff", "--no-color", "--binary", base, "--", ...scopedPaths]);
+    if (working.stdout.trim()) sections.push("# Staged and unstaged changes\n", working.stdout.trimEnd());
+
+    for (const file of changedFiles.filter((item) => item.change === "added").slice(0, 100)) {
+      const tracked = runGit(repoPath, ["ls-files", "--error-unmatch", "--", file.path]);
+      if (tracked.status === 0) continue;
+      const untracked = runGit(repoPath, ["diff", "--no-index", "--no-color", "--binary", "--", "/dev/null", file.path]);
+      if (untracked.stdout.trim()) sections.push("# Untracked file\n", untracked.stdout.trimEnd());
+    }
+  }
+
+  const evidence = [
+    "# PatchWarden change evidence",
+    `# changed_files: ${changedFiles.length}`,
+    `# workspace_dirty_before: ${before.workspace_dirty}`,
+    `# workspace_dirty_after: ${after.workspace_dirty}`,
+    ...changedFiles.map((file) => `# ${file.change}: ${file.path}`),
+  ].join("\n");
+  const body = sections.join("\n\n");
+  const fullDiff = `${evidence}\n\n${body || (changedFiles.length ? "(textual patch unavailable; see changed-files.json for hash evidence)" : "(no task file changes detected)")}\n`;
+  const additions = fullDiff.split(/\r?\n/).filter((line) => line.startsWith("+") && !line.startsWith("+++")).length;
+  const deletions = fullDiff.split(/\r?\n/).filter((line) => line.startsWith("-") && !line.startsWith("---")).length;
+  const fileStats = buildFileStats(repoPath, before, after, changedFiles);
+
+  return {
+    changed_files: changedFiles,
+    diff: fullDiff,
+    diff_available: changedFiles.length > 0,
+    diff_truncated: false,
+    diff_size_bytes: Buffer.byteLength(fullDiff, "utf-8"),
+    additions,
+    deletions,
+    file_stats: fileStats,
+    workspace_dirty_before: before.workspace_dirty,
+    workspace_dirty_after: after.workspace_dirty,
+    patch_mode: changedFiles.length === 0 ? "no_changes" : body ? "textual" : "hash_only",
+    unavailable_reason: changedFiles.length > 0 && !body
+      ? (before.is_git && after.is_git
+          ? "Git could not produce a textual patch for the changed files; hash evidence remains available."
+          : "Repository is not a Git worktree; only bounded hash evidence is available.")
+      : null,
+  };
+}
+
+function buildFileStats(
+  repoPath: string,
+  before: RepoSnapshot,
+  after: RepoSnapshot,
+  changedFiles: ChangedFile[]
+): ChangeArtifacts["file_stats"] {
+  return changedFiles.map((file) => {
+    let additions = 0;
+    let deletions = 0;
+    const paths = file.old_path ? [file.old_path, file.path] : [file.path];
+
+    if (before.is_git && after.is_git) {
+      const ranges: string[][] = [];
+      if (before.head && after.head && before.head !== after.head) {
+        ranges.push([before.head, after.head]);
+      }
+      ranges.push([after.head || "HEAD"]);
+      for (const range of ranges) {
+        const result = runGit(repoPath, ["diff", "--numstat", ...range, "--", ...paths]);
+        for (const line of result.stdout.split(/\r?\n/).filter(Boolean)) {
+          const [added, removed] = line.split(/\s+/);
+          if (/^\d+$/.test(added)) additions += Number(added);
+          if (/^\d+$/.test(removed)) deletions += Number(removed);
+        }
+      }
+    }
+
+    if (file.change === "added" && additions === 0) {
+      try {
+        const content = readFileSync(resolve(repoPath, file.path), "utf-8");
+        additions = countLines(content);
+      } catch {}
+    }
+
+    return { path: file.path, status: file.change, additions, deletions };
+  });
+}
+
+function countLines(content: string): number {
+  if (content.length === 0) return 0;
+  return content.split(/\r?\n/).length - (content.endsWith("\n") ? 1 : 0);
+}
+
+export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): ChangedFile[] {
+  const paths = [...new Set([...Object.keys(before.files), ...Object.keys(after.files)])].sort();
+  const changed: ChangedFile[] = [];
+  for (const path of paths) {
+    const left = before.files[path];
+    const right = after.files[path];
+    if (!left && right) {
+      changed.push({ path, change: "added", before_sha256: null, after_sha256: right.sha256 });
+    } else if (left && !right) {
+      changed.push({ path, change: "deleted", before_sha256: left.sha256, after_sha256: null });
+    } else if (left.sha256 !== right.sha256) {
+      changed.push({ path, change: "modified", before_sha256: left.sha256, after_sha256: right.sha256 });
+    }
+  }
+  const deletedByHash = new Map<string, ChangedFile[]>();
+  for (const file of changed.filter((item) => item.change === "deleted" && item.before_sha256)) {
+    const entries = deletedByHash.get(file.before_sha256!) || [];
+    entries.push(file);
+    deletedByHash.set(file.before_sha256!, entries);
+  }
+
+  const consumed = new Set<ChangedFile>();
+  const renamed: ChangedFile[] = [];
+  for (const file of changed.filter((item) => item.change === "added" && item.after_sha256)) {
+    const candidates = deletedByHash.get(file.after_sha256!) || [];
+    const source = candidates.find((item) => !consumed.has(item));
+    if (!source) continue;
+    consumed.add(source);
+    consumed.add(file);
+    renamed.push({
+      path: file.path,
+      old_path: source.path,
+      change: "renamed",
+      before_sha256: source.before_sha256,
+      after_sha256: file.after_sha256,
+    });
+  }
+
+  return [...changed.filter((item) => !consumed.has(item)), ...renamed]
+    .sort((left, right) => left.path.localeCompare(right.path));
+}
+
+function walkWorkspace(root: string): string[] {
+  const result: string[] = [];
+  const visit = (directory: string) => {
+    if (result.length >= MAX_SNAPSHOT_FILES) return;
+    let entries;
+    try {
+      entries = readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (result.length >= MAX_SNAPSHOT_FILES) break;
+      if (entry.isDirectory() && SKIP_DIRECTORIES.has(entry.name)) continue;
+      const absolute = join(directory, entry.name);
+      if (entry.isDirectory()) visit(absolute);
+      else if (entry.isFile()) result.push(relative(root, absolute).replace(/\\/g, "/"));
+    }
+  };
+  visit(root);
+  return result;
+}
+
+function runGit(repoPath: string, args: string[]) {
+  const result = spawnSync("git", args, {
+    cwd: repoPath,
+    encoding: "utf-8",
+    timeout: 30_000,
+    maxBuffer: MAX_DIFF_BYTES,
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}

package/src/runner/cli.ts

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * PatchWarden Runner CLI
+ *
+ * Usage:
+ *   node dist/runner/cli.js <task_id>
+ *   npm run runner -- <task_id>
+ */
+
+import { runTask } from "./runTask.js";
+import { loadConfig } from "../config.js";
+
+// Load config early
+loadConfig();
+
+const taskId = process.argv[2] || process.env.PATCHWARDEN_TASK_ID;
+
+if (!taskId) {
+  console.error("Usage: node dist/runner/cli.js <task_id>");
+  console.error("   or: npm run runner -- <task_id>");
+  process.exit(1);
+}
+
+console.error(`[runner] Starting task: ${taskId}`);
+
+const result = await runTask(taskId);
+
+console.error(`[runner] Task ${result.task_id}: ${result.status}`);
+if (result.error) {
+  console.error(`[runner] Error: ${result.error}`);
+  process.exit(1);
+}
+
+console.error("[runner] Done.");