chore: import upstream snapshot with attribution

2026-07-13 13:32:57 +08:00
commit cd420f9332
4811 changed files with 884702 additions and 0 deletions
@@ -0,0 +1,284 @@
+import { describe, it, expect } from "vitest";
+import {
+  truncateStack,
+  truncateMessage,
+  parseError,
+  sanitizeError,
+  shouldRetryError,
+  shouldLookupRetrySettings,
+} from "../src/v3/errors.js";
+import type { TaskRunError } from "../src/v3/schemas/common.js";
+
+// Helper: build a fake stack with N frames
+function buildStack(messageLines: string[], frameCount: number): string {
+  const frames = Array.from(
+    { length: frameCount },
+    (_, i) => `    at functionName${i} (/path/to/file${i}.ts:${i + 1}:${i + 10})`
+  );
+  return [...messageLines, ...frames].join("\n");
+}
+
+describe("truncateStack", () => {
+  it("returns empty string for undefined", () => {
+    expect(truncateStack(undefined)).toBe("");
+  });
+
+  it("returns empty string for empty string", () => {
+    expect(truncateStack("")).toBe("");
+  });
+
+  it("preserves a short stack unchanged", () => {
+    const stack = buildStack(["Error: something broke"], 10);
+    expect(truncateStack(stack)).toBe(stack);
+  });
+
+  it("preserves exactly 50 frames", () => {
+    const stack = buildStack(["Error: at the limit"], 50);
+    const result = truncateStack(stack);
+    expect(result).toBe(stack);
+    expect(result.split("\n").filter((l) => l.trimStart().startsWith("at ")).length).toBe(50);
+  });
+
+  it("truncates to 50 frames when exceeding the limit", () => {
+    const stack = buildStack(["Error: too many frames"], 200);
+    const result = truncateStack(stack);
+    const lines = result.split("\n");
+
+    // Message line + 5 top + 1 omitted notice + 45 bottom = 52 lines
+    expect(lines[0]).toBe("Error: too many frames");
+    expect(lines).toContain("    ... 150 frames omitted ...");
+
+    const frameLines = lines.filter((l) => l.trimStart().startsWith("at "));
+    expect(frameLines.length).toBe(50);
+
+    // First kept frame is frame 0 (top of stack)
+    expect(frameLines[0]).toContain("functionName0");
+    // Last kept frame is the last original frame
+    expect(frameLines[frameLines.length - 1]).toContain("functionName199");
+  });
+
+  it("preserves multi-line error messages before frames", () => {
+    const stack = buildStack(["TypeError: cannot read property", "  caused by: something"], 60);
+    const result = truncateStack(stack);
+    const lines = result.split("\n");
+
+    expect(lines[0]).toBe("TypeError: cannot read property");
+    expect(lines[1]).toBe("  caused by: something");
+    expect(lines).toContain("    ... 10 frames omitted ...");
+  });
+
+  it("truncates individual lines longer than 1024 chars", () => {
+    const longFrame = `    at someFn (${"x".repeat(2000)}:1:1)`;
+    const stack = ["Error: long line", longFrame].join("\n");
+    const result = truncateStack(stack);
+    const frameLine = result.split("\n")[1]!;
+
+    expect(frameLine.length).toBeLessThan(1100);
+    expect(frameLine).toContain("...[truncated]");
+  });
+});
+
+describe("truncateMessage", () => {
+  it("returns empty string for undefined", () => {
+    expect(truncateMessage(undefined)).toBe("");
+  });
+
+  it("returns empty string for empty string", () => {
+    expect(truncateMessage("")).toBe("");
+  });
+
+  it("preserves a short message", () => {
+    expect(truncateMessage("hello")).toBe("hello");
+  });
+
+  it("truncates messages over 1000 chars", () => {
+    const long = "x".repeat(5000);
+    const result = truncateMessage(long);
+    expect(result.length).toBeLessThan(1100);
+    expect(result).toContain("...[truncated]");
+  });
+
+  it("preserves a message at exactly 1000 chars", () => {
+    const exact = "x".repeat(1000);
+    expect(truncateMessage(exact)).toBe(exact);
+  });
+});
+
+describe("parseError truncation", () => {
+  it("truncates large stack traces in Error objects", () => {
+    const error = new Error("boom");
+    error.stack = buildStack(["Error: boom"], 200);
+    const parsed = parseError(error);
+
+    expect(parsed.type).toBe("BUILT_IN_ERROR");
+    if (parsed.type === "BUILT_IN_ERROR") {
+      const frameLines = parsed.stackTrace
+        .split("\n")
+        .filter((l) => l.trimStart().startsWith("at "));
+      expect(frameLines.length).toBe(50);
+      expect(parsed.stackTrace).toContain("frames omitted");
+    }
+  });
+
+  it("truncates large error messages", () => {
+    const error = new Error("x".repeat(5000));
+    const parsed = parseError(error);
+
+    if (parsed.type === "BUILT_IN_ERROR") {
+      expect(parsed.message.length).toBeLessThan(1100);
+      expect(parsed.message).toContain("...[truncated]");
+    }
+  });
+});
+
+describe("sanitizeError truncation", () => {
+  it("truncates stack traces during sanitization", () => {
+    const result = sanitizeError({
+      type: "BUILT_IN_ERROR",
+      name: "Error",
+      message: "boom",
+      stackTrace: buildStack(["Error: boom"], 200),
+    });
+
+    if (result.type === "BUILT_IN_ERROR") {
+      const frameLines = result.stackTrace
+        .split("\n")
+        .filter((l) => l.trimStart().startsWith("at "));
+      expect(frameLines.length).toBe(50);
+    }
+  });
+
+  it("strips null bytes and truncates", () => {
+    const result = sanitizeError({
+      type: "BUILT_IN_ERROR",
+      name: "Error\0",
+      message: "hello\0world",
+      stackTrace: "Error: hello\0world\n    at fn (/path.ts:1:1)",
+    });
+
+    if (result.type === "BUILT_IN_ERROR") {
+      expect(result.name).toBe("Error");
+      expect(result.message).toBe("helloworld");
+      expect(result.stackTrace).not.toContain("\0");
+    }
+  });
+
+  it("truncates STRING_ERROR raw field", () => {
+    const result = sanitizeError({
+      type: "STRING_ERROR",
+      raw: "x".repeat(5000),
+    });
+
+    if (result.type === "STRING_ERROR") {
+      expect(result.raw.length).toBeLessThan(1100);
+      expect(result.raw).toContain("...[truncated]");
+    }
+  });
+
+  it("preserves small CUSTOM_ERROR raw as valid JSON", () => {
+    const originalJson = JSON.stringify({ foo: "bar", nested: { baz: 1 } });
+    const result = sanitizeError({
+      type: "CUSTOM_ERROR",
+      raw: originalJson,
+    });
+
+    if (result.type === "CUSTOM_ERROR") {
+      // Small JSON should pass through unchanged and remain parseable
+      expect(result.raw).toBe(originalJson);
+      expect(() => JSON.parse(result.raw)).not.toThrow();
+    }
+  });
+
+  it("wraps oversized CUSTOM_ERROR raw in a valid JSON envelope", () => {
+    const hugeJson = JSON.stringify({ data: "x".repeat(5000) });
+    const result = sanitizeError({
+      type: "CUSTOM_ERROR",
+      raw: hugeJson,
+    });
+
+    if (result.type === "CUSTOM_ERROR") {
+      // Must remain valid JSON (critical: createErrorTaskError calls JSON.parse on this)
+      expect(() => JSON.parse(result.raw)).not.toThrow();
+      const parsed = JSON.parse(result.raw);
+      expect(parsed.truncated).toBe(true);
+      expect(typeof parsed.preview).toBe("string");
+      expect(parsed.preview.length).toBeLessThanOrEqual(1000);
+    }
+  });
+});
+
+describe("sanitizeError INTERNAL_ERROR optional fields", () => {
+  it("preserves undefined message (does not convert to empty string)", () => {
+    const result = sanitizeError({
+      type: "INTERNAL_ERROR",
+      code: "SOME_INTERNAL_CODE" as any,
+      // message and stackTrace intentionally undefined
+    });
+
+    if (result.type === "INTERNAL_ERROR") {
+      // Must stay undefined so `error.message ?? fallback` works downstream
+      expect(result.message).toBeUndefined();
+      expect(result.stackTrace).toBeUndefined();
+    }
+  });
+
+  it("truncates INTERNAL_ERROR message when present", () => {
+    const result = sanitizeError({
+      type: "INTERNAL_ERROR",
+      code: "SOME_INTERNAL_CODE" as any,
+      message: "x".repeat(5000),
+    });
+
+    if (result.type === "INTERNAL_ERROR") {
+      expect(result.message).toBeDefined();
+      expect(result.message!.length).toBeLessThan(1100);
+      expect(result.message).toContain("...[truncated]");
+    }
+  });
+});
+
+describe("truncateStack message line bounding", () => {
+  it("truncates huge error messages embedded in the stack", () => {
+    // V8 format: "Error: <message>\n    at ..."
+    // A huge message on the first line must still be bounded.
+    const hugeMessage = "x".repeat(100_000);
+    const stack = `Error: ${hugeMessage}\n    at fn (/path.ts:1:1)`;
+    const result = truncateStack(stack);
+
+    // Total output should be bounded (not 100KB+)
+    expect(result.length).toBeLessThan(5_000);
+    expect(result).toContain("...[truncated]");
+  });
+});
+
+describe("shouldRetryError + shouldLookupRetrySettings", () => {
+  const internal = (code: string): TaskRunError =>
+    ({ type: "INTERNAL_ERROR", code }) as TaskRunError;
+
+  it("retries SIGSEGV (changed from non-retriable) and looks up retry settings", () => {
+    const err = internal("TASK_PROCESS_SIGSEGV");
+    expect(shouldRetryError(err)).toBe(true);
+    expect(shouldLookupRetrySettings(err)).toBe(true);
+  });
+
+  it("retries SIGTERM via the same path", () => {
+    const err = internal("TASK_PROCESS_SIGTERM");
+    expect(shouldRetryError(err)).toBe(true);
+    expect(shouldLookupRetrySettings(err)).toBe(true);
+  });
+
+  it("retries TASK_MIDDLEWARE_ERROR using the task's retry settings", () => {
+    const err = internal("TASK_MIDDLEWARE_ERROR");
+    expect(shouldRetryError(err)).toBe(true);
+    expect(shouldLookupRetrySettings(err)).toBe(true);
+  });
+
+  it("still does not retry SIGKILL timeout", () => {
+    expect(shouldRetryError(internal("TASK_PROCESS_SIGKILL_TIMEOUT"))).toBe(false);
+  });
+
+  it("still does not retry OOM kills (handled by the separate machine-bump path)", () => {
+    expect(shouldRetryError(internal("TASK_PROCESS_OOM_KILLED"))).toBe(false);
+    expect(shouldRetryError(internal("TASK_PROCESS_MAYBE_OOM_KILLED"))).toBe(false);
+  });
+});