patchwarden 0.4.0 → 0.6.1

package/src/direct/directGuards.ts

@@ -0,0 +1,279 @@
+import { resolve, relative, isAbsolute, sep } from "node:path";
+import { existsSync, statSync, openSync, readSync, closeSync } from "node:fs";
+import { PatchWardenError } from "../errors.js";
+import { isSensitivePath } from "../security/sensitiveGuard.js";
+import { guardWorkspacePath } from "../security/pathGuard.js";
+import { getConfig } from "../config.js";
+import type { DirectSessionRecord } from "./directSessionStore.js";
+
+// ── Session state guards ───────────────────────────────────────────
+
+export function guardDirectSessionActive(session: DirectSessionRecord): void {
+  if (new Date(session.expires_at) < new Date()) {
+    throw new PatchWardenError(
+      "session_expired",
+      `Direct session "${session.session_id}" expired at ${session.expires_at}.`,
+      "Create a new direct session with create_direct_session.",
+      true,
+      { session_id: session.session_id, expires_at: session.expires_at }
+    );
+  }
+
+  if (session.finalized) {
+    throw new PatchWardenError(
+      "session_finalized",
+      `Direct session "${session.session_id}" has been finalized. No further modifications are allowed.`,
+      "Create a new direct session with create_direct_session to continue making changes.",
+      true,
+      { session_id: session.session_id, finalized_at: session.finalized_at }
+    );
+  }
+}
+
+export function guardDirectSessionFinalized(
+  session: DirectSessionRecord
+): void {
+  if (!session.finalized) {
+    throw new PatchWardenError(
+      "session_not_finalized",
+      `Direct session "${session.session_id}" has not been finalized. Call finalize_direct_session first.`,
+      "Call finalize_direct_session before audit_session.",
+      true,
+      { session_id: session.session_id }
+    );
+  }
+}
+
+// ── Path guards ────────────────────────────────────────────────────
+
+/**
+ * Resolve a relative path against the session's repo_path and verify it stays
+ * inside both the repo and the workspace root.
+ */
+export function guardDirectPath(
+  filePath: string,
+  resolvedRepoPath: string,
+  workspaceRoot: string
+): string {
+  const config = getConfig();
+  const resolved = resolve(resolvedRepoPath, filePath);
+  const normalizedRepo = resolve(resolvedRepoPath);
+  const normalizedWs = resolve(workspaceRoot);
+
+  // Check path is inside workspace root
+  const relToWs = relative(normalizedWs, resolved);
+  if (isAbsolute(relToWs) || relToWs.startsWith("..")) {
+    throw new PatchWardenError(
+      "path_outside_repo",
+      `Path "${filePath}" resolves outside the session repo.`,
+      "Use a relative path inside the session's repo_path.",
+      true,
+      { path: filePath, operation: "direct_path_access" }
+    );
+  }
+
+  // Check path is inside repo_path
+  const relToRepo = relative(normalizedRepo, resolved);
+  if (isAbsolute(relToRepo) || relToRepo.startsWith("..")) {
+    throw new PatchWardenError(
+      "path_outside_repo",
+      `Path "${filePath}" is outside the session repo_path "${resolvedRepoPath}".`,
+      "Use a relative path inside the session's repo_path.",
+      true,
+      { path: filePath, operation: "direct_path_access" }
+    );
+  }
+
+  return resolved;
+}
+
+/**
+ * Guard a read path: must be inside repo, not sensitive, not binary.
+ */
+export function guardDirectReadPath(
+  filePath: string,
+  resolvedRepoPath: string,
+  workspaceRoot: string
+): string {
+  const resolved = guardDirectPath(filePath, resolvedRepoPath, workspaceRoot);
+  const normalized = filePath.replace(/\\/g, "/");
+
+  // Block internal PatchWarden paths (sessions, tasks, plans, assessments)
+  if (
+    normalized.startsWith(".patchwarden/") ||
+    normalized.includes("/.patchwarden/")
+  ) {
+    throw new PatchWardenError(
+      "internal_patchwarden_path_blocked",
+      `Access denied: "${filePath}" is inside the internal .patchwarden directory.`,
+      "Internal PatchWarden files cannot be accessed through Direct mode.",
+      true,
+      { path: filePath, operation: "direct_read" }
+    );
+  }
+
+  if (isSensitivePath(filePath)) {
+    throw new PatchWardenError(
+      "sensitive_path_blocked",
+      `Access denied: "${filePath}" matches a sensitive file pattern.`,
+      "Read only non-sensitive files within the session repo.",
+      true,
+      { path: filePath, operation: "direct_read" }
+    );
+  }
+
+  if (existsSync(resolved) && statSync(resolved).isFile() && isBinaryFile(resolved)) {
+    throw new PatchWardenError(
+      "binary_file_blocked",
+      `File "${filePath}" appears to be a binary file.`,
+      "Binary files cannot be read in Direct mode.",
+      true,
+      { path: filePath, operation: "direct_read" }
+    );
+  }
+
+  return resolved;
+}
+
+/**
+ * Guard a write path: must be inside repo, not sensitive, not binary,
+ * not in node_modules, release, or dist directories.
+ */
+export function guardDirectWritePath(
+  filePath: string,
+  resolvedRepoPath: string,
+  workspaceRoot: string
+): string {
+  const resolved = guardDirectPath(filePath, resolvedRepoPath, workspaceRoot);
+  const normalized = filePath.replace(/\\/g, "/");
+
+  // Block internal PatchWarden paths
+  if (
+    normalized.startsWith(".patchwarden/") ||
+    normalized.includes("/.patchwarden/")
+  ) {
+    throw new PatchWardenError(
+      "internal_patchwarden_path_blocked",
+      `Modification denied: "${filePath}" is inside the internal .patchwarden directory.`,
+      "Internal PatchWarden files cannot be modified through Direct mode.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  if (isSensitivePath(normalized)) {
+    throw new PatchWardenError(
+      "sensitive_path_blocked",
+      `Modification denied: "${filePath}" matches a sensitive file pattern.`,
+      "Do not modify .env, credentials, keys, or other sensitive files.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  // Block node_modules
+  if (normalized.startsWith("node_modules/") || normalized.includes("/node_modules/")) {
+    throw new PatchWardenError(
+      "blocked_artifact_path",
+      `Modification denied: "${filePath}" is inside node_modules.`,
+      "Do not modify dependencies directly. Use package management tools instead.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  // Block release/
+  if (normalized.startsWith("release/") || normalized.includes("/release/")) {
+    throw new PatchWardenError(
+      "blocked_artifact_path",
+      `Modification denied: "${filePath}" is inside the release directory.`,
+      "Do not manually modify release artifacts.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  // Block dist/
+  if (normalized.startsWith("dist/") || normalized.includes("/dist/")) {
+    throw new PatchWardenError(
+      "blocked_artifact_path",
+      `Modification denied: "${filePath}" is inside the dist directory.`,
+      "Do not manually modify build output. Modify source files instead.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  if (existsSync(resolved) && statSync(resolved).isFile() && isBinaryFile(resolved)) {
+    throw new PatchWardenError(
+      "binary_file_blocked",
+      `Modification denied: "${filePath}" appears to be a binary file.`,
+      "Binary files cannot be modified in Direct mode.",
+      true,
+      { path: filePath, operation: "direct_write" }
+    );
+  }
+
+  return resolved;
+}
+
+// ── Size guards ────────────────────────────────────────────────────
+
+export function guardDirectPatchSize(patchBytes: number): void {
+  const config = getConfig();
+  if (patchBytes > config.directMaxPatchBytes) {
+    throw new PatchWardenError(
+      "patch_too_large",
+      `Patch size ${patchBytes} bytes exceeds maximum ${config.directMaxPatchBytes} bytes.`,
+      "Split the patch into smaller operations or reduce the patch size.",
+      true,
+      { patch_bytes: patchBytes, max_bytes: config.directMaxPatchBytes }
+    );
+  }
+}
+
+export function guardDirectFileSize(fileBytes: number): void {
+  const config = getConfig();
+  if (fileBytes > config.directMaxFileBytes) {
+    throw new PatchWardenError(
+      "file_too_large",
+      `File size ${fileBytes} bytes exceeds maximum ${config.directMaxFileBytes} bytes.`,
+      "Use search_workspace to find specific content, or split the read into smaller portions.",
+      true,
+      { file_bytes: fileBytes, max_bytes: config.directMaxFileBytes }
+    );
+  }
+}
+
+// ── Binary detection ───────────────────────────────────────────────
+
+const BINARY_EXTENSIONS = new Set([
+  ".exe", ".dll", ".so", ".dylib", ".a", ".lib", ".o", ".obj",
+  ".zip", ".gz", ".tar", ".tgz", ".bz2", ".7z", ".rar",
+  ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".ico", ".webp", ".tiff",
+  ".pdf", ".doc", ".docx", ".xls", ".xlsx", ".ppt", ".pptx",
+  ".mp3", ".mp4", ".avi", ".mov", ".wav", ".flv",
+  ".bin", ".dat", ".pak", ".pfx", ".p12", ".class", ".jar", ".war",
+  ".wasm", ".node",
+]);
+
+export function isBinaryFile(filePath: string): boolean {
+  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
+  for (const ext of BINARY_EXTENSIONS) {
+    if (normalized.endsWith(ext)) return true;
+  }
+
+  // Check file content for null bytes (simple heuristic)
+  try {
+    const fd = openSync(filePath, "r");
+    const buffer = Buffer.alloc(8192);
+    const bytesRead = readSync(fd, buffer, 0, 8192, 0);
+    closeSync(fd);
+    for (let i = 0; i < bytesRead; i++) {
+      if (buffer[i] === 0) return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}

package/src/direct/directPatch.ts

@@ -0,0 +1,258 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, resolve } from "node:path";
+import { PatchWardenError } from "../errors.js";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export type PatchOperationType =
+  | "replace_exact"
+  | "insert_before"
+  | "insert_after"
+  | "replace_whole_file";
+
+export interface PatchOperation {
+  type: PatchOperationType;
+  old_text?: string;
+  new_text: string;
+  occurrence?: "first" | "all" | "exactly_once";
+}
+
+export interface ApplyPatchResult {
+  before_sha256: string;
+  after_sha256: string;
+  operations_applied: number;
+  bytes_changed: number;
+}
+
+// ── Hash helpers ───────────────────────────────────────────────────
+
+export function computeFileSha256(filePath: string): string {
+  const content = readFileSync(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+
+export function computeContentSha256(content: string): string {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+
+export function validateExpectedSha256(
+  filePath: string,
+  expectedSha256: string
+): string {
+  if (!existsSync(filePath)) {
+    throw new PatchWardenError(
+      "file_hash_mismatch",
+      `File does not exist: "${filePath}".`,
+      "Ensure the file path is correct and the file exists before applying a patch.",
+      true,
+      { expected_sha256: expectedSha256 }
+    );
+  }
+
+  const currentHash = computeFileSha256(filePath);
+  if (currentHash !== expectedSha256) {
+    throw new PatchWardenError(
+      "file_hash_mismatch",
+      `File hash mismatch. Expected "${expectedSha256}" but got "${currentHash}".`,
+      "Re-read the file to get the current sha256, then retry the patch with the updated expected_sha256.",
+      true,
+      { expected_sha256: expectedSha256, actual_sha256: currentHash }
+    );
+  }
+
+  return currentHash;
+}
+
+// ── Patch application ──────────────────────────────────────────────
+
+export function applyPatchOperations(
+  filePath: string,
+  operations: PatchOperation[]
+): ApplyPatchResult {
+  if (!existsSync(filePath)) {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      `File does not exist: "${filePath}".`,
+      "Ensure the file exists before applying a patch. Direct mode does not support creating new files.",
+      true,
+      { path: filePath }
+    );
+  }
+
+  const beforeContent = readFileSync(filePath, "utf-8");
+  const beforeSha256 = computeContentSha256(beforeContent);
+  let content = beforeContent;
+  let operationsApplied = 0;
+
+  for (const op of operations) {
+    content = applySingleOperation(content, op);
+    operationsApplied++;
+  }
+
+  const afterSha256 = computeContentSha256(content);
+  const bytesChanged = Math.abs(
+    Buffer.byteLength(content, "utf-8") - Buffer.byteLength(beforeContent, "utf-8")
+  );
+
+  // Ensure parent directory exists (should already exist for existing files)
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, "utf-8");
+
+  return {
+    before_sha256: beforeSha256,
+    after_sha256: afterSha256,
+    operations_applied: operationsApplied,
+    bytes_changed: bytesChanged,
+  };
+}
+
+function applySingleOperation(
+  content: string,
+  op: PatchOperation
+): string {
+  switch (op.type) {
+    case "replace_exact":
+      return applyReplaceExact(content, op);
+    case "insert_before":
+      return applyInsertBefore(content, op);
+    case "insert_after":
+      return applyInsertAfter(content, op);
+    case "replace_whole_file":
+      return op.new_text;
+    default:
+      throw new PatchWardenError(
+        "patch_anchor_not_found",
+        `Unknown operation type: "${op.type}".`,
+        "Use one of: replace_exact, insert_before, insert_after, replace_whole_file.",
+        true,
+        { operation_type: op.type }
+      );
+  }
+}
+
+function applyReplaceExact(
+  content: string,
+  op: PatchOperation
+): string {
+  if (op.old_text === undefined || op.old_text === "") {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      "replace_exact requires a non-empty old_text.",
+      "Provide the exact text to replace.",
+      true,
+      { operation: "replace_exact" }
+    );
+  }
+
+  const occurrence = op.occurrence || "first";
+  const oldText = op.old_text;
+  const newText = op.new_text;
+
+  if (occurrence === "all") {
+    if (!content.includes(oldText)) {
+      throw new PatchWardenError(
+        "patch_anchor_not_found",
+        `old_text not found in file content.`,
+        "Ensure old_text exactly matches content in the file.",
+        true,
+        { operation: "replace_exact", occurrence: "all" }
+      );
+    }
+    return content.split(oldText).join(newText);
+  }
+
+  if (occurrence === "exactly_once") {
+    const firstIndex = content.indexOf(oldText);
+    if (firstIndex === -1) {
+      throw new PatchWardenError(
+        "patch_anchor_not_found",
+        `old_text not found in file content.`,
+        "Ensure old_text exactly matches content in the file.",
+        true,
+        { operation: "replace_exact", occurrence: "exactly_once" }
+      );
+    }
+    const secondIndex = content.indexOf(oldText, firstIndex + 1);
+    if (secondIndex !== -1) {
+      throw new PatchWardenError(
+        "patch_ambiguous",
+        `old_text appears multiple times in file content, but occurrence is "exactly_once".`,
+        "Use occurrence: \"first\" to replace the first match, or occurrence: \"all\" to replace all matches.",
+        true,
+        { operation: "replace_exact", occurrence: "exactly_once" }
+      );
+    }
+    return content.slice(0, firstIndex) + newText + content.slice(firstIndex + oldText.length);
+  }
+
+  // occurrence === "first" (default)
+  if (!content.includes(oldText)) {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      `old_text not found in file content.`,
+      "Ensure old_text exactly matches content in the file.",
+      true,
+      { operation: "replace_exact", occurrence: "first" }
+    );
+  }
+  const index = content.indexOf(oldText);
+  return content.slice(0, index) + newText + content.slice(index + oldText.length);
+}
+
+function applyInsertBefore(
+  content: string,
+  op: PatchOperation
+): string {
+  if (op.old_text === undefined || op.old_text === "") {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      "insert_before requires a non-empty old_text as anchor.",
+      "Provide the anchor text before which new_text should be inserted.",
+      true,
+      { operation: "insert_before" }
+    );
+  }
+
+  const index = content.indexOf(op.old_text);
+  if (index === -1) {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      `Anchor text not found in file content for insert_before.`,
+      "Ensure old_text exactly matches content in the file.",
+      true,
+      { operation: "insert_before" }
+    );
+  }
+
+  return content.slice(0, index) + op.new_text + content.slice(index);
+}
+
+function applyInsertAfter(
+  content: string,
+  op: PatchOperation
+): string {
+  if (op.old_text === undefined || op.old_text === "") {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      "insert_after requires a non-empty old_text as anchor.",
+      "Provide the anchor text after which new_text should be inserted.",
+      true,
+      { operation: "insert_after" }
+    );
+  }
+
+  const index = content.indexOf(op.old_text);
+  if (index === -1) {
+    throw new PatchWardenError(
+      "patch_anchor_not_found",
+      `Anchor text not found in file content for insert_after.`,
+      "Ensure old_text exactly matches content in the file.",
+      true,
+      { operation: "insert_after" }
+    );
+  }
+
+  const insertPos = index + op.old_text.length;
+  return content.slice(0, insertPos) + op.new_text + content.slice(insertPos);
+}