@pensar/apex 2.5.0 → 2.6.1-canary.0cc77dcc

package/src/core/agents/offSecAgent/tools/applyPatch.test.ts

@@ -0,0 +1,546 @@
+import { execFile } from "node:child_process";
+import {
+  lstatSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { describe, expect, it } from "vitest";
+import {
+  type ApplyPatchResult,
+  applyPatch,
+  duplicateTargetKey,
+} from "./applyPatch";
+import type { UnifiedSandbox } from "./sandbox";
+import type { ToolContext } from "./types";
+
+const execute = promisify(execFile);
+
+function makeCtx(
+  agentCwd: string,
+  extra: Partial<ToolContext> = {},
+): ToolContext {
+  return {
+    agentCwd,
+    session: { id: "ses_test", rootPath: agentCwd },
+    ...extra,
+  } as ToolContext;
+}
+
+async function run(ctx: ToolContext, patch: string): Promise<ApplyPatchResult> {
+  const tool = applyPatch(ctx);
+  return (await tool.execute?.(
+    { patch, toolCallDescription: "test patch" },
+    { toolCallId: "t1", messages: [] },
+  )) as ApplyPatchResult;
+}
+
+const linuxSandbox: UnifiedSandbox = {
+  type: "linux",
+  async execute(command, options) {
+    const { stdout, stderr } = await execute("/bin/sh", ["-c", command], {
+      cwd: options?.cwd,
+      env: { ...process.env, ...options?.envVars },
+      timeout: (options?.timeout ?? 30) * 1000,
+      maxBuffer: 3 * 1024 * 1024,
+    });
+    return { stdout, stderr, exitCode: 0, success: true };
+  },
+};
+
+describe("applyPatch tool — preflight", () => {
+  it("applies a multi-hunk patch to disk", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-"));
+    writeFileSync(
+      join(root, "file.ts"),
+      "const a = 1;\nconst b = 2;\nconst c = 3;\n",
+    );
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1,3 +1,3 @@
+-const a = 1;
++const a = 10;
+ const b = 2;
+-const c = 3;
++const c = 30;
+`,
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.files[0]).toMatchObject({
+      path: "file.ts",
+      status: "applied",
+      hunksApplied: 1,
+    });
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe(
+      "const a = 10;\nconst b = 2;\nconst c = 30;\n",
+    );
+  });
+
+  it("mutates nothing when any file fails preflight", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-pre-"));
+    writeFileSync(join(root, "good.ts"), "one\ntwo\n");
+    writeFileSync(join(root, "bad.ts"), "hello\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/good.ts
++++ b/good.ts
+@@ -1,2 +1,2 @@
+ one
+-two
++TWO
+--- a/bad.ts
++++ b/bad.ts
+@@ -1 +1 @@
+-goodbye
++hi
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Failed applying patch to bad\.ts/);
+    expect(result.files[0]).toMatchObject({
+      path: "good.ts",
+      status: "unapplied",
+    });
+    expect(result.files[1]).toMatchObject({ path: "bad.ts", status: "failed" });
+    expect(readFileSync(join(root, "good.ts"), "utf-8")).toBe("one\ntwo\n");
+    expect(readFileSync(join(root, "bad.ts"), "utf-8")).toBe("hello\n");
+  });
+
+  it("reports a parse failure without touching anything", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-parse-"));
+    writeFileSync(join(root, "file.ts"), "hello\n");
+
+    const result = await run(makeCtx(root), "not a patch");
+
+    expect(result.success).toBe(false);
+    expect(result.files).toEqual([]);
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe("hello\n");
+  });
+
+  it("rejects a patch that targets the same file twice", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-dup-"));
+    writeFileSync(join(root, "file.ts"), "a\nb\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1 +1 @@
+-a
++A
+--- a/file.ts
++++ b/file.ts
+@@ -2 +2 @@
+-b
++B
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/same file twice/);
+    expect(result.files.every((f) => f.status !== "applied")).toBe(true);
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe("a\nb\n");
+  });
+
+  it("rejects paths escaping the agent working directory", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-escape-"));
+    writeFileSync(join(root, "secret.ts"), "keep\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- /etc/passwd
++++ /etc/passwd
+@@ -1 +1 @@
+-x
++y
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/esca/i);
+  });
+
+  it("rejects relative paths escaping the agent working directory", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-esc2-"));
+    writeFileSync(join(root, "inside.ts"), "a\n");
+    writeFileSync(join(root, "outside.ts"), "keep\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/../outside.ts
++++ b/../outside.ts
+@@ -1 +1 @@
+-keep
++changed
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/escapes/i);
+    expect(readFileSync(join(root, "outside.ts"), "utf-8")).toBe("keep\n");
+  });
+
+  it("rejects paths escaping the file workspace root when scoped", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-scope-"));
+    const workspace = join(root, "helpers");
+    mkdirSync(workspace);
+    writeFileSync(join(root, "outside.ts"), "keep\n");
+
+    const result = await run(
+      makeCtx(root, { fileWorkspaceRoot: workspace }),
+      `--- a/../outside.ts
++++ b/../outside.ts
+@@ -1 +1 @@
+-keep
++changed
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/escapes/i);
+    expect(readFileSync(join(root, "outside.ts"), "utf-8")).toBe("keep\n");
+  });
+});
+
+describe("applyPatch tool — create and delete", () => {
+  describe.each([
+    { name: "local", sandbox: undefined },
+    { name: "Linux process adapter", sandbox: linuxSandbox },
+  ])("symlink deletion: $name", ({ sandbox }) => {
+    it.skipIf(process.platform === "win32").each(["inside", "outside"])(
+      "rejects a link to an %s target before committing any file",
+      async (location) => {
+        const root = mkdtempSync(join(tmpdir(), "apex-patch-symlink-"));
+        try {
+          const workspace = join(root, "helpers");
+          mkdirSync(workspace);
+          const target = join(
+            location === "inside" ? workspace : root,
+            "target.txt",
+          );
+          writeFileSync(target, "target\n");
+          writeFileSync(join(workspace, "keep.txt"), "keep\n");
+          const link = join(workspace, "link.txt");
+          symlinkSync(target, link);
+          const result = await run(
+            makeCtx(workspace, { fileWorkspaceRoot: workspace, sandbox }),
+            "--- a/keep.txt\n+++ b/keep.txt\n@@ -1 +1 @@\n-keep\n+changed\n--- a/link.txt\n+++ /dev/null\n@@ -1 +0,0 @@\n-target\n",
+          );
+          expect(result.success).toBe(false);
+          expect(result.error).toMatch(/symlink|escapes/i);
+          expect(result.files.map((file) => file.status)).toEqual([
+            "unapplied",
+            "failed",
+          ]);
+          expect(readFileSync(target, "utf8")).toBe("target\n");
+          expect(readFileSync(join(workspace, "keep.txt"), "utf8")).toBe(
+            "keep\n",
+          );
+          expect(lstatSync(link).isSymbolicLink()).toBe(true);
+        } finally {
+          rmSync(root, { recursive: true, force: true });
+        }
+      },
+    );
+  });
+
+  it("creates a file via /dev/null and refuses to create it twice", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-new-"));
+
+    const createPatch = `--- /dev/null
++++ b/created.ts
+@@ -0,0 +1,2 @@
++one
++two
+`;
+    const first = await run(makeCtx(root), createPatch);
+    expect(first.success).toBe(true);
+    expect(first.files[0]).toMatchObject({
+      status: "applied",
+      created: true,
+      hunksApplied: 1,
+    });
+    expect(readFileSync(join(root, "created.ts"), "utf-8")).toBe("one\ntwo\n");
+
+    const second = await run(makeCtx(root), createPatch);
+    expect(second.success).toBe(false);
+    expect(second.error).toMatch(/already exists/i);
+    expect(readFileSync(join(root, "created.ts"), "utf-8")).toBe("one\ntwo\n");
+  });
+
+  it("commits nothing when a later create target already exists", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-coll-"));
+    writeFileSync(join(root, "first.ts"), "one\ntwo\n");
+    writeFileSync(join(root, "exists.ts"), "already\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/first.ts
++++ b/first.ts
+@@ -1,2 +1,2 @@
+ one
+-two
++TWO
+--- /dev/null
++++ b/exists.ts
+@@ -0,0 +1,1 @@
++new content
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/already exists/i);
+    expect(result.files[0]).toMatchObject({
+      path: "first.ts",
+      status: "unapplied",
+    });
+    expect(result.files[1]).toMatchObject({
+      path: "exists.ts",
+      status: "failed",
+    });
+    expect(readFileSync(join(root, "first.ts"), "utf-8")).toBe("one\ntwo\n");
+    expect(readFileSync(join(root, "exists.ts"), "utf-8")).toBe("already\n");
+  });
+
+  it("validates prepared output against the size limit before any commit", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-size-"));
+    writeFileSync(join(root, "first.ts"), "one\ntwo\n");
+    writeFileSync(join(root, "big.ts"), "small\n");
+    const huge = "x".repeat(1024 * 1024 + 10);
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/first.ts
++++ b/first.ts
+@@ -1,2 +1,2 @@
+ one
+-two
++TWO
+--- a/big.ts
++++ b/big.ts
+@@ -1 +1,2 @@
+ small
++${huge}
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/Text mutation limit/i);
+    expect(result.files[0]).toMatchObject({ status: "unapplied" });
+    expect(result.files[1]).toMatchObject({ status: "failed" });
+    expect(readFileSync(join(root, "first.ts"), "utf-8")).toBe("one\ntwo\n");
+    expect(readFileSync(join(root, "big.ts"), "utf-8")).toBe("small\n");
+  });
+
+  it("rejects patch output containing NUL bytes before committing", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-nul-"));
+    writeFileSync(join(root, "nul.ts"), "a\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/nul.ts
++++ b/nul.ts
+@@ -1 +1 @@
+-a
++b${"\0"}c
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/binary/i);
+    expect(result.files[0].status).toBe("failed");
+    expect(readFileSync(join(root, "nul.ts"), "utf-8")).toBe("a\n");
+  });
+
+  it("deletes a file via /dev/null and reports missing targets", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-del-"));
+    writeFileSync(join(root, "gone.ts"), "only\n");
+
+    const deleted = await run(
+      makeCtx(root),
+      `--- a/gone.ts
++++ /dev/null
+@@ -1 +0,0 @@
+-only
+`,
+    );
+    expect(deleted.success).toBe(true);
+    expect(deleted.files[0]).toMatchObject({
+      status: "applied",
+      deleted: true,
+    });
+
+    const missing = await run(
+      makeCtx(root),
+      `--- a/gone.ts
++++ /dev/null
+@@ -1 +0,0 @@
+-only
+`,
+    );
+    expect(missing.success).toBe(false);
+    expect(missing.files[0].status).toBe("failed");
+  });
+});
+
+describe("applyPatch tool — formatting on disk", () => {
+  it("preserves a missing final newline when the hunk stays off EOF", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-nl-"));
+    writeFileSync(join(root, "file.ts"), "a\nb\nc");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1 +1 @@
+-a
++A
+`,
+    );
+
+    expect(result.success).toBe(true);
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe("A\nb\nc");
+  });
+
+  it("adapts an LF patch to a CRLF file and reports it", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-crlf-"));
+    writeFileSync(join(root, "file.ts"), "one\r\ntwo\r\nthree\r\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1,3 +1,3 @@
+ one
+-two
++TWO
+ three
+`,
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.files[0].eolAdaptation).toBe("added-cr");
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe(
+      "one\r\nTWO\r\nthree\r\n",
+    );
+  });
+
+  it("preserves a BOM across an edit", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-bom-"));
+    writeFileSync(join(root, "file.ts"), "first\nsecond\n");
+
+    const result = await run(
+      makeCtx(root),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1 +1 @@
+-first
++FIRST
+`,
+    );
+
+    expect(result.success).toBe(true);
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe(
+      "FIRST\nsecond\n",
+    );
+  });
+});
+
+describe("applyPatch tool — interruption", () => {
+  it("marks everything unapplied when aborted before commit", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-abort-"));
+    writeFileSync(join(root, "file.ts"), "a\nb\n");
+    const controller = new AbortController();
+    controller.abort();
+
+    const result = await run(
+      makeCtx(root, { abortSignal: controller.signal }),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1,2 +1,2 @@
+-a
++A
+ b
+`,
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.error).toMatch(/abort/i);
+    expect(result.files.every((f) => f.status === "unapplied")).toBe(true);
+    expect(readFileSync(join(root, "file.ts"), "utf-8")).toBe("a\nb\n");
+  });
+});
+
+describe("duplicateTargetKey", () => {
+  const neverRuns = async () => ({
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    success: true,
+  });
+
+  it("folds case for windows sandboxes", () => {
+    const ctx = makeCtx("/w", {
+      sandbox: { type: "windows", execute: neverRuns },
+    });
+    expect(duplicateTargetKey(ctx, "/w/A.ts")).toBe("/w/a.ts");
+  });
+
+  it("preserves case for linux sandboxes", () => {
+    const ctx = makeCtx("/w", {
+      sandbox: { type: "linux", execute: neverRuns },
+    });
+    expect(duplicateTargetKey(ctx, "/w/A.ts")).toBe("/w/A.ts");
+  });
+
+  it("follows host platform semantics without a sandbox", () => {
+    const ctx = makeCtx("/w");
+    const expected = process.platform === "win32" ? "/w/a.ts" : "/w/A.ts";
+    expect(duplicateTargetKey(ctx, "/w/A.ts")).toBe(expected);
+  });
+});
+
+describe("applyPatch tool — sandbox routing", () => {
+  it("applies through the remote file operation path", async () => {
+    const root = mkdtempSync(join(tmpdir(), "apex-patch-sbx-"));
+    const workspace = join(root, "helpers");
+    mkdirSync(workspace);
+    writeFileSync(join(workspace, "file.ts"), "one\ntwo\nthree\n");
+
+    const result = await run(
+      makeCtx(root, {
+        fileWorkspaceRoot: workspace,
+        sandbox: linuxSandbox,
+      }),
+      `--- a/file.ts
++++ b/file.ts
+@@ -1,3 +1,3 @@
+ one
+-two
++TWO
+ three
+`,
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.files[0]).toMatchObject({
+      status: "applied",
+      hunksApplied: 1,
+    });
+    expect(readFileSync(join(workspace, "file.ts"), "utf-8")).toBe(
+      "one\nTWO\nthree\n",
+    );
+  });
+});

package/src/core/agents/offSecAgent/tools/applyPatch.ts

@@ -0,0 +1,58 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { resolveBackends } from "../../../tools/backends/resolve";
+import type { ApplyPatchResult } from "./applyPatchImpl";
+import type { ToolContext } from "./types";
+
+export type {
+  ApplyPatchResult,
+  FilePatchResult,
+  FilePatchStatus,
+} from "./applyPatchImpl";
+export {
+  duplicateTargetKey,
+  parseUnifiedDiff,
+} from "./applyPatchImpl";
+
+const applyPatchInputSchema = z.object({
+  patch: z
+    .string()
+    .describe(
+      "Unified diff to apply. May contain one or more file hunks (---/+++/@@). Paths are relative to the agent working directory unless absolute.",
+    ),
+  toolCallDescription: z
+    .string()
+    .describe(
+      "A concise, human-readable description of what this tool call is doing (e.g., 'Apply parameterized-query fix across auth handlers')",
+    ),
+});
+
+export function applyPatch(ctx: ToolContext) {
+  return tool({
+    description: `Apply a unified diff patch to one or more files.
+
+Use this for multi-hunk or multi-file edits. For a single small string replace,
+prefer update_file.
+
+The entire patch is validated against current file contents before anything is
+changed: if any file's context does not match, a create target already exists,
+or a prepared result violates the text/size limits, nothing is written. Context
+must match at exactly one position in the file — matches at multiple positions
+are rejected; add more context lines to disambiguate. Commits are conditional —
+if a file changed since the preflight read, that file fails and later files are
+left unapplied (already-applied files stay applied; there is no rollback). Each
+file gets a receipt: applied, failed, or unapplied.
+
+Create files with a "--- /dev/null" header; delete with "+++ /dev/null" (the
+hunks must cover the whole file; symlink deletion patches are rejected).
+Renames, copies, mode changes, and binary
+patches are rejected. Final newlines, BOMs, and CRLF line endings are preserved;
+an LF patch applied to a CRLF file is adapted and reported in the receipt.
+Paths resolve under the agent working directory (or file workspace when scoped).`,
+    inputSchema: applyPatchInputSchema,
+    execute: async ({ patch }): Promise<ApplyPatchResult> => {
+      const { fs } = resolveBackends(ctx);
+      return fs.applyPatch(patch);
+    },
+  });
+}