patchwarden 0.6.4 → 1.1.0

package/src/runner/postTaskCleanup.ts

@@ -0,0 +1,154 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
+
+const EXCLUDED_DIRS = new Set([".git", ".patchwarden", ".venv", "node_modules", "samples", "docs"]);
+const CLEANUP_DIRS = new Set(["__pycache__", "dist", "release_packages", "temp_files"]);
+const CLEANUP_FILES = [/\.pyc$/i];
+
+export interface PostTaskCleanupEntry {
+  path: string;
+  reason: string;
+}
+
+export interface PostTaskCleanupReport {
+  enabled: boolean;
+  removed: PostTaskCleanupEntry[];
+  skipped: Array<PostTaskCleanupEntry & { skip_reason: string }>;
+  source_files_touched: number;
+}
+
+export function runPostTaskCleanup(repoPath: string, taskDir: string): PostTaskCleanupReport {
+  const report: PostTaskCleanupReport = {
+    enabled: true,
+    removed: [],
+    skipped: [],
+    source_files_touched: 0,
+  };
+  const root = resolve(repoPath);
+  const candidates = collectCandidates(root);
+  for (const candidate of candidates) {
+    const rel = toRepoRelative(root, candidate.path);
+    if (!rel || isExcluded(rel)) {
+      report.skipped.push({ path: rel || ".", reason: candidate.reason, skip_reason: "excluded_path" });
+      continue;
+    }
+    if (hasTrackedGitContent(root, rel)) {
+      report.skipped.push({ path: rel, reason: candidate.reason, skip_reason: "tracked_by_git" });
+      continue;
+    }
+    if (!isIgnoredOrUntracked(root, rel)) {
+      report.skipped.push({ path: rel, reason: candidate.reason, skip_reason: "not_ignored_or_untracked" });
+      continue;
+    }
+    try {
+      rmSync(candidate.path, { recursive: true, force: true });
+      report.removed.push({ path: rel, reason: candidate.reason });
+    } catch (error) {
+      report.skipped.push({
+        path: rel,
+        reason: candidate.reason,
+        skip_reason: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+  writeFileSync(join(taskDir, "post-task-cleanup.json"), JSON.stringify(report, null, 2), "utf-8");
+  return report;
+}
+
+function collectCandidates(root: string): PostTaskCleanupEntry[] {
+  const found = new Map<string, string>();
+  walk(root, (path, isDir) => {
+    const name = basename(path);
+    if (isDir) {
+      if (name === "__pycache__") found.set(path, "python_bytecode_cache");
+      if (name === "dist" && toRepoRelative(root, path) === "frontend/dist") found.set(path, "frontend_build_output");
+      if (name === "release_packages") found.set(path, "release_package_output");
+      if (name === "temp_files" && toRepoRelative(root, path) === "backend/temp_files") found.set(path, "backend_temp_files");
+    } else if (CLEANUP_FILES.some((pattern) => pattern.test(name))) {
+      found.set(path, "python_bytecode_file");
+    }
+  });
+  return [...found].map(([path, reason]) => ({ path, reason }));
+}
+
+function walk(dir: string, visit: (path: string, isDir: boolean) => void): void {
+  if (!existsSync(dir)) return;
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    const isDir = entry.isDirectory();
+    visit(full, isDir);
+    if (isDir && !EXCLUDED_DIRS.has(entry.name) && !CLEANUP_DIRS.has(entry.name)) {
+      walk(full, visit);
+    }
+  }
+}
+
+function hasTrackedGitContent(root: string, rel: string): boolean {
+  if (!isGitWorktree(root)) return false;
+  try {
+    const output = execFileSync("git", ["ls-files", "--", rel], {
+      cwd: root,
+      encoding: "utf-8",
+      windowsHide: true,
+    });
+    return output.trim().length > 0;
+  } catch {
+    return true;
+  }
+}
+
+function isIgnoredOrUntracked(root: string, rel: string): boolean {
+  if (!isGitWorktree(root)) return true;
+  try {
+    execFileSync("git", ["check-ignore", "-q", "--", rel], {
+      cwd: root,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    return true;
+  } catch {
+    try {
+      const output = execFileSync("git", ["ls-files", "--others", "--exclude-standard", "--", rel], {
+        cwd: root,
+        encoding: "utf-8",
+        windowsHide: true,
+      });
+      return output.trim().length > 0 || !existsSync(resolve(root, rel));
+    } catch {
+      return false;
+    }
+  }
+}
+
+function isGitWorktree(root: string): boolean {
+  try {
+    return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: root,
+      encoding: "utf-8",
+      windowsHide: true,
+    }).trim() === "true";
+  } catch {
+    return false;
+  }
+}
+
+function toRepoRelative(root: string, target: string): string {
+  const resolved = resolve(target);
+  const rel = relative(root, resolved);
+  if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`)) {
+    return "";
+  }
+  return rel.replace(/\\/g, "/");
+}
+
+function isExcluded(rel: string): boolean {
+  const parts = rel.split("/");
+  return parts.some((part) => EXCLUDED_DIRS.has(part));
+}

package/src/runner/runTask.ts

@@ -34,6 +34,7 @@ import {
 } from "./changeCapture.js";
 import { PatchWardenError, errorPayload } from "../errors.js";
 import { diagnoseAndroidBuild } from "../tools/androidDoctor.js";
+import { runPostTaskCleanup, type PostTaskCleanupReport } from "./postTaskCleanup.js";
 
 const HEARTBEAT_INTERVAL_MS = 2000;
 const GRACEFUL_KILL_MS = 2000;
@@ -150,6 +151,14 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     current_command: null,
     error: null,
   });
+  // v0.7.0: record task_started_at and watcher_instance_id so diagnose_task
+  // can detect PID reuse and orphaned tasks. watcher_instance_id comes from
+  // the watcher process env; when run_task MCP tool is used directly, this
+  // field is intentionally left undefined so ownership cannot be falsely claimed.
+  writeTaskRuntime(taskDir, {
+    task_started_at: new Date(startedAtMs).toISOString(),
+    watcher_instance_id: process.env.PATCHWARDEN_WATCHER_INSTANCE_ID || undefined,
+  });
   setTaskPhase(taskDir, "preparing", null, "Capturing pre-task repository state.");
 
   let beforeSnapshot;
@@ -230,19 +239,40 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
           ? `Verification command \"${failedVerification.command}\" could not start: ${failedVerification.spawnError}`
           : `Verification command \"${failedVerification.command}\" exited with code ${failedVerification.exitCode}.`;
       } else if (verifyResults.length === verifyCommands.length) {
-        finalStatus = "done";
+        finalStatus = "done_by_agent";
       } else {
         finalError = "Verification did not complete all configured commands.";
       }
     } else {
       testResult = skippedTest(testCommand, repoPath, "No verification command configured.");
-      finalStatus = "done";
+      finalStatus = "done_by_agent";
     }
   } catch (error) {
     lastCaughtError = error;
     finalError = errorMessage(error);
   }
 
+  let cleanupReport: PostTaskCleanupReport = {
+    enabled: true,
+    removed: [],
+    skipped: [],
+    source_files_touched: 0,
+  };
+  if (finalStatus !== "canceled") {
+    try {
+      cleanupReport = runPostTaskCleanup(repoPath, taskDir);
+      updateStatus(taskDir, { cleanup: cleanupReport });
+    } catch (error) {
+      cleanupReport = {
+        enabled: true,
+        removed: [],
+        skipped: [{ path: ".", reason: "post_task_cleanup", skip_reason: errorMessage(error) }],
+        source_files_touched: 0,
+      };
+      writeFileSync(join(taskDir, "post-task-cleanup.json"), JSON.stringify(cleanupReport, null, 2), "utf-8");
+      updateStatus(taskDir, { cleanup: cleanupReport });
+    }
+  }
   setTaskPhase(taskDir, "collecting_artifacts", null, "Capturing post-task state and writing reports.");
   const artifactCollectionStartedAt = new Date().toISOString();
   let changes: ChangeArtifacts;
@@ -310,7 +340,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
       "",
     ].join("\n"), "utf-8");
     // Don't override test failure with artifact failure
-    if (finalStatus === "done") {
+    if (finalStatus === "done_by_agent") {
       finalError = `Change capture failed: ${artifactCollectionError}`;
       finalStatus = "failed";
     } else {
@@ -335,7 +365,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
       );
   } catch (error) {
     finalError ||= `Workspace scope capture failed: ${errorMessage(error)}`;
-    if (finalStatus === "done") finalStatus = "failed";
+    if (finalStatus === "done_by_agent") finalStatus = "failed";
   }
 
   // Phase 4: Pre-existing external dirty files are warnings, not failures
@@ -400,8 +430,8 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
   writeFileSync(join(taskDir, "verify.json"), JSON.stringify(verifyJson, null, 2), "utf-8");
   writeFileSync(join(taskDir, "verify.log"), buildVerifyLog(verifyJson.commands), "utf-8");
 
-  if (!["canceled", "done", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(finalStatus)) finalStatus = "failed";
-  const finalPhase: TaskPhase = finalStatus === "done" ? "completed" : finalStatus;
+  if (!["canceled", "done_by_agent", "failed_verification", "failed_scope_violation", "failed_policy_violation"].includes(finalStatus)) finalStatus = "failed";
+  const finalPhase: TaskPhase = finalStatus === "done_by_agent" ? "done_by_agent" : finalStatus;
   const followup = buildFailureFollowup(finalStatus, finalError, verifyJson.commands);
 
   // Phase 7: Run Android build environment diagnostics if android_app exists
@@ -462,6 +492,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     artifact_collection_error: artifactCollectionError,
     artifact_collection_started_at: artifactCollectionStartedAt,
     artifact_collection_finished_at: artifactCollectionFinishedAt,
+    cleanup: cleanupReport,
     artifact_manifest: artifactManifest,
     out_of_scope_changes: outOfScopeChanges,
     new_out_of_scope_changes: newOutOfScopeChanges,
@@ -479,7 +510,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     commands_observed: [],
     verify: verifyJson,
     artifacts: [
-      "result.md", "result.json", "diff.patch", "git.diff", "test.log", "verify.log", "verify.json", "changed-files.json", "file-stats.json", "artifact_manifest.json",
+      "result.md", "result.json", "diff.patch", "git.diff", "test.log", "verify.log", "verify.json", "changed-files.json", "file-stats.json", "artifact_manifest.json", "post-task-cleanup.json",
       ...(outOfScopeChanges.length > 0 ? ["rollback_scope_violation_plan.md", "rollback-plan.json"] : []),
       ...(artifactStatus !== "collected" ? ["partial_result.md"] : []),
     ],
@@ -495,7 +526,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     failed_command: followup.failed_command,
     suggested_next_action: followup.suggested_next_action,
     safe_followup_prompt: followup.safe_followup_prompt,
-    next_steps: finalStatus === "done"
+    next_steps: finalStatus === "done_by_agent"
       ? ["Review get_task_summary and audit_task before accepting the work."]
       : ["Resolve the reported failure before accepting the work."],
   }, null, 2), "utf-8");
@@ -522,6 +553,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     artifact_collection_error: artifactCollectionError,
     artifact_collection_started_at: artifactCollectionStartedAt,
     artifact_collection_finished_at: artifactCollectionFinishedAt,
+    cleanup: cleanupReport,
     out_of_scope_changes: outOfScopeChanges,
     new_out_of_scope_changes: newOutOfScopeChanges,
     preexisting_external_dirty_files: preexistingExternalDirty,
@@ -532,6 +564,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     workspace_dirty_before: changes.workspace_dirty_before,
     workspace_dirty_after: changes.workspace_dirty_after,
     workspace_dirty: changes.workspace_dirty_after,
+    acceptance_status: finalStatus === "done_by_agent" ? "pending" : null,
   });
   writeTaskRuntime(taskDir, {
     phase: finalPhase,
@@ -559,7 +592,7 @@ function buildFailureFollowup(
   safe_followup_prompt: string | null;
 } {
   const failed = commands.find((command) => command.status !== "passed");
-  if (status === "done") {
+  if (status === "done_by_agent" || status === "done") {
     return {
       failure_reason: null,
       failed_command: null,
@@ -634,6 +667,12 @@ async function runManagedProcess(options: {
   } catch (error) {
     return { exitCode: null, stdout: "", stderr: "", spawnError: errorMessage(error), terminationReason: null };
   }
+  // v0.7.0: record child_started_at immediately so diagnose_task can detect
+  // PID reuse by comparing this timestamp with the live process start time.
+  writeTaskRuntime(options.taskDir, {
+    child_pid: child.pid,
+    child_started_at: new Date().toISOString(),
+  });
 
   const stdoutStream = openStream(options.stdoutPath);
   const stderrStream = openStream(options.stderrPath);
@@ -904,7 +943,7 @@ function buildResultMarkdown(input: {
     input.error || "Agent execution and configured verification completed successfully.",
     "",
     "## Risks",
-    input.status === "done"
+    input.status === "done_by_agent" || input.status === "done"
       ? "- Review git.diff and changed-files.json before accepting the task."
       : "- Task did not complete successfully; outputs may be partial.",
     "",

package/src/security/discoveryTokenStore.ts

@@ -0,0 +1,157 @@
+/**
+ * v0.8.1: discovery token store — server-side token store for invoke_discovered_tool.
+ *
+ * discover_tools 为每个搜索结果生成 discoveryToken，server-side 保存 token 真实信息。
+ * invoke_discovered_tool 只接受 token id（不信任客户端回传的 token JSON）。
+ *
+ * 安全契约：
+ * - 不引入第三方 npm 依赖（用 node:crypto 的 randomBytes）
+ * - 不持久化到磁盘（内存 Map，进程内共享，单例）
+ * - token 单次使用语义（consumeToken 后即删除）
+ */
+
+import { randomBytes } from "node:crypto";
+import { PatchWardenError } from "../errors.js";
+import type { ToolRisk } from "../tools/toolRegistry.js";
+import type { ToolProfile } from "../tools/toolCatalog.js";
+
+// ── 类型定义 ──────────────────────────────────────────────────────
+
+export interface DiscoveryTokenRecord {
+  token: string;           // token id，格式 dst_{YYYYMMDD}_{randomHex12}
+  toolName: string;        // 该 token 授权调用的工具名
+  risk: ToolRisk;          // 该工具的风险等级
+  allowedScope?: string[]; // 允许的文件 scope（可选）
+  issuedAt: string;        // ISO 时间戳
+  expiresAt: string;       // ISO 时间戳，默认 issuedAt + 10 分钟
+  query: string;           // discover_tools 时的查询词
+  schemaDigest: string;    // 工具 inputSchema 的 sha256 digest
+  profile: ToolProfile;    // discover 时的 profile
+}
+
+export interface IssueTokenInput {
+  toolName: string;
+  risk: ToolRisk;
+  query: string;
+  schemaDigest: string;
+  profile: ToolProfile;
+  allowedScope?: string[];
+  ttlMs?: number; // 默认 10 * 60 * 1000（10 分钟）
+}
+
+// ── 常量 ──────────────────────────────────────────────────────────
+
+const DEFAULT_TTL_MS = 10 * 60 * 1000; // 10 分钟
+
+// ── 模块级 token store（单例，进程内共享） ───────────────────────
+
+const tokenStore = new Map<string, DiscoveryTokenRecord>();
+
+// ── 内部工具 ──────────────────────────────────────────────────────
+
+function formatDatePart(date: Date): string {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}${m}${d}`;
+}
+
+function generateTokenId(): string {
+  const datePart = formatDatePart(new Date());
+  const randomPart = randomBytes(6).toString("hex"); // 12 位 hex
+  return `dst_${datePart}_${randomPart}`;
+}
+
+// ── 公共 API ──────────────────────────────────────────────────────
+
+/**
+ * 生成并保存 discovery token，返回 token id。
+ * token id 格式：dst_{YYYYMMDD}_{randomHex12}
+ */
+export function issueToken(input: IssueTokenInput): string {
+  const now = new Date();
+  const issuedAt = now.toISOString();
+  const expiresAt = new Date(Date.now() + (input.ttlMs ?? DEFAULT_TTL_MS)).toISOString();
+  const token = generateTokenId();
+
+  const record: DiscoveryTokenRecord = {
+    token,
+    toolName: input.toolName,
+    risk: input.risk,
+    allowedScope: input.allowedScope,
+    issuedAt,
+    expiresAt,
+    query: input.query,
+    schemaDigest: input.schemaDigest,
+    profile: input.profile,
+  };
+
+  tokenStore.set(token, record);
+  return token;
+}
+
+/**
+ * 消费 token（单次使用语义）。
+ * - 不存在 → 抛 PatchWardenError("token_not_found")
+ * - 过期（expiresAt 早于现在）→ 抛 PatchWardenError("token_expired")
+ * - 有效 → 从 store 删除并返回 record
+ */
+export function consumeToken(tokenId: string): DiscoveryTokenRecord {
+  const record = tokenStore.get(tokenId);
+  if (!record) {
+    throw new PatchWardenError(
+      "token_not_found",
+      `Discovery token not found: ${tokenId}`,
+      "Call discover_tools to obtain a fresh discovery token before invoking invoke_discovered_tool.",
+      true,
+      { token: tokenId }
+    );
+  }
+
+  const now = Date.now();
+  const expiresAtMs = Date.parse(record.expiresAt);
+  if (expiresAtMs < now) {
+    // 过期 token 从 store 删除，避免累积
+    tokenStore.delete(tokenId);
+    throw new PatchWardenError(
+      "token_expired",
+      `Discovery token expired: ${tokenId}`,
+      "Call discover_tools again to obtain a fresh discovery token.",
+      true,
+      { token: tokenId, expired_at: record.expiresAt }
+    );
+  }
+
+  tokenStore.delete(tokenId);
+  return record;
+}
+
+/**
+ * 只读查看 token，不消费、不校验过期。
+ * 不存在返回 null，存在返回 record（不删除）。
+ */
+export function peekToken(tokenId: string): DiscoveryTokenRecord | null {
+  const record = tokenStore.get(tokenId);
+  return record ?? null;
+}
+
+/**
+ * 撤销 token，返回是否删除成功。
+ */
+export function revokeToken(tokenId: string): boolean {
+  return tokenStore.delete(tokenId);
+}
+
+/**
+ * 清空所有 token（测试用）。
+ */
+export function clearAllTokens(): void {
+  tokenStore.clear();
+}
+
+/**
+ * 返回当前 store 中的 token 数量（测试/诊断用）。
+ */
+export function getActiveTokenCount(): number {
+  return tokenStore.size;
+}