patchwarden 1.5.0 → 1.5.1

package/dist/control/routes/status.js

@@ -0,0 +1,250 @@
+/**
+ * Control Center routes — runtime status, events, diagnostics, tunnel URLs.
+ *
+ * `handleStatus` is the dashboard's primary poll endpoint: it fans out health
+ * probes, watcher/task snapshots, and suggestion generation, and records
+ * observed state-change events (core/direct/watcher/task transitions) into the
+ * activity timeline. The remaining endpoints expose the control-center status
+ * file, the event timeline, diagnostics (redacted), and tunnel UI URLs.
+ */
+import { existsSync } from "node:fs";
+import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import { listAgentsSafe, listTasksForStatus, probeRuntimeHealth, readEvents, recordEvent, readToolManifest, readTunnelStatus, readTunnelUrl, readWatcherStatusSafe, resolveWorkspaceRootSafe, } from "../runtime.js";
+import { findTunnelClientExecutable } from "./process.js";
+import { config, controlCenterStatusPath, CORE_BASE_URL, DEFAULT_TUNNEL_CLIENT_EXE, DIRECT_BASE_URL, errorMessage, readJsonFileSafe, sendJson, } from "../shared.js";
+function buildSuggestions(s) {
+    const out = [];
+    if (!s.core.available) {
+        out.push({
+            code: "core_stopped",
+            severity: "warning",
+            message: "Core 未运行，建议启动 Core profile",
+            action: "/api/core/start",
+        });
+    }
+    if (!s.direct.available) {
+        out.push({
+            code: "direct_stopped",
+            severity: "warning",
+            message: "Direct 未运行，建议启动 Direct profile",
+            action: "/api/direct/start",
+        });
+    }
+    if (s.watcher.status === "stale" || s.watcher.status === "unreadable") {
+        out.push({
+            code: "watcher_stale",
+            severity: "error",
+            message: "Watcher 处于 " + s.watcher.status + " 状态，建议 Restart All",
+            action: "/api/restart-all",
+        });
+    }
+    if (s.tasks.stale > 0) {
+        out.push({
+            code: "stale_task",
+            severity: "warning",
+            message: "存在 " + s.tasks.stale + " 个 stale 任务，建议查看并 reconcile",
+            link: "/pages/tasks.html?filter=stale",
+        });
+    }
+    const coreTunnelReady = !!(s.tunnel.core && s.tunnel.core.ready);
+    const directTunnelReady = !!(s.tunnel.direct && s.tunnel.direct.ready);
+    if (!coreTunnelReady || !directTunnelReady) {
+        out.push({
+            code: "tunnel_not_ready",
+            severity: "warning",
+            message: "Tunnel 未就绪，建议重启 profile 或检查代理",
+            action: "/api/restart-all",
+        });
+    }
+    const missingAgents = s.agents.filter((a) => !a.available);
+    if (missingAgents.length > 0) {
+        out.push({
+            code: "agent_missing",
+            severity: "info",
+            message: "Agent 未就绪：" + missingAgents.map((a) => a.name).join(", ") + "（请检查 opencode/claude 路径）",
+        });
+    }
+    return out;
+}
+let lastStatusDigest = null;
+function buildStatusDigest(s) {
+    const task_statuses = {};
+    for (const t of s.tasks.tasks) {
+        const entry = t;
+        task_statuses[entry.task_id] = entry.status;
+    }
+    return {
+        core_available: s.core.available,
+        direct_available: s.direct.available,
+        watcher_status: s.watcher.status,
+        task_statuses,
+    };
+}
+function diffAndRecordEvents(prev, curr) {
+    if (prev.core_available !== curr.core_available) {
+        recordEvent("core.status_changed", { from: prev.core_available, to: curr.core_available });
+    }
+    if (prev.direct_available !== curr.direct_available) {
+        recordEvent("direct.status_changed", { from: prev.direct_available, to: curr.direct_available });
+    }
+    if (prev.watcher_status !== curr.watcher_status) {
+        recordEvent("watcher.status_changed", { from: prev.watcher_status, to: curr.watcher_status });
+    }
+    for (const [taskId, newStatus] of Object.entries(curr.task_statuses)) {
+        const oldStatus = prev.task_statuses[taskId];
+        if (oldStatus && oldStatus !== newStatus) {
+            recordEvent("task.status_changed", { task_id: taskId, from: oldStatus, to: newStatus });
+        }
+    }
+}
+// ── Handlers ──────────────────────────────────────────────────────
+export async function handleStatus(res) {
+    try {
+        const [coreHealth, directHealth, watcher, tunnelCore, tunnelDirect, toolsCore, toolsDirect, agents, workspaceRoot, tasks] = await Promise.all([
+            probeRuntimeHealth(CORE_BASE_URL).catch((err) => ({
+                available: false,
+                reason: errorMessage(err),
+                healthz: null,
+                readyz: null,
+            })),
+            probeRuntimeHealth(DIRECT_BASE_URL).catch((err) => ({
+                available: false,
+                reason: errorMessage(err),
+                healthz: null,
+                readyz: null,
+            })),
+            Promise.resolve(readWatcherStatusSafe()),
+            Promise.resolve(readTunnelStatus(false)),
+            Promise.resolve(readTunnelStatus(true)),
+            Promise.resolve(readToolManifest(false)),
+            Promise.resolve(readToolManifest(true)),
+            Promise.resolve(listAgentsSafe()),
+            Promise.resolve(resolveWorkspaceRootSafe()),
+            Promise.resolve(listTasksForStatus()),
+        ]);
+        const snapshotForSuggestions = {
+            core: coreHealth,
+            direct: directHealth,
+            watcher,
+            tunnel: { core: tunnelCore, direct: tunnelDirect },
+            agents,
+            tasks,
+        };
+        const suggestions = buildSuggestions(snapshotForSuggestions);
+        const tunnelClientExe = findTunnelClientExecutable();
+        // Diff against the previous poll to record observed state-change events.
+        // This is the only place that observes Core/Direct/watcher/task transitions
+        // (the control center is otherwise stateless and pull-driven).
+        const digest = buildStatusDigest(snapshotForSuggestions);
+        if (lastStatusDigest) {
+            diffAndRecordEvents(lastStatusDigest, digest);
+        }
+        lastStatusDigest = digest;
+        sendJson(res, 200, {
+            core: coreHealth,
+            direct: directHealth,
+            watcher,
+            tunnel: { core: tunnelCore, direct: tunnelDirect },
+            tools: { core: toolsCore, direct: toolsDirect },
+            agents,
+            workspace_root: workspaceRoot,
+            tasks,
+            suggestions,
+            setup: {
+                tunnel_client: {
+                    available: tunnelClientExe !== null,
+                    path: tunnelClientExe,
+                    default_path: DEFAULT_TUNNEL_CLIENT_EXE,
+                },
+                workspace_root: workspaceRoot,
+                watcher: {
+                    status: watcher.status,
+                    available: watcher.available,
+                    reason: watcher.reason,
+                },
+            },
+        });
+    }
+    catch (err) {
+        sendJson(res, 200, { error: errorMessage(err), partial: true });
+    }
+}
+export function handleControlCenterStatus(res) {
+    // Public read of the status file (used by tray/launcher to confirm identity).
+    if (!existsSync(controlCenterStatusPath)) {
+        sendJson(res, 200, { running: false });
+        return;
+    }
+    const data = readJsonFileSafe(controlCenterStatusPath);
+    if (!data) {
+        sendJson(res, 200, { running: false });
+        return;
+    }
+    sendJson(res, 200, { running: true, ...data });
+}
+export function handleEvents(res, limit) {
+    const events = readEvents(limit);
+    sendJson(res, 200, {
+        events,
+        total: events.length,
+        limit,
+    });
+}
+export function handleTunnelUiUrl(res) {
+    sendJson(res, 200, {
+        core: readTunnelUrl(false),
+        direct: readTunnelUrl(true),
+    });
+}
+export function handleDiagnostics(res) {
+    try {
+        const watcher = readWatcherStatusSafe();
+        const tunnelCore = readTunnelStatus(false);
+        const tunnelDirect = readTunnelStatus(true);
+        const toolsCore = readToolManifest(false);
+        const toolsDirect = readToolManifest(true);
+        const agents = listAgentsSafe();
+        let workspaceRoot = null;
+        try {
+            workspaceRoot = resolveWorkspaceRootSafe();
+        }
+        catch {
+            workspaceRoot = null;
+        }
+        // Recent failures: last 5 failed tasks (status contains "failed")
+        let recentFailures = [];
+        try {
+            const result = listTasksForStatus();
+            recentFailures = result.tasks
+                .filter((t) => typeof t.status === "string" && t.status.includes("failed"))
+                .slice(0, 5)
+                .map((t) => ({ task_id: t.task_id, status: t.status }));
+        }
+        catch {
+            recentFailures = [];
+        }
+        const coreReady = !!(tunnelCore && tunnelCore.ready);
+        const directReady = !!(tunnelDirect && tunnelDirect.ready);
+        const diagnostics = {
+            server_version: PATCHWARDEN_VERSION,
+            schema_epoch: TOOL_SCHEMA_EPOCH,
+            tool_manifest_sha256: toolsCore.tool_manifest_sha256,
+            watcher_status: watcher.status,
+            tunnel_core_ready: coreReady,
+            tunnel_direct_ready: directReady,
+            core_tool_count: toolsCore.tool_count,
+            direct_tool_count: toolsDirect.tool_count,
+            agent_status: agents.map((a) => ({ name: a.name, available: a.available })),
+            workspace_root: workspaceRoot,
+            recent_failures: recentFailures,
+            direct_profile_enabled: config.enableDirectProfile ?? false,
+        };
+        // Redact any sensitive content that may have leaked into string fields.
+        const redacted = redactSensitiveValue(diagnostics);
+        sendJson(res, 200, redacted.value);
+    }
+    catch (err) {
+        sendJson(res, 200, { error: errorMessage(err) });
+    }
+}

package/dist/control/routes/taskActions.d.ts

@@ -0,0 +1,21 @@
+import { type ServerResponse } from "node:http";
+/**
+ * Reconcile a stale task. Does NOT delete the task. Reads the task files,
+ * decides whether it is safe to mark the task as stale/archived, writes a
+ * reconcile record, and (when safe) annotates status.json with reconcile
+ * metadata. The task status enum is never changed — only metadata is added.
+ */
+export declare function handleReconcile(res: ServerResponse, taskId: string): void;
+/**
+ * Run audit_task for a task. Only safe to delegate when the task directory
+ * exists and the task is in a terminal state (auditing a running task mid-flight
+ * would race with the watcher writing artifacts).
+ */
+export declare function handleTaskAudit(res: ServerResponse, taskId: string): void;
+export declare function handleOpenTaskFolder(res: ServerResponse, taskId: string): void;
+/**
+ * Hide a stale task from the dashboard's stale-task view. The task itself is
+ * NOT deleted or modified — only the control-center's local hidden-stale-ids
+ * state file is updated. Requires control token (enforced by the POST router).
+ */
+export declare function handleHideStale(res: ServerResponse, taskId: string): void;

package/dist/control/routes/taskActions.js

@@ -0,0 +1,233 @@
+/**
+ * Control Center routes — mutating task actions (POST /api/tasks/:id/*).
+ *
+ * These handlers are invoked only after the server router has validated the
+ * control token. They cover reconcile, on-demand audit_task, opening the task
+ * folder in the host file explorer, and hiding a stale task from the
+ * dashboard. None of them delete task files; they annotate or launch external
+ * viewers.
+ */
+import { existsSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { auditTask } from "../../tools/auditTask.js";
+import { getTasksDir } from "../../config.js";
+import { classifyStaleTask, isValidTaskId, readHiddenStaleIds, readWatcherStatusSafe, recordEvent, TERMINAL_TASK_STATUSES, writeHiddenStaleIds, } from "../runtime.js";
+import { config, errorMessage, readJsonFileSafe, sendJson } from "../shared.js";
+/**
+ * Reconcile a stale task. Does NOT delete the task. Reads the task files,
+ * decides whether it is safe to mark the task as stale/archived, writes a
+ * reconcile record, and (when safe) annotates status.json with reconcile
+ * metadata. The task status enum is never changed — only metadata is added.
+ */
+export function handleReconcile(res, taskId) {
+    try {
+        if (!isValidTaskId(taskId)) {
+            sendJson(res, 400, { error: "Invalid task id" });
+            return;
+        }
+        const tasksDir = getTasksDir(config);
+        const taskDir = join(tasksDir, taskId);
+        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+            sendJson(res, 404, { error: "Task not found" });
+            return;
+        }
+        const statusPath = join(taskDir, "status.json");
+        const runtimePath = join(taskDir, "runtime.json");
+        const statusData = readJsonFileSafe(statusPath) ?? {};
+        const runtimeData = readJsonFileSafe(runtimePath) ?? {};
+        const watcher = readWatcherStatusSafe();
+        const VALID_ACCEPTANCE = ["pending", "accepted", "rejected", "needs_fix", "blocked"];
+        const taskStatus = String(statusData.status || "pending");
+        const taskAcceptanceStatus = taskStatus === "done_by_agent"
+            ? (typeof statusData.acceptance_status === "string" && VALID_ACCEPTANCE.includes(statusData.acceptance_status) ? statusData.acceptance_status : "pending")
+            : null;
+        const taskEntry = {
+            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: taskAcceptanceStatus,
+            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 : [],
+            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,
+        };
+        const cls = classifyStaleTask(taskEntry, watcher);
+        const isTerminal = TERMINAL_TASK_STATUSES.has(taskEntry.status);
+        // Safe to mark stale/archived when:
+        //  - terminal status  -> archive (already finished)
+        //  - stale AND watcher is not actively driving it (no current_command OR watcher not healthy)
+        let decision;
+        let safe = false;
+        if (isTerminal) {
+            decision = "marked_archived";
+            safe = true;
+        }
+        else if (cls.is_stale &&
+            (taskEntry.current_command === null || taskEntry.current_command === "" || watcher.status !== "healthy")) {
+            decision = "marked_stale";
+            safe = true;
+        }
+        else {
+            decision = "no_action";
+            safe = false;
+        }
+        const reconciledAt = new Date().toISOString();
+        const reconcileRecord = {
+            task_id: taskId,
+            reconciled_at: reconciledAt,
+            decision,
+            safe,
+            previous_status: taskEntry.status,
+            previous_phase: taskEntry.phase,
+            is_stale: cls.is_stale,
+            stale_reasons: cls.stale_reasons,
+            watcher_status: watcher.status,
+            watcher_last_heartbeat_at: watcher.last_heartbeat_at,
+            task_last_heartbeat_at: taskEntry.last_heartbeat_at || null,
+            task_current_command: taskEntry.current_command,
+            notes: decision === "no_action"
+                ? "Task does not currently qualify for safe reconcile (still actively running or watcher is healthy)."
+                : "Task annotated with reconcile metadata; original status preserved. No files were deleted.",
+        };
+        // Write the reconcile record artifact.
+        try {
+            writeFileSync(join(taskDir, "reconcile.json"), JSON.stringify(reconcileRecord, null, 2), "utf-8");
+        }
+        catch (writeErr) {
+            sendJson(res, 500, { error: `Failed to write reconcile record: ${errorMessage(writeErr)}` });
+            return;
+        }
+        // Annotate status.json with reconcile metadata (do not mutate status enum).
+        if (safe) {
+            const annotated = {
+                ...statusData,
+                reconcile_state: decision === "marked_archived" ? "archived" : "stale",
+                reconciled_at: reconciledAt,
+            };
+            try {
+                writeFileSync(statusPath, JSON.stringify(annotated, null, 2), "utf-8");
+            }
+            catch (writeErr) {
+                sendJson(res, 500, { error: `Failed to annotate status.json: ${errorMessage(writeErr)}` });
+                return;
+            }
+        }
+        recordEvent("task.reconciled", {
+            task_id: taskId,
+            decision,
+            safe,
+            previous_status: taskEntry.status,
+            is_stale: cls.is_stale,
+        });
+        sendJson(res, 200, reconcileRecord);
+    }
+    catch (err) {
+        sendJson(res, 500, { error: errorMessage(err) });
+    }
+}
+/**
+ * Run audit_task for a task. Only safe to delegate when the task directory
+ * exists and the task is in a terminal state (auditing a running task mid-flight
+ * would race with the watcher writing artifacts).
+ */
+export function handleTaskAudit(res, taskId) {
+    try {
+        if (!isValidTaskId(taskId)) {
+            sendJson(res, 400, { error: "Invalid task id" });
+            return;
+        }
+        const tasksDir = getTasksDir(config);
+        const taskDir = join(tasksDir, taskId);
+        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+            sendJson(res, 404, { error: "Task not found" });
+            return;
+        }
+        const statusData = readJsonFileSafe(join(taskDir, "status.json"));
+        const taskStatus = statusData ? String(statusData.status || "") : "";
+        if (!TERMINAL_TASK_STATUSES.has(taskStatus)) {
+            sendJson(res, 409, {
+                error: "Task is not in a terminal state; audit_task can only run safely after completion.",
+                status: taskStatus || "unknown",
+            });
+            return;
+        }
+        const output = auditTask(taskId);
+        recordEvent("task.audited", { task_id: taskId, previous_status: taskStatus });
+        sendJson(res, 200, { ok: true, audit: output });
+    }
+    catch (err) {
+        sendJson(res, 500, { error: errorMessage(err) });
+    }
+}
+export function handleOpenTaskFolder(res, taskId) {
+    try {
+        if (!isValidTaskId(taskId)) {
+            sendJson(res, 400, { error: "Invalid task id" });
+            return;
+        }
+        const tasksDir = getTasksDir(config);
+        const taskDir = join(tasksDir, taskId);
+        if (!existsSync(taskDir) || !statSync(taskDir).isDirectory()) {
+            sendJson(res, 404, { error: "Task not found" });
+            return;
+        }
+        let cmd;
+        if (process.platform === "win32") {
+            cmd = "explorer.exe";
+        }
+        else if (process.platform === "darwin") {
+            cmd = "open";
+        }
+        else {
+            cmd = "xdg-open";
+        }
+        try {
+            const child = spawn(cmd, [taskDir], { detached: true, stdio: "ignore" });
+            child.on("error", () => { });
+            child.unref();
+        }
+        catch {
+            /* ignore */
+        }
+        sendJson(res, 200, { ok: true, path: taskDir });
+    }
+    catch (err) {
+        sendJson(res, 500, { error: errorMessage(err) });
+    }
+}
+/**
+ * Hide a stale task from the dashboard's stale-task view. The task itself is
+ * NOT deleted or modified — only the control-center's local hidden-stale-ids
+ * state file is updated. Requires control token (enforced by the POST router).
+ */
+export function handleHideStale(res, taskId) {
+    try {
+        if (!isValidTaskId(taskId)) {
+            sendJson(res, 400, { error: "Invalid task id" });
+            return;
+        }
+        const ids = readHiddenStaleIds();
+        if (!ids.includes(taskId)) {
+            ids.push(taskId);
+            writeHiddenStaleIds(ids);
+        }
+        recordEvent("task.hide_stale", { task_id: taskId });
+        sendJson(res, 200, { ok: true, hidden: taskId });
+    }
+    catch (err) {
+        sendJson(res, 500, { error: errorMessage(err) });
+    }
+}

package/dist/control/routes/tasks.d.ts

@@ -0,0 +1,20 @@
+import { type ServerResponse } from "node:http";
+export interface TaskFilters {
+    repo_path?: string;
+    status?: string;
+    acceptance_status?: string;
+    agent?: string;
+    warning_type?: string;
+}
+export declare function handleTasks(res: ServerResponse, filters?: TaskFilters): void;
+export declare function deriveStaleReasonCode(staleReasons: string[]): string;
+export declare function staleExplanationFor(reasonCode: string): {
+    explanation: string;
+    next_action: string;
+};
+export declare function handleStaleTasks(res: ServerResponse): void;
+export declare function handleTaskDetail(res: ServerResponse, taskId: string): void;
+export declare function handleTaskSafeResult(res: ServerResponse, taskId: string): void;
+export declare function handleTaskSafeAudit(res: ServerResponse, taskId: string): void;
+export declare function handleTaskSafeTestSummary(res: ServerResponse, taskId: string): void;
+export declare function handleTaskSafeDiffSummary(res: ServerResponse, taskId: string): void;