patchwarden 0.4.0 → 0.6.1

package/src/direct/directSessionStore.ts

@@ -0,0 +1,345 @@
+import {
+  mkdirSync,
+  writeFileSync,
+  existsSync,
+  readFileSync,
+} from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { resolve, join } from "node:path";
+import {
+  getDirectSessionsDir,
+  getConfig,
+  getRepoDirectAllowedCommands,
+  PatchWardenConfig,
+} from "../config.js";
+import { guardPath } from "../security/pathGuard.js";
+import { PatchWardenError } from "../errors.js";
+import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
+import { getLastToolCatalogSnapshot } from "../tools/toolCatalog.js";
+import {
+  captureRepoSnapshot,
+  buildChangeArtifacts,
+  type RepoSnapshot,
+  type ChangeArtifacts,
+} from "../runner/changeCapture.js";
+
+// ── Types ──────────────────────────────────────────────────────────
+
+export interface DirectSessionOperation {
+  index: number;
+  timestamp: string;
+  path: string;
+  before_sha256: string;
+  after_sha256: string;
+  operations_applied: number;
+  bytes_changed: number;
+}
+
+export interface DirectSessionVerificationRun {
+  command: string;
+  exit_code: number | null;
+  passed: boolean;
+  timed_out: boolean;
+  stdout_tail: string;
+  stderr_tail: string;
+  started_at: string;
+  finished_at: string;
+  log_path: string;
+}
+
+export interface DirectSessionRecord {
+  session_id: string;
+  title: string;
+  repo_path: string;
+  resolved_repo_path: string;
+  created_at: string;
+  expires_at: string;
+  server_version: string;
+  schema_epoch: string;
+  tool_manifest_sha256: string;
+  workspace_snapshot_before: RepoSnapshot;
+  workspace_fingerprint_before: string;
+  allowed_commands: string[];
+  operations: DirectSessionOperation[];
+  verification_runs: DirectSessionVerificationRun[];
+  finalized: boolean;
+  finalized_at: string | null;
+  audited: boolean;
+  change_artifacts: ChangeArtifacts | null;
+}
+
+export interface DirectSessionCreateInput {
+  repo_path: string;
+  resolved_repo_path: string;
+  title?: string;
+  snapshot: RepoSnapshot;
+}
+
+// ── ID generation ──────────────────────────────────────────────────
+
+export function generateDirectSessionId(): string {
+  const timestamp = new Date()
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace("T", "_")
+    .slice(0, 15);
+  const randomHex = randomBytes(16).toString("hex");
+  return `direct_${timestamp}_${randomHex}`;
+}
+
+// ── Directory management ───────────────────────────────────────────
+
+export function createDirectSessionDir(sessionId: string): string {
+  const config = getConfig();
+  const sessionsDir = getDirectSessionsDir(config);
+  guardPath(sessionsDir, config.workspaceRoot, config.directSessionsDir);
+  mkdirSync(sessionsDir, { recursive: true });
+  const dir = resolve(sessionsDir, sessionId);
+  guardPath(dir, config.workspaceRoot, config.directSessionsDir);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export function getDirectSessionDir(sessionId: string): string {
+  const config = getConfig();
+  const sessionsDir = getDirectSessionsDir(config);
+  return resolve(sessionsDir, sessionId);
+}
+
+// ── CRUD ───────────────────────────────────────────────────────────
+
+export function createDirectSession(
+  input: DirectSessionCreateInput
+): DirectSessionRecord {
+  const config = getConfig();
+
+  const sessionId = generateDirectSessionId();
+  const dir = createDirectSessionDir(sessionId);
+
+  const toolManifest =
+    getLastToolCatalogSnapshot()?.tool_manifest_sha256 ||
+    computeFallbackManifestHash(config);
+
+  const workspaceFingerprint = computeWorkspaceFingerprint(input.snapshot);
+
+  const allowedCommands = [
+    ...(config.directAllowedCommands || []),
+    ...getRepoDirectAllowedCommands(config, input.resolved_repo_path),
+  ];
+
+  const now = new Date();
+  const expiresAt = new Date(
+    now.getTime() + config.directSessionTtlSeconds * 1000
+  ).toISOString();
+
+  const record: DirectSessionRecord = {
+    session_id: sessionId,
+    title: input.title || "",
+    repo_path: input.repo_path,
+    resolved_repo_path: input.resolved_repo_path,
+    created_at: now.toISOString(),
+    expires_at: expiresAt,
+    server_version: PATCHWARDEN_VERSION,
+    schema_epoch: TOOL_SCHEMA_EPOCH,
+    tool_manifest_sha256: toolManifest,
+    workspace_snapshot_before: input.snapshot,
+    workspace_fingerprint_before: workspaceFingerprint,
+    allowed_commands: allowedCommands,
+    operations: [],
+    verification_runs: [],
+    finalized: false,
+    finalized_at: null,
+    audited: false,
+    change_artifacts: null,
+  };
+
+  writeFileSync(
+    join(dir, "session.json"),
+    JSON.stringify(record, null, 2),
+    "utf-8"
+  );
+
+  return record;
+}
+
+export function readDirectSession(sessionId: string): DirectSessionRecord {
+  const config = getConfig();
+  const sessionsDir = getDirectSessionsDir(config);
+  const dir = resolve(sessionsDir, sessionId);
+  const file = join(dir, "session.json");
+  guardPath(file, config.workspaceRoot, config.directSessionsDir);
+
+  if (!existsSync(file)) {
+    throw new PatchWardenError(
+      "session_not_found",
+      `Direct session "${sessionId}" not found.`,
+      "Call create_direct_session first to get a valid session_id.",
+      true,
+      { session_id: sessionId }
+    );
+  }
+
+  return JSON.parse(readFileSync(file, "utf-8")) as DirectSessionRecord;
+}
+
+export function updateDirectSession(
+  sessionId: string,
+  updates: Partial<DirectSessionRecord>
+): DirectSessionRecord {
+  const session = readDirectSession(sessionId);
+  const updated: DirectSessionRecord = { ...session, ...updates };
+  const dir = getDirectSessionDir(sessionId);
+  writeFileSync(
+    join(dir, "session.json"),
+    JSON.stringify(updated, null, 2),
+    "utf-8"
+  );
+  return updated;
+}
+
+export function appendDirectSessionOperation(
+  sessionId: string,
+  operation: DirectSessionOperation
+): DirectSessionRecord {
+  const session = readDirectSession(sessionId);
+  const operations = [...session.operations, operation];
+  return updateDirectSession(sessionId, { operations });
+}
+
+export function appendDirectSessionVerificationRun(
+  sessionId: string,
+  run: DirectSessionVerificationRun
+): DirectSessionRecord {
+  const session = readDirectSession(sessionId);
+  const verification_runs = [...session.verification_runs, run];
+  return updateDirectSession(sessionId, { verification_runs });
+}
+
+// ── Validation ─────────────────────────────────────────────────────
+
+export interface DirectSessionValidationResult {
+  valid: boolean;
+  failure_reason: string | null;
+  session: DirectSessionRecord | null;
+}
+
+export function validateDirectSessionFreshness(
+  sessionId: string
+): DirectSessionValidationResult {
+  let session: DirectSessionRecord;
+  try {
+    session = readDirectSession(sessionId);
+  } catch (e) {
+    return {
+      valid: false,
+      failure_reason: extractReason(e),
+      session: null,
+    };
+  }
+
+  if (new Date(session.expires_at) < new Date()) {
+    return { valid: false, failure_reason: "session_expired", session };
+  }
+
+  const currentManifest =
+    getLastToolCatalogSnapshot()?.tool_manifest_sha256 ||
+    computeFallbackManifestHash(getConfig());
+  if (currentManifest !== session.tool_manifest_sha256) {
+    return {
+      valid: false,
+      failure_reason: "session_stale_config",
+      session,
+    };
+  }
+
+  return { valid: true, failure_reason: null, session };
+}
+
+// ── Finalization ───────────────────────────────────────────────────
+
+export function finalizeDirectSessionRecord(
+  sessionId: string,
+  afterSnapshot: RepoSnapshot,
+  changeArtifacts: ChangeArtifacts
+): DirectSessionRecord {
+  const dir = getDirectSessionDir(sessionId);
+
+  // Write change artifacts to session directory
+  writeFileSync(
+    join(dir, "changed-files.json"),
+    JSON.stringify(changeArtifacts.changed_files, null, 2),
+    "utf-8"
+  );
+  writeFileSync(join(dir, "diff.patch"), changeArtifacts.diff, "utf-8");
+
+  const summary = {
+    changed_files_total: changeArtifacts.changed_files.length,
+    additions: changeArtifacts.additions,
+    deletions: changeArtifacts.deletions,
+    patch_mode: changeArtifacts.patch_mode,
+    artifact_hygiene: changeArtifacts.artifact_hygiene,
+  };
+  writeFileSync(
+    join(dir, "summary.json"),
+    JSON.stringify(summary, null, 2),
+    "utf-8"
+  );
+  writeFileSync(join(dir, "summary.md"), formatSummaryMd(changeArtifacts), "utf-8");
+
+  return updateDirectSession(sessionId, {
+    finalized: true,
+    finalized_at: new Date().toISOString(),
+    change_artifacts: changeArtifacts,
+  });
+}
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+export function computeWorkspaceFingerprint(snapshot: RepoSnapshot): string {
+  const fileHashes = Object.entries(snapshot.files)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([path, fp]) => `${path}:${fp.sha256}`)
+    .join("\n");
+  return createHash("sha256")
+    .update(`${snapshot.head || "null"}\n${snapshot.status}\n${fileHashes}`)
+    .digest("hex");
+}
+
+function computeFallbackManifestHash(config: PatchWardenConfig): string {
+  return createHash("sha256")
+    .update(`${TOOL_SCHEMA_EPOCH}:${config.toolProfile || "full"}`)
+    .digest("hex");
+}
+
+function extractReason(error: unknown): string {
+  if (error instanceof PatchWardenError) return error.reason;
+  if (error instanceof Error) return error.message.slice(0, 80);
+  return String(error).slice(0, 80);
+}
+
+function formatSummaryMd(artifacts: ChangeArtifacts): string {
+  const lines: string[] = [
+    "# Direct Session Change Summary",
+    "",
+    `**Changed files:** ${artifacts.changed_files.length}`,
+    `**Additions:** ${artifacts.additions}`,
+    `**Deletions:** ${artifacts.deletions}`,
+    `**Patch mode:** ${artifacts.patch_mode}`,
+    "",
+    "## Artifact Hygiene",
+    "",
+    `- Source changes: ${artifacts.artifact_hygiene.counts.source_changes}`,
+    `- Tracked build artifacts: ${artifacts.artifact_hygiene.counts.tracked_build_artifacts}`,
+    `- Runtime generated files: ${artifacts.artifact_hygiene.counts.runtime_generated_files}`,
+    `- Suspicious changes: ${artifacts.artifact_hygiene.counts.suspicious_changes}`,
+    "",
+    "## Changed Files",
+    "",
+  ];
+
+  for (const file of artifacts.changed_files) {
+    lines.push(`- **${file.change}**: ${file.path}${file.old_path ? ` (from ${file.old_path})` : ""}`);
+  }
+
+  return lines.join("\n");
+}

package/src/direct/directVerification.ts

@@ -0,0 +1,138 @@
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getConfig } from "../config.js";
+import { guardDirectCommand } from "../security/commandGuard.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { runSimpleProcess } from "../runner/simpleProcess.js";
+import { getDirectSessionDir } from "./directSessionStore.js";
+import type { DirectSessionVerificationRun } from "./directSessionStore.js";
+
+const MAX_TAIL_CHARS = 10_000;
+const DEFAULT_TIMEOUT_SECONDS = 120;
+
+export interface RunDirectVerificationInput {
+  command: string;
+  resolvedRepoPath: string;
+  sessionId: string;
+  timeoutSeconds?: number;
+}
+
+export interface RunDirectVerificationResult {
+  run: DirectSessionVerificationRun;
+  log_path: string;
+}
+
+export async function runDirectVerification(
+  input: RunDirectVerificationInput
+): Promise<RunDirectVerificationResult> {
+  const config = getConfig();
+  const allowedCommand = guardDirectCommand(
+    input.command,
+    config,
+    input.resolvedRepoPath
+  );
+
+  const timeoutSeconds = input.timeoutSeconds ?? DEFAULT_TIMEOUT_SECONDS;
+  const timeoutMs = timeoutSeconds * 1000;
+
+  // Parse command into command + args
+  const parts = parseCommand(allowedCommand);
+  if (!parts) {
+    throw new Error(`Failed to parse command: "${allowedCommand}"`);
+  }
+
+  const sessionDir = getDirectSessionDir(input.sessionId);
+  const logPath = join(sessionDir, "verification.log");
+
+  const startedAt = new Date().toISOString();
+  const result = await runSimpleProcess({
+    command: parts.command,
+    args: parts.args,
+    cwd: input.resolvedRepoPath,
+    timeoutMs,
+    stdoutPath: logPath,
+    stderrPath: logPath,
+  });
+  const finishedAt = new Date().toISOString();
+
+  // Redact and truncate output
+  const stdoutRedacted = redactSensitiveContent(result.stdout || "");
+  const stderrRedacted = redactSensitiveContent(result.stderr || "");
+
+  const stdoutTail = truncateTail(stdoutRedacted.content, MAX_TAIL_CHARS);
+  const stderrTail = truncateTail(stderrRedacted.content, MAX_TAIL_CHARS);
+
+  const passed = result.exitCode === 0 && !result.timedOut;
+
+  const run: DirectSessionVerificationRun = {
+    command: allowedCommand,
+    exit_code: result.exitCode,
+    passed,
+    timed_out: result.timedOut,
+    stdout_tail: stdoutTail,
+    stderr_tail: stderrTail,
+    started_at: startedAt,
+    finished_at: finishedAt,
+    log_path: logPath,
+  };
+
+  // Write verification.json
+  const verificationJson = {
+    command: allowedCommand,
+    exit_code: result.exitCode,
+    passed,
+    timed_out: result.timedOut,
+    started_at: startedAt,
+    finished_at: finishedAt,
+    duration_ms: new Date(finishedAt).getTime() - new Date(startedAt).getTime(),
+    stdout_truncated: result.stdoutTruncated,
+    stderr_truncated: result.stderrTruncated,
+    redacted: stdoutRedacted.redacted || stderrRedacted.redacted,
+    redaction_categories: [
+      ...new Set([
+        ...stdoutRedacted.redaction_categories,
+        ...stderrRedacted.redaction_categories,
+      ]),
+    ],
+    spawn_error: result.spawnError,
+  };
+
+  writeFileSync(
+    join(sessionDir, "verification.json"),
+    JSON.stringify(verificationJson, null, 2),
+    "utf-8"
+  );
+
+  return { run, log_path: logPath };
+}
+
+// ── Helpers ────────────────────────────────────────────────────────
+
+function parseCommand(
+  command: string
+): { command: string; args: string[] } | null {
+  const trimmed = command.trim();
+  if (!trimmed) return null;
+
+  // Simple split by spaces - sufficient for allowlisted commands like "npm test"
+  const parts = trimmed.split(/\s+/);
+
+  // On Windows, npm/npx are batch files (.cmd) and spawn() cannot find them
+  // without shell resolution. Wrap with cmd.exe /c for those commands.
+  if (process.platform === "win32" && (parts[0] === "npm" || parts[0] === "npx")) {
+    return {
+      command: "cmd",
+      args: ["/c", ...parts],
+    };
+  }
+
+  return {
+    command: parts[0],
+    args: parts.slice(1),
+  };
+}
+
+function truncateTail(content: string, maxChars: number): string {
+  if (content.length <= maxChars) return content;
+  return "...(truncated)\n" + content.slice(content.length - maxChars);
+}

package/src/doctor.ts

@@ -18,7 +18,7 @@ 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 { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, selectToolsForProfile } from "./tools/toolCatalog.js";
 import { PATCHWARDEN_VERSION } from "./version.js";
 
 // ── State ──────────────────────────────────────────────────────────
@@ -65,6 +65,7 @@ function cmd(cmdStr: string): string {
 async function main() {
 
 console.log("PatchWarden Doctor\n");
+const allowDefaultConfig = process.argv.includes("--allow-default-config");
 
 // 1. Node version
 const nodeVer = process.version;
@@ -76,6 +77,24 @@ check("Node.js version", nodeMajor >= 18,
 const npmVer = cmd("npm --version");
 check("npm available", npmVer !== "", npmVer || "npm not found in PATH");
 
+// Local-only medium-risk confirmation entrypoint. It must exist as a package
+// binary but must not be exposed as an MCP tool.
+try {
+  const packageJson = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8"));
+  check(
+    "patchwarden-confirm package binary",
+    packageJson.bin?.["patchwarden-confirm"] === "dist/assessments/confirmCli.js",
+    packageJson.bin?.["patchwarden-confirm"] || "missing"
+  );
+  check(
+    "patchwarden-confirm compiled entrypoint",
+    existsSync(resolve(process.cwd(), "dist/assessments/confirmCli.js")),
+    "run npm.cmd run build"
+  );
+} catch (error) {
+  check("patchwarden-confirm package binary", false, error instanceof Error ? error.message : String(error));
+}
+
 // 3. Git
 const gitVer = cmd("git --version");
 warnCheck("Git available", gitVer !== "",
@@ -92,10 +111,14 @@ 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');
+const configDetail = configPathUsed
+  ? configPathUsed
+  : 'Create one: cp examples/config.example.json patchwarden.config.json';
+if (allowDefaultConfig) {
+  warnCheck("Config file exists", configPathUsed !== "", configDetail);
+} else {
+  check("Config file exists", configPathUsed !== "", configDetail);
+}
 
 // 5. PATCHWARDEN_CONFIG env
 if (process.env.PATCHWARDEN_CONFIG) {
@@ -219,10 +242,10 @@ const previousProfile = process.env.PATCHWARDEN_TOOL_PROFILE;
 try {
   process.env.PATCHWARDEN_TOOL_PROFILE = "full";
   const fullTools = getToolDefs();
-  const coreTools = selectToolsForProfile(fullTools, "chatgpt_core");
+  const coreTools = selectToolsForProfile(fullTools, "chatgpt_core", config?.enableDirectProfile);
   const createSchema = coreTools.find((tool) => tool.name === "create_task")?.inputSchema as any;
   const waitSchema = coreTools.find((tool) => tool.name === "wait_for_task")?.inputSchema as any;
-  check("Full tool profile exposes 22 tools", fullTools.length === 22, `${fullTools.length} tools`);
+  check("Full tool profile exposes 30 tools", fullTools.length === 30, `${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),
@@ -237,6 +260,26 @@ try {
       waitSchema?.properties?.wait_seconds
     )
   );
+
+  // chatgpt_direct profile checks
+  const directDisabledTools = selectToolsForProfile(fullTools, "chatgpt_direct", false);
+  check(
+    "chatgpt_direct disabled exposes only health_check (degraded mode)",
+    directDisabledTools.length === 1 && directDisabledTools[0].name === "health_check",
+    `${directDisabledTools.map((t) => t.name).join(", ")}`
+  );
+
+  if (config?.enableDirectProfile) {
+    const directEnabledTools = selectToolsForProfile(fullTools, "chatgpt_direct", true);
+    check(
+      `chatgpt_direct enabled exposes the exact ${CHATGPT_DIRECT_TOOL_NAMES.length}-tool manifest`,
+      JSON.stringify(directEnabledTools.map((tool) => tool.name)) === JSON.stringify(CHATGPT_DIRECT_TOOL_NAMES),
+      directEnabledTools.map((tool) => tool.name).join(", ")
+    );
+  } else {
+    results.push(`[OK]   chatgpt_direct enabled check skipped (enableDirectProfile=false)`);
+    ok++;
+  }
 } finally {
   if (previousProfile === undefined) delete process.env.PATCHWARDEN_TOOL_PROFILE;
   else process.env.PATCHWARDEN_TOOL_PROFILE = previousProfile;
@@ -290,6 +333,33 @@ for (const t of newTools) {
   check(`Tool module: ${t}`, existsSync(compiled), existsSync(compiled) ? "compiled" : "missing");
 }
 
+// Direct tool module checks
+const directToolModules = [
+  "createDirectSession",
+  "searchWorkspace",
+  "applyPatch",
+  "runVerification",
+  "finalizeDirectSession",
+  "auditSession",
+];
+for (const t of directToolModules) {
+  const compiled = resolve(process.cwd(), "dist/tools", `${t}.js`);
+  check(`Direct tool module: ${t}`, existsSync(compiled), existsSync(compiled) ? "compiled" : "missing");
+}
+
+// Direct support module checks
+const directSupportModules = [
+  "directSessionStore",
+  "directGuards",
+  "directPatch",
+  "directVerification",
+  "directAudit",
+];
+for (const t of directSupportModules) {
+  const compiled = resolve(process.cwd(), "dist/direct", `${t}.js`);
+  check(`Direct support module: ${t}`, existsSync(compiled), existsSync(compiled) ? "compiled" : "missing");
+}
+
 // Task directory writable
 if (config) {
   const tasksDir = resolve(config.workspaceRoot, config.tasksDir);
@@ -380,11 +450,37 @@ if (config) {
   }
 }
 
+// 14b. Direct profile config checks
+if (config) {
+  const directCmds = config.directAllowedCommands || [];
+  warnCheck("directAllowedCommands is non-empty", directCmds.length > 0,
+    directCmds.length > 0 ? `${directCmds.length} commands` : "No Direct commands configured");
+
+  // npm run doctor should NOT be in default Direct whitelist
+  const hasDoctor = directCmds.some((c: string) => c === "npm run doctor");
+  check("directAllowedCommands does not include npm run doctor", !hasDoctor,
+    hasDoctor ? "npm run doctor found in Direct whitelist — remove it for tighter security" : "not present");
+
+  check("directSessionTtlSeconds is valid",
+    config.directSessionTtlSeconds >= 60 && config.directSessionTtlSeconds <= 86400,
+    `${config.directSessionTtlSeconds}s`);
+
+  check("directMaxPatchBytes is positive",
+    config.directMaxPatchBytes > 0, `${config.directMaxPatchBytes}`);
+
+  check("directMaxFileBytes is positive",
+    config.directMaxFileBytes > 0, `${config.directMaxFileBytes}`);
+}
+
 // 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",
+  "scripts/patchwarden-mcp-direct.cmd",
+  "PatchWarden.cmd",
+  "scripts/manage-patchwarden.ps1",
+  "scripts/launchers/Start-PatchWarden-Direct-Tunnel.cmd",
 ];
 for (const tf of tunnelFiles) {
   const full = resolve(process.cwd(), tf);