patchwarden 1.5.1 → 1.6.2

package/dist/control/routes/workspace.js

@@ -9,13 +9,15 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { execFile } from "node:child_process";
-import { listAgents } from "../../tools/listAgents.js";
+import { listAgents } from "../../tools/workspace/listAgents.js";
 import { resolveWorkspaceRoot } from "../../config.js";
 import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { buildGitEnvironment, redactProcessOutput, resolveTrustedExecutable } from "../../runner/processSecurity.js";
 import { config, errorMessage, sendJson } from "../shared.js";
 export function handleWorkspace(res) {
     let workspaceRoot = null;
     let directories = [];
+    let internalDirectories = [];
     let agents = [];
     let configSummary = null;
     try {
@@ -26,10 +28,18 @@ export function handleWorkspace(res) {
     }
     if (workspaceRoot) {
         try {
-            directories = readdirSync(workspaceRoot, { withFileTypes: true })
-                .filter((e) => e.isDirectory())
-                .map((e) => e.name)
-                .sort();
+            const entries = readdirSync(workspaceRoot, { withFileTypes: true }).filter((e) => e.isDirectory());
+            for (const entry of entries) {
+                const child = join(workspaceRoot, entry.name);
+                const isInternal = entry.name.startsWith(".") || entry.name.startsWith("_");
+                const isGitRepo = existsSync(join(child, ".git"));
+                if (isGitRepo && !isInternal)
+                    directories.push(entry.name);
+                else
+                    internalDirectories.push(entry.name);
+            }
+            directories.sort();
+            internalDirectories.sort();
         }
         catch {
             directories = [];
@@ -51,7 +61,7 @@ export function handleWorkspace(res) {
     catch {
         configSummary = null;
     }
-    sendJson(res, 200, { workspace_root: workspaceRoot, directories, agents, config: configSummary });
+    sendJson(res, 200, { workspace_root: workspaceRoot, directories, internal_directories: internalDirectories, agents, config: configSummary });
 }
 /**
  * Lists first-level subdirectories of the workspace root and, for each one,
@@ -124,8 +134,13 @@ export function handleWorkspaceRepoStatus(res, repoParam) {
             sendJson(res, 500, { error: `workspace root unavailable: ${errorMessage(err)}` });
             return;
         }
-        // Reject obvious traversal in the raw parameter before resolving.
-        if (repoParam.includes("\0") || repoParam.includes("..")) {
+        // Reject parent traversal segments before resolving without rejecting
+        // otherwise valid names such as "release..candidate".
+        const hasParentTraversal = repoParam
+            .replace(/\\/g, "/")
+            .split("/")
+            .some((segment) => segment === "..");
+        if (repoParam.includes("\0") || hasParentTraversal) {
             sendJson(res, 400, { error: "Invalid repo path: traversal segments are not allowed" });
             return;
         }
@@ -143,27 +158,25 @@ export function handleWorkspaceRepoStatus(res, repoParam) {
             sendJson(res, 404, { error: "Repo directory not found", repo_path: repoParam });
             return;
         }
-        // Only `git status --short` is permitted; no arbitrary git subcommand.
+        // Only porcelain status is permitted; no arbitrary git subcommand.
         // Timeout guards against a hung git prompt (e.g. credential dialog).
-        execFile("git", ["status", "--short"], { cwd: repoAbs, maxBuffer: 1024 * 1024, timeout: 8000, windowsHide: true, encoding: "utf-8" }, (err, stdout, stderr) => {
+        const env = buildGitEnvironment(repoAbs);
+        let git;
+        try {
+            git = resolveTrustedExecutable("git", repoAbs, { pathValue: env.PATH });
+        }
+        catch (err) {
+            sendRepoStatusFailure(res, repoParam, repoAbs, err);
+            return;
+        }
+        execFile(git, ["status", "--porcelain=v1"], { cwd: repoAbs, env, maxBuffer: 1024 * 1024, timeout: 8000, windowsHide: true, encoding: "utf-8" }, (err, stdout, stderr) => {
             if (err) {
                 // Not a git repo, git missing, or git errored — return a structured
                 // failure rather than 500 so the UI can render it gracefully.
-                sendJson(res, 200, {
-                    repo_path: repoParam,
-                    resolved_repo_path: repoAbs,
-                    is_git_repo: false,
-                    changed_files_count: 0,
-                    untracked_count: 0,
-                    modified_count: 0,
-                    is_clean: true,
-                    short_status: "",
-                    error: errorMessage(err),
-                    stderr: stderr ? String(stderr).slice(0, 500) : "",
-                });
+                sendRepoStatusFailure(res, repoParam, repoAbs, err, stderr);
                 return;
             }
-            const text = String(stdout);
+            const text = redactProcessOutput(String(stdout));
             const lines = text.split(/\r?\n/).filter((l) => l.length > 0);
             let modified = 0;
             let untracked = 0;
@@ -191,3 +204,17 @@ export function handleWorkspaceRepoStatus(res, repoParam) {
         sendJson(res, 500, { error: errorMessage(err) });
     }
 }
+function sendRepoStatusFailure(res, repoParam, repoAbs, error, stderr = "") {
+    sendJson(res, 200, {
+        repo_path: repoParam,
+        resolved_repo_path: repoAbs,
+        is_git_repo: false,
+        changed_files_count: 0,
+        untracked_count: 0,
+        modified_count: 0,
+        is_clean: true,
+        short_status: "",
+        error: redactProcessOutput(errorMessage(error)),
+        stderr: redactProcessOutput(String(stderr || "")).slice(0, 500),
+    });
+}

package/dist/control/runtime.d.ts

@@ -1,5 +1,5 @@
-import { type TaskEntry } from "../tools/listTasks.js";
-import { type AgentAvailability } from "../tools/listAgents.js";
+import { type TaskEntry } from "../tools/tasks/listTasks.js";
+import { type AgentAvailability } from "../tools/workspace/listAgents.js";
 import { type WatcherStatusSnapshot } from "../watcherStatus.js";
 export interface HealthProbe {
     available: boolean;
@@ -82,6 +82,7 @@ export interface ControlCenterEvent {
 export declare function recordEvent(type: string, payload?: Record<string, unknown>): void;
 export declare function readEvents(limit: number): ControlCenterEvent[];
 export declare function readHiddenStaleIds(): string[];
+export declare function reconstructTaskEntry(taskId: string, statusData: Record<string, unknown>, runtimeData?: Record<string, unknown>, watcher?: WatcherStatusSnapshot): TaskEntry;
 export declare function writeHiddenStaleIds(ids: string[]): void;
 export declare function readHiddenDirectSessionIds(): string[];
 export declare function writeHiddenDirectSessionIds(ids: string[]): void;

package/dist/control/runtime.js

@@ -7,15 +7,19 @@
  * file mtime, id validation). These are pure helpers consumed by the route
  * modules; they hold no HTTP-layer concerns beyond reusing `sendJson`.
  */
-import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { get as httpGet } from "node:http";
-import { listTasks } from "../tools/listTasks.js";
-import { listAgents } from "../tools/listAgents.js";
+import { listTasks } from "../tools/tasks/listTasks.js";
+import { listAgents } from "../tools/workspace/listAgents.js";
 import { readWatcherStatus } from "../watcherStatus.js";
 import { resolveWorkspaceRoot } from "../config.js";
 import { PATCHWARDEN_VERSION } from "../version.js";
+import { isValidDirectSessionId as isValidStoredDirectSessionId } from "../direct/directSessionStore.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { withFileLockSync } from "../utils/lockedJsonFile.js";
 import { logger } from "../logging.js";
+import { TERMINAL_TASK_STATUSES as SHARED_TERMINAL_TASK_STATUSES } from "../tools/tasks/taskStates.js";
 import { config, controlCenterEventsPath, controlCenterStatusPath, errorMessage, getControlCenterLogDir, getRuntimeRoot, host, MAX_EVENT_LINES, port, readJsonFileSafe, } from "./shared.js";
 export function probeHealthStatus(targetUrl) {
     return new Promise((resolve) => {
@@ -155,16 +159,7 @@ export function resolveWorkspaceRootSafe() {
         return null;
     }
 }
-export const TERMINAL_TASK_STATUSES = new Set([
-    "done",
-    "done_by_agent",
-    "failed",
-    "failed_verification",
-    "failed_scope_violation",
-    "failed_policy_violation",
-    "canceled",
-    "timeout",
-]);
+export const TERMINAL_TASK_STATUSES = SHARED_TERMINAL_TASK_STATUSES;
 /**
  * Classify a task as stale based on Phase 2 rules:
  *  - status=running but last_heartbeat_at exceeds threshold
@@ -253,7 +248,7 @@ export function writeStatusFile() {
     };
     try {
         mkdirSync(getControlCenterLogDir(), { recursive: true });
-        writeFileSync(controlCenterStatusPath, JSON.stringify(status, null, 2), "utf-8");
+        atomicWriteJsonFileSync(controlCenterStatusPath, status);
     }
     catch (err) {
         logger.error("[control-center] Failed to write status file", { error: errorMessage(err) });
@@ -283,23 +278,18 @@ export function recordEvent(type, payload) {
     };
     try {
         mkdirSync(getControlCenterLogDir(), { recursive: true });
-        appendFileSync(controlCenterEventsPath, JSON.stringify(event) + "\n", "utf-8");
+        withFileLockSync(controlCenterEventsPath, () => {
+            appendFileSync(controlCenterEventsPath, JSON.stringify(event) + "\n", "utf-8");
+            const stat = statSync(controlCenterEventsPath);
+            if (stat.size > 512 * 1024)
+                trimEventsFileUnlocked();
+        });
     }
     catch (err) {
         logger.error("[control-center] Failed to write event", { error: errorMessage(err) });
     }
-    // Lazy trim: only when the file grows well past the cap.
-    try {
-        const stat = statSync(controlCenterEventsPath);
-        if (stat.size > 512 * 1024) {
-            trimEventsFile();
-        }
-    }
-    catch {
-        /* ignore */
-    }
 }
-function trimEventsFile() {
+function trimEventsFileUnlocked() {
     try {
         if (!existsSync(controlCenterEventsPath))
             return;
@@ -308,7 +298,7 @@ function trimEventsFile() {
         if (lines.length <= MAX_EVENT_LINES)
             return;
         const trimmed = lines.slice(lines.length - MAX_EVENT_LINES);
-        writeFileSync(controlCenterEventsPath, trimmed.join("\n") + "\n", "utf-8");
+        atomicWriteFileSync(controlCenterEventsPath, trimmed.join("\n") + "\n");
     }
     catch (err) {
         logger.error("[control-center] Failed to trim events file", { error: errorMessage(err) });
@@ -341,39 +331,74 @@ export function readHiddenStaleIds() {
     const p = join(getControlCenterLogDir(), "hidden-stale-ids.json");
     if (!existsSync(p))
         return [];
-    return readJsonFileSafe(p) || [];
+    return readStoredStringArray(p);
+}
+export function reconstructTaskEntry(taskId, statusData, runtimeData = {}, watcher = readWatcherStatusSafe()) {
+    const validAcceptance = new Set(["pending", "accepted", "rejected", "needs_fix", "blocked"]);
+    const taskStatus = String(statusData.status || "pending");
+    const acceptanceStatus = taskStatus === "done_by_agent"
+        ? (typeof statusData.acceptance_status === "string" && validAcceptance.has(statusData.acceptance_status)
+            ? statusData.acceptance_status
+            : "pending")
+        : null;
+    return {
+        task_id: taskId,
+        plan_id: String(statusData.plan_id || ""),
+        title: "",
+        agent: String(statusData.agent || ""),
+        status: taskStatus,
+        phase: String(runtimeData.phase || statusData.phase || "queued"),
+        acceptance_status: acceptanceStatus,
+        created_at: String(statusData.created_at || ""),
+        updated_at: String(statusData.updated_at || ""),
+        workspace_root: String(statusData.workspace_root || config.workspaceRoot),
+        repo_path: String(statusData.repo_path || "."),
+        resolved_repo_path: String(statusData.resolved_repo_path || statusData.repo_path || config.workspaceRoot),
+        test_command: String(statusData.test_command || ""),
+        verify_commands: Array.isArray(statusData.verify_commands)
+            ? statusData.verify_commands.filter((command) => typeof command === "string")
+            : [],
+        error: statusData.error ? String(statusData.error) : null,
+        last_heartbeat_at: String(runtimeData.last_heartbeat_at || statusData.last_heartbeat_at || statusData.updated_at || ""),
+        current_command: runtimeData.current_command === undefined ? null : String(runtimeData.current_command || "") || null,
+        timeout_seconds: Number(statusData.timeout_seconds) || config.defaultTaskTimeoutSeconds,
+        pending_reason: null,
+        watcher_status: watcher.status,
+    };
 }
 export function writeHiddenStaleIds(ids) {
     const dir = getControlCenterLogDir();
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "hidden-stale-ids.json"), JSON.stringify(ids, null, 2));
+    atomicWriteJsonFileSync(join(dir, "hidden-stale-ids.json"), normalizeStoredIds(ids));
 }
 // ── Hidden direct session IDs (local UI state) ────────────────────
 export function readHiddenDirectSessionIds() {
     const p = join(getControlCenterLogDir(), "hidden-direct-session-ids.json");
     if (!existsSync(p))
         return [];
-    return readJsonFileSafe(p) || [];
+    return readStoredStringArray(p);
 }
 export function writeHiddenDirectSessionIds(ids) {
     const dir = getControlCenterLogDir();
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, "hidden-direct-session-ids.json"), JSON.stringify(ids, null, 2));
+    atomicWriteJsonFileSync(join(dir, "hidden-direct-session-ids.json"), normalizeStoredIds(ids));
 }
 export function isValidDirectSessionId(sessionId) {
-    // Allow alphanumeric, dash, underscore only — reject path traversal and NUL.
-    return (sessionId.length > 0 &&
-        /^[A-Za-z0-9_-]+$/.test(sessionId) &&
-        !sessionId.includes("\0"));
+    return isValidStoredDirectSessionId(sessionId);
 }
 export function isValidTaskId(taskId) {
-    return !(taskId === "." ||
-        taskId === ".." ||
-        taskId.includes("/") ||
-        taskId.includes("\\") ||
-        taskId.includes("\0"));
+    return /^[A-Za-z0-9][A-Za-z0-9_-]{0,159}$/.test(taskId);
+}
+function readStoredStringArray(path) {
+    const value = readJsonFileSafe(path);
+    if (!Array.isArray(value))
+        return [];
+    return normalizeStoredIds(value);
+}
+function normalizeStoredIds(value) {
+    return [...new Set(value.filter((entry) => typeof entry === "string" && entry.length > 0))];
 }
 // ── Small shared helpers ──────────────────────────────────────────
 export function parseReviewVerdict(content) {