Skip to content
Python
5.1 KB
Raw Blame
import { mkdtemp, rm, symlink } from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { DiagnosticLogger } from "@one-memory/runtime-control";
import { afterEach, expect, it } from "vitest";

import {
  followLogs,
  parseLogQuery,
  readLogReport,
  redactDiagnosticEvent,
  renderLogText,
} from "./log-report.js";

const roots: string[] = [];
afterEach(async () =>
  Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true }))),
);

it("parses bounded filters and refuses malformed identifiers", () => {
  expect(
    parseLogQuery(["--since", "15m", "--errors-only", "--tail", "25"]),
  ).toMatchObject({
    errorsOnly: true,
    tail: 25,
  });
  expect(parseLogQuery(["--tail", "5001"])).toBeNull();
  expect(parseLogQuery(["--trace", "not-a-uuid"])).toBeNull();
  expect(parseLogQuery(["--component", "../../private"])).toBeNull();
});

it("redacts unsafe details and absolute stack frames from the read surface", () => {
  const event = {
    schema_version: 1 as const,
    timestamp: "2026-09-24T02:00:00.000Z",
    level: "error" as const,
    service: "runtime" as const,
    component: "runtime.core",
    event: "core.failed",
    outcome: "failed",
    session_id: "11111111-1111-4111-8111-111111111111",
    details: {
      count: 1,
      reason: "/Users/me/private-query.txt",
      status: "sk-live-secret-token",
      source_id: "credential.private",
      prompt: "secret-token-123",
      authorization: "Bearer secret-token-123",
    } as unknown as Record<string, string | number | boolean | null>,
    safe_stack: [
      "packages/runtime-control/src/example.ts:42:7",
      "packages/runtime/sk-live-secret-token.ts:1:1",
      "/Users/me/private.py:1",
      "C:\\Users\\me\\private.py:1",
    ],
  };
  const redacted = redactDiagnosticEvent(event);
  expect(redacted.details).toEqual({ count: 1 });
  expect(redacted.safe_stack).toEqual([
    "packages/runtime-control/src/example.ts:42:7",
  ]);
  expect(JSON.stringify(redacted)).not.toContain("secret-token-123");
  expect(JSON.stringify(redacted)).not.toContain("sk-live-secret-token");
  expect(JSON.stringify(redacted)).not.toContain("credential.private");
  expect(JSON.stringify(redacted)).not.toContain("/Users/me");
  expect(JSON.stringify(redacted)).not.toContain("C:\\\\Users");
});

it("defaults to the newest session and renders correlation ids", async () => {
  const dataDir = await mkdtemp(path.join(os.tmpdir(), "om-cli-logs-"));
  roots.push(dataDir);
  const old = new DiagnosticLogger({
    dataDir,
    service: "runtime",
    sessionId: "11111111-1111-4111-8111-111111111111",
    now: () => new Date("2026-09-24T01:00:00Z"),
  });
  const recent = new DiagnosticLogger({
    dataDir,
    service: "desktop",
    sessionId: "22222222-2222-4222-8222-222222222222",
    now: () => new Date("2026-09-24T02:00:00Z"),
  });
  await old.log({
    level: "info",
    component: "runtime.service",
    event: "service.ready",
    outcome: "succeeded",
  });
  await recent.log({
    level: "error",
    component: "desktop.connection",
    event: "connection.failed",
    outcome: "failed",
    operation_id: "operation-1",
  });
  const query = parseLogQuery([]);
  expect(query).not.toBeNull();
  if (!query) throw new Error("query_missing");
  const report = await readLogReport(dataDir, query);
  expect(report.events).toHaveLength(1);
  expect(renderLogText(report.events, 0)).toContain("operation=operation-1");
});

it("follows a newly appended event without stopping Runtime", async () => {
  const dataDir = await mkdtemp(path.join(os.tmpdir(), "om-cli-follow-"));
  roots.push(dataDir);
  const logger = new DiagnosticLogger({ dataDir, service: "runtime" });
  await logger.log({
    level: "info",
    component: "runtime.service",
    event: "service.ready",
    outcome: "succeeded",
  });
  const seen: string[] = [];
  let waited = false;
  const query = parseLogQuery(["--follow"]);
  expect(query).not.toBeNull();
  if (!query) throw new Error("query_missing");
  await followLogs({
    dataDir,
    query,
    signal: new AbortController().signal,
    maxEvents: 2,
    emit: (event) => seen.push(event.event),
    wait: async () => {
      if (!waited) {
        waited = true;
        await logger.log({
          level: "error",
          component: "runtime.core",
          event: "core.failed",
          outcome: "failed",
          error_code: "core_failed",
        });
      }
    },
  });
  expect(seen).toEqual(["service.ready", "core.failed"]);
});

it("fails follow mode when the diagnostic directory is unsafe", async () => {
  const dataDir = await mkdtemp(
    path.join(os.tmpdir(), "om-cli-follow-unsafe-"),
  );
  const external = await mkdtemp(
    path.join(os.tmpdir(), "om-cli-follow-external-"),
  );
  roots.push(dataDir, external);
  await symlink(external, path.join(dataDir, "logs"));
  const query = parseLogQuery(["--follow"]);
  expect(query).not.toBeNull();
  if (!query) throw new Error("query_missing");
  await expect(
    followLogs({
      dataDir,
      query,
      signal: new AbortController().signal,
      maxEvents: 1,
      emit: () => undefined,
      wait: async () => undefined,
    }),
  ).rejects.toThrow("log_directory_unreadable");
});