Naite Viewer

import { createHash } from "crypto";

const configPath = "/project/api/src/sonamu.config.ts";
const hash = createHash("md5")
  .update(configPath)
  .digest("hex")
  .slice(0, 8);

// Example: "a1b2c3d4"
// Final socket path: ~/.sonamu/naite-a1b2c3d4.sock

// 1. Test start - Socket connection and run/start send
beforeAll(async () => {
  await NaiteReporter.startTestRun();
  // → send({ type: "run/start" })
});

// 2. Test execution - Naite log collection
test("create user", async () => {
  Naite.t("user:create:input", { username: "john" });

  const { user } = await userModel.create({ username: "john" });

  Naite.t("user:create:output", { userId: user.id });

  // afterEach runs after test ends
});

// 3. Test end - traces collection and send
afterEach(async ({ task }) => {
  // Collect all Naite logs with getAllTraces()
  task.meta.traces = Naite.getAllTraces();

  // Send to Extension
  await NaiteReporter.reportTestResult({
    testName: task.name,
    status: task.result?.state,
    traces: task.meta.traces,
    // ...
  });
  // → send({ type: "test/result", traces: [...] })
});

// 4. Full run end - run/end send and socket close
afterAll(() => {
  await NaiteReporter.endTestRun();
  // → send({ type: "run/end" })
  // → socket.end()
});

user:create:input
{ username: "john", email: "john@example.com" }

📍 Direct call location:
  /Users/.../user.model.test.ts:20

📚 Full callstack:
  1. test (user.model.test.ts:20)
     ↑ Click to navigate to this location
  2. createUser (user.model.ts:45)
  3. runWithMockContext (bootstrap.ts:58)

✓ full order processing flow (456ms)
  └─ order:validate:start     { orderId: 123 }
  └─ order:validate:done      { valid: true }
  └─ order:inventory:check    { productId: 456 }
  └─ order:inventory:available { quantity: 10 }
  └─ order:payment:start      { amount: 50000 }
  └─ order:payment:done       { transactionId: "tx_789" }
  └─ order:shipping:start     { orderId: 123 }
  └─ order:shipping:done      { trackingNumber: "TRK_001" }

✓ User entity full generation (2.3s)
  └─ syncer:generateAll:start     { entityId: "User" }
  └─ syncer:renderTemplate        { template: "model", entityId: "User" }
  └─ syncer:writeFile             { path: "user.model.ts" }
  └─ syncer:renderTemplate        { template: "types", entityId: "User" }
  └─ syncer:writeFile             { path: "user.types.ts" }
  └─ syncer:renderTemplate        { template: "service", entityId: "User" }
  └─ syncer:writeFile             { path: "user.service.ts" }
  └─ syncer:generateAll:done      { filesCreated: 3 }

✓ large data processing performance (5.2s)
  perf:start          12:34:56.000
  perf:fetch:start    12:34:56.001
  perf:fetch:done     12:34:57.500  ← 1.5 seconds
  perf:process:start  12:34:57.501
  perf:process:done   12:35:00.800  ← 3.3 seconds (bottleneck!)
  perf:save:start     12:35:00.801
  perf:save:done      12:35:01.200  ← 0.4 seconds
  perf:end            12:35:01.201

class NaiteReporterClass {
  private socketPath: string | null = null;
  private socket: Socket | null = null;
  private connected = false;
  private buffer: string[] = [];

  /**
   * Ensure socket connection
   * - Return immediately if already connected
   * - Store messages in buffer if connecting
   * - Ignore connection failure (Extension may be off)
   */
  private async ensureConnection(): Promise<void> {
    if (this.connected) return;

    return new Promise((resolve, reject) => {
      this.socketPath = getSocketPath();
      this.socket = connect(this.socketPath);

      this.socket.on("connect", () => {
        this.connected = true;

        // Send buffered messages
        for (const msg of this.buffer) {
          this.socket?.write(msg);
        }
        this.buffer = [];

        resolve();
      });

      this.socket.on("error", () => {
        // Ignore error as Extension may be off
        this.connected = false;
        this.socket = null;
        reject();
      });

      this.socket.on("close", () => {
        this.connected = false;
        this.socket = null;
      });
    });
  }

  /**
   * Send message
   * - Send immediately if connected
   * - Store in buffer if connecting
   */
  private async send(data: NaiteMessage): Promise<void> {
    const msg = `${JSON.stringify(data)}\n`;

    await this.ensureConnection().catch(() => {});

    if (this.connected && this.socket) {
      this.socket.write(msg);
    } else {
      this.buffer.push(msg);
    }
  }

  async startTestRun() {
    if (process.env.CI) return; // Ignore in CI

    await this.send({
      type: "run/start",
      startedAt: new Date().toISOString(),
    });
  }

  async reportTestResult(result: TestResult) {
    if (process.env.CI) return;

    await this.send({
      type: "test/result",
      receivedAt: new Date().toISOString(),
      ...result,
    });
  }

  async endTestRun() {
    if (process.env.CI) return;

    await this.send({
      type: "run/end",
      endedAt: new Date().toISOString(),
    });

    // Close socket
    if (this.socket) {
      this.socket.end();
      this.socket = null;
      this.connected = false;
    }
  }
}

export const test = Object.assign(
  async (title: string, fn: TestFunction<object>, options?: TestOptions) => {
    return vitestTest(title, options, async (context) => {
      await runWithMockContext(async () => {
        try {
          // Run test
          await fn(context);

          // Collect traces on success too
          context.task.meta.traces = Naite.getAllTraces();
        } catch (e: unknown) {
          // Collect traces on failure too (for error tracking)
          context.task.meta.traces = Naite.getAllTraces();
          throw e;
        }
      });
    });
  },
  // ... skip, only, todo handled the same way
);

// Send to Extension in afterEach
afterEach(async ({ task }) => {
  await NaiteReporter.reportTestResult({
    suiteName: task.suite?.name ?? "(no suite)",
    suiteFilePath: task.file?.filepath,
    testName: task.name,
    testFilePath: task.file?.filepath ?? "",
    testLine: task.location?.line ?? 0,
    status: task.result?.state ?? "pass",
    duration: task.result?.duration ?? 0,
    error: task.result?.errors?.[0]
      ? {
          message: task.result.errors[0].message,
          stack: task.result.errors[0].stack,
        }
      : undefined,
    traces: task.meta?.traces ?? [],
  });
});