patchwarden 0.6.0 → 0.6.1

package/src/tools/safeStatus.ts

@@ -0,0 +1,96 @@
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { getTasksDir, getConfig, type PatchWardenConfig } from "../config.js";
+import { guardReadPath } from "../security/pathGuard.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import type { TaskStatus, TaskPhase } from "./createTask.js";
+import { readTaskRuntime } from "../taskRuntime.js";
+import { readWatcherStatus } from "../watcherStatus.js";
+
+export interface SafeStatusOutput {
+  task_id: string;
+  status: TaskStatus | "not_found";
+  phase: TaskPhase | null;
+  created_at: string | null;
+  started_at: string | null;
+  updated_at: string | null;
+  finished_at: string | null;
+  last_heartbeat_at: string | null;
+  current_command: string | null;
+  verify_status: "passed" | "failed" | "skipped" | null;
+  artifact_status: string | null;
+  watcher_state: string | null;
+  error_code: string | null;
+  error_summary: string | null;
+}
+
+export function safeStatus(taskId: string, config?: PatchWardenConfig): SafeStatusOutput {
+  const cfg = config || getConfig();
+  const tasksDir = getTasksDir(cfg);
+
+  const taskDir = resolve(tasksDir, taskId);
+  const statusFile = join(taskDir, "status.json");
+
+  // Check existence BEFORE guardReadPath so that a non-existent task
+  // returns a structured not_found response instead of throwing.
+  if (!existsSync(statusFile)) {
+    return {
+      task_id: taskId,
+      status: "not_found",
+      phase: null,
+      created_at: null,
+      started_at: null,
+      updated_at: null,
+      finished_at: null,
+      last_heartbeat_at: null,
+      current_command: null,
+      verify_status: null,
+      artifact_status: null,
+      watcher_state: null,
+      error_code: null,
+      error_summary: null,
+    };
+  }
+
+  guardReadPath(statusFile, cfg.workspaceRoot, cfg.tasksDir);
+  guardSensitivePath(statusFile);
+
+  const raw = readFileSync(statusFile, "utf-8");
+  const status = JSON.parse(raw) as Record<string, unknown>;
+  const runtime = readTaskRuntime(taskDir);
+  const phase = (runtime.phase || status.phase || "queued") as TaskPhase;
+  const watcher = readWatcherStatus(cfg);
+
+  // Extract short error summary — never the full error text
+  let errorCode: string | null = null;
+  let errorSummary: string | null = null;
+  if (status.error && typeof status.error === "string") {
+    const errorStr = status.error as string;
+    // Keep only the first 200 chars as summary
+    errorSummary = errorStr.length > 200 ? errorStr.slice(0, 200) + "..." : errorStr;
+    // Try to extract an error code from the status
+    if (typeof status.status === "string" && (status.status as string).startsWith("failed")) {
+      errorCode = status.status as string;
+    }
+  } else if (typeof status.status === "string" && (status.status as string).startsWith("failed")) {
+    errorCode = status.status as string;
+    errorSummary = `Task ended with status: ${status.status}`;
+  }
+
+  return {
+    task_id: taskId,
+    status: (status.status as TaskStatus) || "not_found",
+    phase,
+    created_at: typeof status.created_at === "string" ? status.created_at : null,
+    started_at: typeof status.started_at === "string" ? status.started_at : null,
+    updated_at: typeof status.updated_at === "string" ? status.updated_at : null,
+    finished_at: typeof status.finished_at === "string" ? status.finished_at : null,
+    last_heartbeat_at: runtime.last_heartbeat_at || (typeof status.last_heartbeat_at === "string" ? status.last_heartbeat_at : null),
+    current_command: runtime.current_command ?? (typeof status.current_command === "string" ? status.current_command : null) ?? null,
+    verify_status: typeof status.verify_status === "string" ? (status.verify_status as "passed" | "failed" | "skipped") : null,
+    artifact_status: typeof status.artifact_status === "string" ? status.artifact_status : null,
+    watcher_state: watcher.status,
+    error_code: errorCode,
+    error_summary: errorSummary,
+  };
+}

package/src/tools/syncFile.ts

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { dirname, resolve, relative, isAbsolute } from "node:path";
+import { PatchWardenError } from "../errors.js";
+import { getConfig, type PatchWardenConfig } from "../config.js";
+import { guardDirectPath, guardDirectWritePath } from "../direct/directGuards.js";
+import { guardSensitivePath } from "../security/sensitiveGuard.js";
+import { computeFileSha256 } from "../direct/directPatch.js";
+
+export interface SyncFileResult {
+  source_path: string;
+  target_path: string;
+  before_target_sha256: string | null;
+  after_target_sha256: string;
+  source_sha256: string;
+  copied_bytes: number;
+  changed: boolean;
+}
+
+/**
+ * Copy a file from source to target within the same session repo.
+ * Both source and target must be inside the session's repo_path.
+ */
+export function syncFile(
+  sessionId: string,
+  sourcePath: string,
+  targetPath: string,
+  options?: {
+    expected_source_sha256?: string;
+    expected_target_sha256?: string;
+  },
+  config?: PatchWardenConfig
+): SyncFileResult {
+  const cfg = config || getConfig();
+  const sessionsDir = resolve(cfg.workspaceRoot, cfg.directSessionsDir);
+
+  // Load session to get repo_path
+  const sessionFile = resolve(sessionsDir, sessionId, "session.json");
+  if (!existsSync(sessionFile)) {
+    throw new PatchWardenError(
+      "direct_session_not_found",
+      `Direct session "${sessionId}" not found.`,
+      "Create a direct session first using direct_start_session.",
+      true,
+      { session_id: sessionId }
+    );
+  }
+
+  const session = JSON.parse(readFileSync(sessionFile, "utf-8"));
+  const repoPath = resolve(session.repo_path);
+  const workspaceRoot = cfg.workspaceRoot;
+
+  // Guard source path — must be inside repo
+  const resolvedSource = guardDirectPath(sourcePath, repoPath, workspaceRoot);
+  guardSensitivePath(resolvedSource);
+
+  if (!existsSync(resolvedSource)) {
+    throw new PatchWardenError(
+      "source_file_not_found",
+      `Source file does not exist: "${sourcePath}".`,
+      "Ensure the source path is correct.",
+      true,
+      { source_path: sourcePath }
+    );
+  }
+
+  // Guard target path — must be inside repo, not in blocked dirs
+  const resolvedTarget = guardDirectWritePath(targetPath, repoPath, workspaceRoot);
+  guardSensitivePath(resolvedTarget);
+
+  // Verify source sha256 if provided
+  const sourceSha256 = computeFileSha256(resolvedSource);
+  if (options?.expected_source_sha256 && options.expected_source_sha256 !== sourceSha256) {
+    throw new PatchWardenError(
+      "source_hash_mismatch",
+      `Source file hash mismatch. Expected "${options.expected_source_sha256}" but got "${sourceSha256}".`,
+      "Re-read the source file to get the current sha256.",
+      true,
+      { expected_sha256: options.expected_source_sha256, actual_sha256: sourceSha256 }
+    );
+  }
+
+  // Get target sha256 before copy
+  let beforeTargetSha256: string | null = null;
+  if (existsSync(resolvedTarget)) {
+    beforeTargetSha256 = computeFileSha256(resolvedTarget);
+    // Verify target sha256 if provided
+    if (options?.expected_target_sha256 && options.expected_target_sha256 !== beforeTargetSha256) {
+      throw new PatchWardenError(
+        "target_hash_mismatch",
+        `Target file hash mismatch. Expected "${options.expected_target_sha256}" but got "${beforeTargetSha256}".`,
+        "Re-read the target file to get the current sha256.",
+        true,
+        { expected_sha256: options.expected_target_sha256, actual_sha256: beforeTargetSha256 }
+      );
+    }
+  }
+
+  // Read source content
+  const sourceContent = readFileSync(resolvedSource);
+  const copiedBytes = sourceContent.length;
+
+  // Create target directory if needed
+  mkdirSync(dirname(resolvedTarget), { recursive: true });
+
+  // Write to target
+  writeFileSync(resolvedTarget, sourceContent, "utf-8");
+
+  // Compute after hash
+  const afterTargetSha256 = computeFileSha256(resolvedTarget);
+  const changed = beforeTargetSha256 !== afterTargetSha256;
+
+  return {
+    source_path: sourcePath,
+    target_path: targetPath,
+    before_target_sha256: beforeTargetSha256,
+    after_target_sha256: afterTargetSha256,
+    source_sha256: sourceSha256,
+    copied_bytes: copiedBytes,
+    changed,
+  };
+}

package/src/tools/toolCatalog.ts

@@ -35,6 +35,7 @@ export const CHATGPT_CORE_TOOL_NAMES = [
   "list_tasks",
   "cancel_task",
   "audit_task",
+  "safe_status",
 ] as const;
 
 export const CHATGPT_DIRECT_TOOL_NAMES = [
@@ -47,6 +48,7 @@ export const CHATGPT_DIRECT_TOOL_NAMES = [
   "run_verification",
   "finalize_direct_session",
   "audit_session",
+  "sync_file",
 ] as const;
 
 let lastSnapshot: ToolCatalogSnapshot | null = null;

package/src/version.ts

@@ -1,2 +1,2 @@
-export const PATCHWARDEN_VERSION = "0.6.0";
-export const TOOL_SCHEMA_EPOCH = "2026-06-22-v6";
+export const PATCHWARDEN_VERSION = "0.6.1";
+export const TOOL_SCHEMA_EPOCH = "2026-06-24-v7";

package/src/watcherStatus.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getConfig, getTasksDir, type PatchWardenConfig } from "./config.js";
 
@@ -24,6 +24,7 @@ export interface WatcherStatusSnapshot {
   instance_id: string | null;
   launcher_pid: number | null;
   reason: string | null;
+  activity: string | null;
 }
 
 export function getWatcherHeartbeatPath(config: PatchWardenConfig = getConfig()): string {
@@ -37,6 +38,22 @@ export function readWatcherStatus(
   const staleAfterSeconds = config.watcherStaleSeconds;
   const heartbeatPath = getWatcherHeartbeatPath(config);
   if (!existsSync(heartbeatPath)) {
+    // Even if watcher heartbeat is missing, check if a task is actively running
+    const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+    if (taskFallback) {
+      return {
+        status: "healthy",
+        available: true,
+        stale_after_seconds: staleAfterSeconds,
+        last_heartbeat_at: taskFallback.heartbeat_at,
+        heartbeat_age_seconds: taskFallback.age_seconds,
+        heartbeat_pid: null,
+        instance_id: null,
+        launcher_pid: null,
+        reason: null,
+        activity: taskFallback.activity,
+      };
+    }
     return {
       status: "missing",
       available: false,
@@ -47,6 +64,7 @@ export function readWatcherStatus(
       instance_id: null,
       launcher_pid: null,
       reason: "Watcher heartbeat has not been observed. Start or restart the PatchWarden watcher.",
+      activity: null,
     };
   }
 
@@ -58,16 +76,47 @@ export function readWatcherStatus(
     const ageMs = Math.max(0, nowMs - heartbeatMs);
     const ageSeconds = Math.round(ageMs / 1000);
     const healthy = ageMs < staleAfterSeconds * 1000;
+    if (healthy) {
+      return {
+        status: "healthy",
+        available: true,
+        stale_after_seconds: staleAfterSeconds,
+        last_heartbeat_at: String(data.last_heartbeat_at),
+        heartbeat_age_seconds: ageSeconds,
+        heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+        instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+        launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+        reason: null,
+        activity: null,
+      };
+    }
+    // Watcher heartbeat is stale — check if a task is actively running
+    const taskFallback = checkRunningTaskHeartbeat(config, nowMs, staleAfterSeconds);
+    if (taskFallback) {
+      return {
+        status: "healthy",
+        available: true,
+        stale_after_seconds: staleAfterSeconds,
+        last_heartbeat_at: taskFallback.heartbeat_at,
+        heartbeat_age_seconds: taskFallback.age_seconds,
+        heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
+        instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
+        launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
+        reason: null,
+        activity: taskFallback.activity,
+      };
+    }
     return {
-      status: healthy ? "healthy" : "stale",
-      available: healthy,
+      status: "stale",
+      available: false,
       stale_after_seconds: staleAfterSeconds,
       last_heartbeat_at: String(data.last_heartbeat_at),
       heartbeat_age_seconds: ageSeconds,
       heartbeat_pid: Number.isInteger(Number(data.pid)) ? Number(data.pid) : null,
       instance_id: typeof data.instance_id === "string" ? data.instance_id : null,
       launcher_pid: Number.isInteger(Number(data.launcher_pid)) ? Number(data.launcher_pid) : null,
-      reason: healthy ? null : "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+      reason: "Watcher heartbeat is stale. Restart the PatchWarden watcher.",
+      activity: null,
     };
   } catch {
     return {
@@ -80,10 +129,58 @@ export function readWatcherStatus(
       instance_id: null,
       launcher_pid: null,
       reason: "Watcher heartbeat file is unreadable.",
+      activity: null,
     };
   }
 }
 
+interface TaskHeartbeatFallback {
+  heartbeat_at: string;
+  age_seconds: number;
+  activity: string;
+}
+
+function checkRunningTaskHeartbeat(
+  config: PatchWardenConfig,
+  nowMs: number,
+  staleAfterSeconds: number
+): TaskHeartbeatFallback | null {
+  const tasksDir = getTasksDir(config);
+  if (!existsSync(tasksDir)) return null;
+  let entries;
+  try {
+    entries = readdirSync(tasksDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const taskDir = join(tasksDir, entry.name);
+    const statusFile = join(taskDir, "status.json");
+    const runtimeFile = join(taskDir, "runtime.json");
+    if (!existsSync(statusFile) || !existsSync(runtimeFile)) continue;
+    try {
+      const status = JSON.parse(readFileSync(statusFile, "utf-8"));
+      if (status.status !== "running") continue;
+      const runtime = JSON.parse(readFileSync(runtimeFile, "utf-8"));
+      const heartbeatAt = String(runtime.last_heartbeat_at || "");
+      const heartbeatMs = Date.parse(heartbeatAt);
+      if (!Number.isFinite(heartbeatMs)) continue;
+      const ageMs = Math.max(0, nowMs - heartbeatMs);
+      if (ageMs < staleAfterSeconds * 1000) {
+        return {
+          heartbeat_at: heartbeatAt,
+          age_seconds: Math.round(ageMs / 1000),
+          activity: `watcher busy executing task ${entry.name}`,
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
 export function derivePendingReason(
   task: { status?: string; phase?: string },
   watcher: WatcherStatusSnapshot