Skip to content
Python
33.2 KB
Raw Blame
import {
  chmod,
  lstat,
  mkdir,
  mkdtemp,
  readdir,
  readFile,
  rm,
  symlink,
  utimes,
  writeFile,
} from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { strFromU8, unzipSync } from "fflate";
import { afterEach, describe, expect, it } from "vitest";

import {
  DiagnosticLogger,
  diagnosticError,
  diagnosticEvent,
  diagnosticLogFiles,
  exportDiagnosticBundle,
  exportDiagnosticZip,
  projectDiagnosticEventForSafeOutput,
  pruneDiagnosticLogs,
  readDiagnosticEvents,
  recordDiagnosticMarker,
  writeDiagnosticEventSync,
} from "./diagnostic-log.js";

const roots: string[] = [];
async function root() {
  const value = await mkdtemp(path.join(os.tmpdir(), "one-memory-log-"));
  roots.push(value);
  return value;
}
afterEach(async () =>
  Promise.all(roots.splice(0).map((item) => rm(item, { recursive: true }))),
);

describe("diagnostic log", () => {
  it("persists an early fatal event before the process can exit", async () => {
    const dataDir = await root();
    writeDiagnosticEventSync(
      {
        dataDir,
        service: "desktop",
        sessionId: "55555555-5555-4555-8555-555555555555",
      },
      {
        level: "error",
        component: "desktop.lifecycle",
        event: "desktop.early_start_failed",
        outcome: "failed",
        error_code: "desktop_test_real_home_mismatch",
        error_type: "Error",
        safe_stack: ["apps/desktop/src/main.ts:80:1"],
        details: { reason: "desktop_test_real_home_mismatch" },
      },
    );

    const result = await readDiagnosticEvents(dataDir);
    expect(result.events).toHaveLength(1);
    expect(result.events[0]).toMatchObject({
      event: "desktop.early_start_failed",
      error_code: "desktop_test_real_home_mismatch",
      details: { reason: "desktop_test_real_home_mismatch" },
    });
  });

  it("keeps the synchronous writer fail-open for invalid input", async () => {
    const dataDir = await root();
    expect(() =>
      writeDiagnosticEventSync(
        {
          dataDir,
          service: "desktop",
          sessionId: "55555555-5555-4555-8555-555555555555",
        },
        {
          level: "error",
          component: "desktop.lifecycle",
          event: "desktop.early_start_failed",
          outcome: "failed",
          details: { nested: ["private"] } as never,
        },
      ),
    ).not.toThrow();
    expect(await readDiagnosticEvents(dataDir)).toEqual({
      events: [],
      invalid_lines: 0,
      unrecognized_lines: 0,
    });
  });

  it("writes structured, private events and reads them by correlation identity", async () => {
    const dataDir = await root();
    const session = "11111111-1111-4111-8111-111111111111";
    const trace = "22222222-2222-4222-8222-222222222222";
    const logger = new DiagnosticLogger({
      dataDir,
      service: "runtime",
      sessionId: session,
    });
    await logger.log({
      level: "info",
      component: "runtime.service",
      event: "runtime.ready",
      outcome: "succeeded",
      trace_id: trace,
      operation_id: "operation-1",
      duration_ms: 12,
      details: {
        phase: "startup",
        count: 2,
        open_file_count: 7,
        memory_bytes: 4096,
        thread_count: 4,
        "cache.hit-rate": 0.75,
        custom_label: "warm",
      },
    });
    const result = await readDiagnosticEvents(dataDir, { traceId: trace });
    expect(result.invalid_lines).toBe(0);
    expect(result.events).toHaveLength(1);
    expect(result.events[0]).toMatchObject({
      schema_version: 1,
      session_id: session,
      trace_id: trace,
      event: "runtime.ready",
      details: expect.objectContaining({
        open_file_count: 7,
        "cache.hit-rate": 0.75,
        custom_label: "warm",
      }),
    });
    const file = (await diagnosticLogFiles(dataDir))[0];
    if (process.platform !== "win32")
      expect((await lstat(file)).mode & 0o777).toBe(0o600);
  });

  it("stamps the package identity from the environment onto every event", async () => {
    const dataDir = await root();
    const session = "33333333-3333-4333-8333-333333333333";
    const previous = {
      build: process.env.ONE_MEMORY_BUILD_ID,
      pkg: process.env.ONE_MEMORY_PACKAGE_ID,
      round: process.env.ONE_MEMORY_ROUND,
    };
    process.env.ONE_MEMORY_BUILD_ID = "One-Memory-H88-4760f30-candidate";
    process.env.ONE_MEMORY_PACKAGE_ID = "One-Memory-H88-4760f30-candidate";
    process.env.ONE_MEMORY_ROUND = "88";
    try {
      const logger = new DiagnosticLogger({
        dataDir,
        service: "desktop",
        sessionId: session,
      });
      await logger.log({
        level: "info",
        component: "desktop.lifecycle",
        event: "ui.action",
        outcome: "started",
      });
      const result = await readDiagnosticEvents(dataDir);
      expect(result.events[0]).toMatchObject({
        event: "ui.action",
        build_id: "One-Memory-H88-4760f30-candidate",
        package_id: "One-Memory-H88-4760f30-candidate",
        round: "88",
      });
    } finally {
      if (previous.build === undefined) delete process.env.ONE_MEMORY_BUILD_ID;
      else process.env.ONE_MEMORY_BUILD_ID = previous.build;
      if (previous.pkg === undefined) delete process.env.ONE_MEMORY_PACKAGE_ID;
      else process.env.ONE_MEMORY_PACKAGE_ID = previous.pkg;
      if (previous.round === undefined) delete process.env.ONE_MEMORY_ROUND;
      else process.env.ONE_MEMORY_ROUND = previous.round;
    }
  });

  it("writes no identity for a source run instead of fabricating one", async () => {
    const dataDir = await root();
    const previous = {
      build: process.env.ONE_MEMORY_BUILD_ID,
      pkg: process.env.ONE_MEMORY_PACKAGE_ID,
      round: process.env.ONE_MEMORY_ROUND,
    };
    delete process.env.ONE_MEMORY_BUILD_ID;
    delete process.env.ONE_MEMORY_PACKAGE_ID;
    delete process.env.ONE_MEMORY_ROUND;
    try {
      const logger = new DiagnosticLogger({
        dataDir,
        service: "desktop",
        sessionId: "44444444-4444-4444-8444-444444444444",
      });
      await logger.log({
        level: "info",
        component: "desktop.lifecycle",
        event: "ui.action",
        outcome: "started",
      });
      const result = await readDiagnosticEvents(dataDir);
      expect(result.events[0].build_id).toBeUndefined();
      expect(result.events[0].package_id).toBeUndefined();
      expect(result.events[0].round).toBeUndefined();
    } finally {
      if (previous.build !== undefined)
        process.env.ONE_MEMORY_BUILD_ID = previous.build;
      if (previous.pkg !== undefined)
        process.env.ONE_MEMORY_PACKAGE_ID = previous.pkg;
      if (previous.round !== undefined)
        process.env.ONE_MEMORY_ROUND = previous.round;
    }
  });

  it("strictly rejects complex detail values, dangerous keys and absolute stacks", () => {
    const base = {
      timestamp: new Date().toISOString(),
      level: "error" as const,
      service: "core" as const,
      component: "hy.bridge",
      event: "hy.failed",
      outcome: "failed",
      session_id: "11111111-1111-4111-8111-111111111111",
    };
    expect(() =>
      diagnosticEvent({
        ...base,
        details: { nested: { secret: "private" } } as never,
      }),
    ).toThrow("diagnostic_detail_value_invalid");
    expect(() =>
      diagnosticEvent({ ...base, details: { constructor: "private" } }),
    ).toThrow("diagnostic_detail_key_invalid");
    expect(() =>
      diagnosticEvent({ ...base, details: { "9invalid": "private" } }),
    ).toThrow("diagnostic_detail_key_invalid");
    expect(() =>
      diagnosticEvent({
        ...base,
        details: Object.fromEntries(
          Array.from({ length: 33 }, (_, index) => [`key_${index}`, index]),
        ),
      }),
    ).toThrow("diagnostic_detail_count_invalid");
    expect(() =>
      diagnosticEvent({ ...base, details: { message: "line1\nline2" } }),
    ).toThrow("diagnostic_text_invalid");
    expect(() =>
      diagnosticEvent({ ...base, details: { metric: Number.NaN } }),
    ).toThrow("diagnostic_detail_value_invalid");
    expect(() =>
      diagnosticEvent({
        ...base,
        details: { count: Number.MAX_SAFE_INTEGER + 1 },
      }),
    ).toThrow("diagnostic_detail_value_invalid");
    expect(() =>
      diagnosticEvent({ ...base, details: { list: ["private"] } as never }),
    ).toThrow("diagnostic_detail_value_invalid");
    expect(() =>
      diagnosticEvent({ ...base, safe_stack: ["/Users/me/private.py:1"] }),
    ).toThrow("diagnostic_stack_invalid");
    expect(() =>
      diagnosticEvent({
        ...base,
        safe_stack: ["packages/runtime/sk-live-secret-token.ts:1:1"],
      }),
    ).toThrow("diagnostic_stack_invalid");
    for (const line of [
      "arbitrary stack text",
      "thread=worker|threading.py:12:wait",
      "FILE:///Users/me/private.py:1:call",
      "one_memory/worker.py:9:call /Users/private",
      "one_memory/GOCSPX-privateCredential.py:9:call",
      "packages/ASIA1234567890ABCDEF/file.ts:1:1",
      "packages/Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8/file.ts:1:1",
    ]) {
      expect(() => diagnosticEvent({ ...base, safe_stack: [line] })).toThrow(
        "diagnostic_stack_invalid",
      );
    }
    expect(() =>
      diagnosticEvent({
        ...base,
        safe_stack: Array.from(
          { length: 17 },
          (_, index) => `one_memory/worker.py:${index + 1}:call`,
        ),
      }),
    ).toThrow("diagnostic_stack_invalid");

    const accepted = diagnosticEvent({
      ...base,
      safe_stack: [
        "apps/desktop/src/main.ts:80:1",
        "one_memory/diagnostic_log.py:895:_safe_stack_line",
        "threading.py:1045:_bootstrap_inner",
        "thread|threading.py:1045:_bootstrap_inner > one_memory/worker.py:9:call",
      ],
    });
    expect(accepted.safe_stack).toHaveLength(4);

    const projected = projectDiagnosticEventForSafeOutput({
      ...accepted,
      safe_stack: [
        "free text",
        "thread=worker|one_memory/worker.py:9:call",
        "packages/runtime-control/src/diagnostic-log.ts:42:7",
        "thread|threading.py:1045:_bootstrap_inner > one_memory/worker.py:9:call",
      ],
    });
    expect(projected.safe_stack).toEqual([
      "packages/runtime-control/src/diagnostic-log.ts:42:7",
      "thread|threading.py:1045:_bootstrap_inner > one_memory/worker.py:9:call",
    ]);
    const conservative = projectDiagnosticEventForSafeOutput(
      diagnosticEvent({
        ...base,
        details: {
          source_id: "cursor",
          reason: "abcdef1234567890abcdef1234567890abcdef12",
          status: "11111111-1111-4111-8111-111111111111",
        },
      }),
    );
    expect(conservative.details).toEqual({
      source_id: "cursor",
      reason: "abcdef1234567890abcdef1234567890abcdef12",
      status: "11111111-1111-4111-8111-111111111111",
    });
  });

  it("drops malformed logger events without interrupting later writes", async () => {
    const dataDir = await root();
    const logger = new DiagnosticLogger({
      dataDir,
      service: "desktop",
      sessionId: "11111111-1111-4111-8111-111111111111",
    });

    await expect(
      logger.log({
        level: "info",
        component: "desktop.sdk_migration",
        event: "sdk_migration.startup",
        outcome: "succeeded",
        details: { nested: { secret: "private" } } as never,
      }),
    ).resolves.toBeUndefined();
    await logger.log({
      level: "info",
      component: "desktop.sdk_migration",
      event: "sdk_migration.startup",
      outcome: "succeeded",
      details: { arbitrary_state: "cutover" },
    });

    const result = await readDiagnosticEvents(dataDir);
    expect(result.invalid_lines).toBe(0);
    expect(result.events).toHaveLength(1);
    expect(result.events[0].details).toEqual({ arbitrary_state: "cutover" });
  });

  it("keeps code locations but strips exception messages and absolute prefixes", () => {
    const secret = "secret-token-918273";
    const error = new Error(secret);
    error.stack = `Error: ${secret}\n    at run (/Users/me/repo/packages/runtime-control/src/example.ts:42:7)`;
    const safe = diagnosticError(error);
    expect(safe).toEqual({
      error_type: "Error",
      safe_stack: ["packages/runtime-control/src/example.ts:42:7"],
    });
    expect(JSON.stringify(safe)).not.toContain(secret);
    expect(JSON.stringify(safe)).not.toContain("/Users/me");
  });

  it("exports events through an independent detail whitelist", async () => {
    const dataDir = await root();
    const logger = new DiagnosticLogger({ dataDir, service: "desktop" });
    const incident = await logger.markIncident({
      component: "desktop.diagnostics",
      status: "degraded",
    });
    await logger.log({
      level: "info",
      component: "desktop.diagnostics",
      event: "diagnostics.checked",
      outcome: "succeeded",
      details: {
        count: 1,
        reason: "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyIn0.signaturevalue",
        status: "ASIA1234567890ABCDEF",
        source_id: "GOCSPX-clientSecret_A1",
        mode: "Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8",
        action: "AIzaSyExampleCredential1234567890",
        platform: "x_ASIA1234567890ABCDEF",
        phase: "x_GOCSPX-clientSecret_A1",
        local_only_secret: "must-not-export",
      },
    });
    await logger.log({
      level: "error",
      component: "credential.private",
      event: "token.failed",
      outcome: "ghp_private_token",
      trace_id: "ghp_private_token",
      instance_id: "ASIA1234567890ABCDEF",
      request_id: "GOCSPX-clientSecret_A1",
      task_id: "Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8",
      error_code: "secret.token",
    });
    const target = path.join(await root(), "bundle.json");
    const result = await exportDiagnosticBundle({
      dataDir,
      target,
      productVersion: "1.2.3",
      status: { status: "degraded", local_only_secret: "must-not-export" },
    });
    expect(result).toEqual({ event_count: 3, invalid_lines: 0 });
    const payload = JSON.parse(await readFile(target, "utf8"));
    expect(payload.events[0].incident_id).toBe(incident.incident_id);
    expect(payload.events[1].details).toEqual({ count: 1 });
    expect(payload.events[2]).toMatchObject({
      component: "diagnostic.redacted",
      event: "diagnostic.redacted",
      outcome: "redacted",
    });
    expect(payload.events[2].trace_id).toBeUndefined();
    expect(payload.events[2].instance_id).toBeUndefined();
    expect(payload.events[2].request_id).toBeUndefined();
    expect(payload.events[2].task_id).toBeUndefined();
    expect(payload.events[2].error_code).toBeUndefined();
    expect(JSON.stringify(payload)).not.toContain("local_only_secret");
    expect(JSON.stringify(payload)).not.toContain("must-not-export");
    expect(JSON.stringify(payload)).not.toContain("eyJhbGciOiJIUzI1NiJ9");
    expect(JSON.stringify(payload)).not.toContain("ASIA1234567890ABCDEF");
    expect(JSON.stringify(payload)).not.toContain("GOCSPX-clientSecret_A1");
    expect(JSON.stringify(payload)).not.toContain("x_ASIA1234567890ABCDEF");
    expect(JSON.stringify(payload)).not.toContain("x_GOCSPX-clientSecret_A1");
    expect(JSON.stringify(payload)).not.toContain("Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8");
    expect(JSON.stringify(payload)).not.toContain(
      "AIzaSyExampleCredential1234567890",
    );
    expect(JSON.stringify(payload)).not.toContain("ghp_private_token");
  });

  it("fails closed when exported build identity has a credential shape", async () => {
    const dataDir = await root();
    const outputDir = await root();
    await expect(
      exportDiagnosticBundle({
        dataDir,
        target: path.join(outputDir, "bundle.json"),
        productVersion: "xoxb-123456-abcdef",
      }),
    ).rejects.toThrow("diagnostic_product_version_invalid");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target: path.join(outputDir, "commit.zip"),
        productVersion: "1.2.3",
        commit: "ghp_private_token",
      }),
    ).rejects.toThrow("diagnostic_commit_invalid");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target: path.join(outputDir, "sha.zip"),
        productVersion: "1.2.3",
        coreSha256: "AKIDExampleSecretId1234567890",
      }),
    ).rejects.toThrow("diagnostic_sha256_invalid");
    expect(await readdir(outputDir)).toEqual([]);
  });

  it("fails closed without publishing a JSON bundle when any line is invalid", async () => {
    const dataDir = await root();
    await mkdir(path.join(dataDir, "logs"), { recursive: true });
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-core.jsonl"),
      "not-json\n",
      { mode: 0o600 },
    );
    const outputDir = await root();
    const target = path.join(outputDir, "bundle.json");
    await expect(
      exportDiagnosticBundle({
        dataDir,
        target,
        productVersion: "1.2.3",
      }),
    ).rejects.toThrow("diagnostic_export_invalid_lines");
    expect(await readdir(outputDir)).toEqual([]);
  });

  it("counts only non-JSON lines as damaged and leaves older records out", async () => {
    const dataDir = await root();
    const logger = new DiagnosticLogger({ dataDir, service: "core" });
    await logger.log({
      level: "info",
      component: "core.service",
      event: "core.ready",
      outcome: "succeeded",
    });
    const older = {
      schema_version: 0,
      service: "desktop",
      component: "desktop.lifecycle",
      event: "desktop.started",
    };
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-desktop.jsonl"),
      [
        JSON.stringify(older),
        JSON.stringify({ ...older, schema_version: 1 }),
        JSON.stringify(["not", "an", "event"]),
        "",
      ].join("\n"),
      { mode: 0o600 },
    );

    const result = await readDiagnosticEvents(dataDir);
    expect(result.events.map((event) => event.event)).toEqual(["core.ready"]);
    expect(result.invalid_lines).toBe(0);
    expect(result.unrecognized_lines).toBe(3);
    // An older build's records do not stop a support export either.
    const target = path.join(await root(), "bundle.json");
    await expect(
      exportDiagnosticBundle({ dataDir, target, productVersion: "1.2.3" }),
    ).resolves.toEqual({ event_count: 1, invalid_lines: 0 });

    await writeFile(
      path.join(dataDir, "logs", "diagnostic-cli.jsonl"),
      '{"schema_version": 1, "event": \n',
      { mode: 0o600 },
    );
    const damaged = await readDiagnosticEvents(dataDir);
    expect(damaged.invalid_lines).toBe(1);
    expect(damaged.unrecognized_lines).toBe(3);
  });

  it("fails closed when the diagnostic directory cannot be read", async () => {
    if (process.platform === "win32") return;
    const dataDir = await root();
    const logs = path.join(dataDir, "logs");
    await mkdir(logs, { recursive: true, mode: 0o700 });
    await writeFile(path.join(logs, "diagnostic-core.jsonl"), "{}\n");
    const outputDir = await root();
    const target = path.join(outputDir, "bundle.json");
    await chmod(logs, 0o000);
    try {
      await expect(
        exportDiagnosticBundle({
          dataDir,
          target,
          productVersion: "1.2.3",
        }),
      ).rejects.toMatchObject({ code: "EACCES" });
    } finally {
      await chmod(logs, 0o700);
    }
    expect(await readdir(outputDir)).toEqual([]);
  });

  it("never overwrites an existing export target or leaves temporary files", async () => {
    const dataDir = await root();
    const outputDir = await root();
    const target = path.join(outputDir, "bundle.json");
    await writeFile(target, "existing-artifact", { mode: 0o600 });
    await expect(
      exportDiagnosticBundle({
        dataDir,
        target,
        productVersion: "1.2.3",
      }),
    ).rejects.toMatchObject({ code: "EEXIST" });
    expect(await readFile(target, "utf8")).toBe("existing-artifact");
    expect(await readdir(outputDir)).toEqual(["bundle.json"]);
  });

  it("preserves microsecond ordering across service log files", async () => {
    const dataDir = await root();
    await mkdir(path.join(dataDir, "logs"), { recursive: true });
    const base = {
      schema_version: 1,
      level: "info",
      outcome: "started",
      session_id: "11111111-1111-4111-8111-111111111111",
      trace_id: "22222222-2222-4222-8222-222222222222",
    };
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-desktop.jsonl"),
      `${JSON.stringify({
        ...base,
        timestamp: "2026-10-14T00:00:00.123Z",
        service: "desktop",
        component: "renderer.ui",
        event: "ui.action",
      })}\n`,
    );
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-core.jsonl"),
      `${JSON.stringify({
        ...base,
        timestamp: "2026-10-14T00:00:00.123999Z",
        service: "core",
        component: "core.api",
        event: "memory.request.started",
      })}\n`,
    );

    const result = await readDiagnosticEvents(dataDir);
    expect(result.invalid_lines).toBe(0);
    expect(result.events.map((event) => event.event)).toEqual([
      "ui.action",
      "memory.request.started",
    ]);
    expect(result.events[1].timestamp).toBe("2026-10-14T00:00:00.123999Z");
  });

  it("exports only reprojected events, a strict summary and README", async () => {
    const dataDir = await root();
    const outputDir = await root();
    const crashDir = await root();
    const secret = "sk-fake-secret-token";
    const conversation = "我喜欢吃绝密蓝莓";
    const home = "/Users/private-person";
    await mkdir(path.join(dataDir, "logs"), { recursive: true });
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-core.jsonl"),
      `${JSON.stringify({
        schema_version: 1,
        timestamp: "2026-10-05T01:00:00.000Z",
        level: "error",
        service: "core",
        component: "memory.task",
        event: "memory.failed",
        outcome: "failed",
        session_id: "11111111-1111-4111-8111-111111111111",
        task_id: "task-1",
        error_code: "model_failed",
        details: { content: conversation, token: secret, count: 1 },
      })}\n`,
    );
    await writeFile(
      path.join(dataDir, "logs", "core.log"),
      `home=${home} build=/Users/build-agent/repo authorization=Bearer ${secret} content=${conversation}\n`,
    );
    await writeFile(
      path.join(crashDir, "MemHub-2026-10-05.ips"),
      `Path: ${home}/MemHub\napi_key=${secret}\n`,
    );
    const target = path.join(outputDir, "MemHub.zip");

    const result = await exportDiagnosticZip({
      dataDir,
      target,
      productVersion: "3800",
      commit: "abcdef12",
      coreSha256: "0".repeat(64),
      home,
      crashReportsDir: crashDir,
      now: new Date("2026-10-05T02:00:00.000Z"),
      markers: [
        {
          timestamp: "2026-10-05T01:30:00.000Z",
          description:
            "蓝莓没出来 /Users/private/query.txt ASIA1234567890ABCDEF GOCSPX-clientSecret_A1 Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8 token=ghp_private_token xoxb-123456-abcdef AKIDExampleSecretId1234567890 AIzaSyExampleCredential1234567890 eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJ1c2VyIn0.signaturevalue",
        },
      ],
      summary: {
        sources: [{ source_id: "workbuddy", imported_messages: 12 }],
        summary_secret: conversation,
        background: {
          status: "exported",
          runtime_state: "ready",
          core_state: "healthy",
          broker_state: "ready",
          instance_id: "instance-1",
          secret: conversation,
        },
      },
    });

    expect(result).toEqual({ filename: "MemHub.zip", file_count: 3 });
    const files = unzipSync(await readFile(target));
    expect(Object.keys(files).sort()).toEqual([
      "README.txt",
      "diagnostics/events.jsonl",
      "summary.json",
    ]);
    const eventFile = files["diagnostics/events.jsonl"];
    const summaryFile = files["summary.json"];
    const readme = files["README.txt"];
    if (!eventFile || !summaryFile || !readme)
      throw new Error("missing support bundle metadata");
    const exportedEvent = JSON.parse(strFromU8(eventFile).trim());
    expect(exportedEvent.details).toEqual({ count: 1 });
    const summary = JSON.parse(strFromU8(summaryFile));
    expect(summary.background).toEqual({
      status: "exported",
      runtime_state: "ready",
      core_state: "healthy",
      broker_state: "ready",
      instance_id: "instance-1",
    });
    expect(summary.sources).toBeUndefined();
    expect(summary.summary_secret).toBeUndefined();
    expect(summary.problem_markers).toEqual([
      {
        timestamp: "2026-10-05T01:30:00.000Z",
        description: "user_marked_incident",
      },
    ]);
    expect(strFromU8(readme)).toContain("user_marked_incident");
    expect(strFromU8(readme)).not.toContain("蓝莓没出来");
    const all = Object.values(files)
      .map((value) => strFromU8(value))
      .join("\n");
    expect(all).not.toContain(secret);
    expect(all).not.toContain("ghp_private_token");
    expect(all).not.toContain("xoxb-123456-abcdef");
    expect(all).not.toContain("AKIDExampleSecretId1234567890");
    expect(all).not.toContain("ASIA1234567890ABCDEF");
    expect(all).not.toContain("GOCSPX-clientSecret_A1");
    expect(all).not.toContain("Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8");
    expect(all).not.toContain("AIzaSyExampleCredential1234567890");
    expect(all).not.toContain("eyJhbGciOiJIUzI1NiJ9");
    expect(all).not.toContain(conversation);
    expect(all).not.toContain(home);
    expect(all).not.toContain("/Users/");
  });

  it("fails closed without publishing a ZIP when a diagnostic line is invalid", async () => {
    const dataDir = await root();
    await mkdir(path.join(dataDir, "logs"), { recursive: true });
    await writeFile(
      path.join(dataDir, "logs", "diagnostic-core.jsonl"),
      "not-json\n",
    );
    const outputDir = await root();
    const target = path.join(outputDir, "MemHub.zip");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target,
        productVersion: "3800",
      }),
    ).rejects.toThrow("diagnostic_export_invalid_lines");
    expect(await readdir(outputDir)).toEqual([]);
  });

  it("stores and exports only the fixed marker description", async () => {
    const dataDir = await root();
    const markerFile = path.join(dataDir, "logs", "problem-markers.jsonl");
    await recordDiagnosticMarker(
      dataDir,
      {
        timestamp: "2026-10-05T01:00:00.000Z",
        description:
          "蓝莓 /Users/private/query.txt ASIA1234567890ABCDEF GOCSPX-clientSecret_A1 Aa1Bb2Cc3Dd4Ee5Ff6Gg7Hh8",
      },
      "/Users/private",
    );
    expect(await readFile(markerFile, "utf8")).toBe(
      `${JSON.stringify({ timestamp: "2026-10-05T01:00:00.000Z", description: "user_marked_incident" })}\n`,
    );
    await writeFile(
      markerFile,
      `${await readFile(markerFile, "utf8")}${JSON.stringify({ timestamp: "2026-10-05T01:30:00.000Z", description: "legacy arbitrary text" })}\n`,
      { mode: 0o600 },
    );

    const target = path.join(await root(), "markers.zip");
    await exportDiagnosticZip({
      dataDir,
      target,
      productVersion: "3800",
      now: new Date("2026-10-05T02:00:00.000Z"),
    });
    const files = unzipSync(await readFile(target));
    const summaryFile = files["summary.json"];
    if (!summaryFile) throw new Error("missing summary.json");
    const payload = JSON.stringify(JSON.parse(strFromU8(summaryFile)));
    expect(payload.match(/user_marked_incident/g)).toHaveLength(2);
    expect(payload).not.toContain("legacy arbitrary text");
    expect(payload).not.toContain("蓝莓");
    expect(payload).not.toContain("/Users/");
  });

  it("never follows a problem marker symlink for reads or writes", async () => {
    const dataDir = await root();
    const logs = path.join(dataDir, "logs");
    await mkdir(logs, { recursive: true });
    const outside = path.join(await root(), "outside-marker");
    await writeFile(outside, "private");
    await symlink(outside, path.join(logs, "problem-markers.jsonl"));

    await expect(
      recordDiagnosticMarker(dataDir, {
        timestamp: "2026-10-05T01:00:00.000Z",
        description: "anything",
      }),
    ).rejects.toThrow("diagnostic_marker_file_unsafe");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target: path.join(await root(), "markers.zip"),
        productVersion: "3800",
      }),
    ).rejects.toThrow("diagnostic_marker_file_unsafe");
    expect(await readFile(outside, "utf8")).toBe("private");
  });

  it("rejects invalid explicit and persisted markers without publishing a ZIP", async () => {
    const dataDir = await root();
    const logs = path.join(dataDir, "logs");
    await mkdir(logs, { recursive: true });
    const outputDir = await root();
    const explicitTarget = path.join(outputDir, "explicit.zip");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target: explicitTarget,
        productVersion: "3800",
        markers: [{ timestamp: "invalid", description: "marker" }],
      }),
    ).rejects.toThrow("diagnostic_marker_invalid");
    await writeFile(path.join(logs, "problem-markers.jsonl"), "not-json\n");
    const persistedTarget = path.join(outputDir, "persisted.zip");
    await expect(
      exportDiagnosticZip({
        dataDir,
        target: persistedTarget,
        productVersion: "3800",
      }),
    ).rejects.toThrow("diagnostic_marker_invalid");
    expect(await readdir(outputDir)).toEqual([]);
  });

  it("an incident retrieves its surrounding session rather than only its marker", async () => {
    const dataDir = await root();
    const times = [
      new Date("2026-09-24T01:00:00Z"),
      new Date("2026-09-24T01:01:00Z"),
      new Date("2026-09-24T01:02:00Z"),
    ];
    const logger = new DiagnosticLogger({
      dataDir,
      service: "desktop",
      sessionId: "11111111-1111-4111-8111-111111111111",
      now: () => times.shift() ?? new Date("2026-09-24T01:02:00Z"),
    });
    await logger.log({
      level: "info",
      component: "desktop.connection",
      event: "connection.started",
      outcome: "started",
    });
    const marker = await logger.markIncident({
      component: "desktop.diagnostics",
      instanceId: "instance-1",
    });
    await logger.log({
      level: "error",
      component: "desktop.connection",
      event: "connection.failed",
      outcome: "failed",
      error_code: "connection_failed",
    });
    const runtime = new DiagnosticLogger({
      dataDir,
      service: "runtime",
      sessionId: "33333333-3333-4333-8333-333333333333",
      now: () => new Date("2026-09-24T01:01:30Z"),
    });
    await runtime.log({
      level: "error",
      component: "runtime.core",
      event: "core.failed",
      outcome: "failed",
      instance_id: "instance-1",
    });
    const result = await readDiagnosticEvents(dataDir, {
      incidentId: marker.incident_id,
    });
    expect(result.events.map((item) => item.event)).toEqual([
      "connection.started",
      "incident.marked",
      "core.failed",
      "connection.failed",
    ]);
  });

  it("ignores symlinks and prunes files older than fourteen days", async () => {
    const dataDir = await root();
    const logs = path.join(dataDir, "logs");
    await mkdir(logs, { recursive: true, mode: 0o700 });
    const old = path.join(logs, "diagnostic-core.jsonl");
    await writeFile(old, "{}\n", { mode: 0o600 });
    const outside = path.join(await root(), "outside");
    await writeFile(outside, "private");
    await symlink(outside, path.join(logs, "diagnostic-runtime.jsonl"));
    const now = Date.now();
    await utimes(
      old,
      new Date(now - 15 * 86400_000),
      new Date(now - 15 * 86400_000),
    );
    await pruneDiagnosticLogs(dataDir, now);
    expect(await diagnosticLogFiles(dataDir)).toEqual([]);
  });

  it("deletes the oldest known log when the total budget is exceeded", async () => {
    const dataDir = await root();
    const logs = path.join(dataDir, "logs");
    await mkdir(logs, { recursive: true, mode: 0o700 });
    const old = path.join(logs, "diagnostic-core.jsonl");
    const recent = path.join(logs, "diagnostic-runtime.jsonl");
    await writeFile(old, "12345678", { mode: 0o600 });
    await writeFile(recent, "abcdefgh", { mode: 0o600 });
    await utimes(old, new Date(1_000), new Date(1_000));
    await utimes(recent, new Date(2_000), new Date(2_000));
    await pruneDiagnosticLogs(dataDir, 3_000, 8);
    expect(
      (await diagnosticLogFiles(dataDir)).map((file) => path.basename(file)),
    ).toEqual(["diagnostic-runtime.jsonl"]);
  });

  it("serializes concurrent writes and rotates bounded files", async () => {
    const dataDir = await root();
    const logger = new DiagnosticLogger({
      dataDir,
      service: "runtime",
      maxFileBytes: 512,
    });
    await Promise.all(
      Array.from({ length: 40 }, (_, index) =>
        logger.log({
          level: "info",
          component: "runtime.concurrent",
          event: "write.completed",
          outcome: "succeeded",
          details: { count: index },
        }),
      ),
    );
    expect((await diagnosticLogFiles(dataDir)).length).toBeGreaterThan(1);
    const result = await readDiagnosticEvents(dataDir, { tail: 5_000 });
    expect(result.invalid_lines).toBe(0);
    expect(result.events.length).toBeGreaterThan(0);
  });

  it("never follows a logs-directory symlink", async () => {
    const dataDir = await root();
    const outside = await root();
    await symlink(outside, path.join(dataDir, "logs"));
    const logger = new DiagnosticLogger({ dataDir, service: "runtime" });
    await logger.log({
      level: "error",
      component: "runtime.core",
      event: "core.failed",
      outcome: "failed",
    });
    expect(await readdir(outside)).toEqual([]);
  });
});