@mycadet/assistant 0.12.9 → 0.12.10

package/src/live-voice/__tests__/live-voice-session-telemetry.test.ts

@@ -1,391 +0,0 @@
-/**
- * Live-voice session telemetry: the started/ended funnel rows a session
- * records, and the attribution carried on its turns.
- *
- * The recorder is mocked: the outbox and its consent gate are covered by
- * `telemetry-events-outbox.test.ts`. What these tests pin is the wiring that
- * decides whether a row exists at all and what it says, which is where the
- * measurement can silently go wrong: a session that fails before `ready` still
- * has to count, a failed session still has to record an end, and a session's
- * turns have to carry its id or the turn count has nothing to group on.
- */
-
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { VoiceTurnOptions } from "../../calls/voice-session-bridge.js";
-import type {
-  StreamingTranscriber,
-  SttStreamServerEvent,
-} from "../../stt/types.js";
-
-const recordLiveVoiceSessionStarted = mock(() => null);
-const recordLiveVoiceSessionEnded = mock(() => null);
-
-// Spread the real module rather than replacing it: other importers pull
-// `recordActivationEvent` and friends out of it, and a bare replacement makes
-// those imports fail to resolve.
-const onboardingEventsStore =
-  await import("../../onboarding/onboarding-events-store.js");
-mock.module("../../onboarding/onboarding-events-store.js", () => ({
-  ...onboardingEventsStore,
-  recordLiveVoiceSessionStarted,
-  recordLiveVoiceSessionEnded,
-}));
-
-// Types are erased, so they import statically regardless of the mock ordering
-// the values below depend on.
-import type { LiveVoiceCredentialReadiness } from "../live-voice-credential-preflight.js";
-import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
-import type {
-  LiveVoiceClientStartFrame,
-  LiveVoiceServerFrame,
-} from "../protocol.js";
-
-// Values load after `mock.module` so the session picks up the mocked recorder.
-const { LiveVoiceSession } = await import("../live-voice-session.js");
-const { LiveVoiceSessionStartupError } =
-  await import("../live-voice-session-manager.js");
-const { createLiveVoiceServerFrameSequencer } = await import("../protocol.js");
-
-const START_FRAME = {
-  type: "start",
-  conversationId: "conversation-123",
-  audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
-} as const satisfies LiveVoiceClientStartFrame;
-
-const NOT_READY: LiveVoiceCredentialReadiness = {
-  status: "not-ready",
-  missing: [
-    {
-      kind: "tts",
-      providerId: "fish-audio",
-      reason: 'TTS provider "fish-audio" is missing credentials',
-    },
-  ],
-  userMessage: "Live voice is unavailable because it requires an API key.",
-};
-
-class MockStreamingTranscriber implements StreamingTranscriber {
-  readonly providerId = "deepgram" as const;
-  readonly boundaryId = "daemon-streaming" as const;
-  private onEvent: ((event: SttStreamServerEvent) => void) | null = null;
-
-  constructor(private readonly stopEvents: SttStreamServerEvent[] = []) {}
-
-  async start(onEvent: (event: SttStreamServerEvent) => void): Promise<void> {
-    this.onEvent = onEvent;
-  }
-
-  sendAudio(): void {}
-
-  stop(): void {
-    for (const event of this.stopEvents) {
-      this.onEvent?.(event);
-    }
-  }
-}
-
-function createContext(
-  startFrame: LiveVoiceClientStartFrame = START_FRAME,
-): LiveVoiceSessionFactoryContext {
-  const sequencer = createLiveVoiceServerFrameSequencer();
-  const frames: LiveVoiceServerFrame[] = [];
-  return {
-    sessionId: "session-123",
-    startFrame,
-    sendFrame: mock(async (payload) => {
-      const frame = sequencer.next(payload);
-      frames.push(frame);
-      return frame;
-    }),
-  };
-}
-
-function readySession(startFrame?: LiveVoiceClientStartFrame) {
-  return new LiveVoiceSession(createContext(startFrame), {
-    resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
-    resolveCredentialReadiness: mock(
-      async (): Promise<LiveVoiceCredentialReadiness> => ({ status: "ready" }),
-    ),
-  });
-}
-
-describe("live-voice session telemetry", () => {
-  beforeEach(() => {
-    recordLiveVoiceSessionStarted.mockClear();
-    recordLiveVoiceSessionEnded.mockClear();
-  });
-
-  test("records a started row for a session that reaches ready", async () => {
-    const session = readySession();
-
-    await session.start();
-
-    expect(recordLiveVoiceSessionStarted).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "started_unknown:unknown",
-    });
-
-    await session.close("client_end");
-  });
-
-  test("stamps the started row with the client and entry the start frame declared", async () => {
-    // The dimension this row exists to carry: the same `macos` client covers
-    // the chat's voice button, the companion's Talk and the voice key, and
-    // only the entry says which one the user reached for.
-    const session = readySession({
-      ...START_FRAME,
-      client: "macos",
-      entry: "companion",
-    });
-
-    await session.start();
-
-    expect(recordLiveVoiceSessionStarted).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "started_macos:companion",
-    });
-
-    await session.close("client_end");
-  });
-
-  test("records a started row even when the preflight rejects the session", async () => {
-    const session = new LiveVoiceSession(createContext(), {
-      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
-      resolveCredentialReadiness: mock(async () => NOT_READY),
-    });
-
-    await expect(session.start()).rejects.toBeInstanceOf(
-      LiveVoiceSessionStartupError,
-    );
-
-    // The denominator of the failure rate: a session rejected before `ready`
-    // is exactly the one that must not go missing from the started count.
-    expect(recordLiveVoiceSessionStarted).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "started_unknown:unknown",
-    });
-  });
-
-  test("records the close reason and a completed outcome on a clean end", async () => {
-    const session = readySession();
-    await session.start();
-
-    await session.close("client_end");
-
-    // These sessions reach `ready` and are closed without ever sending audio,
-    // so they are silent by construction and the reason says which layer
-    // stopped short. See `telemetry/live-voice-funnel.ts`.
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "ended_client_end:silent_no_audio",
-      outcome: "completed",
-    });
-  });
-
-  /**
-   * Run one typed turn against a session with a real turn starter, then close.
-   *
-   * `readySession` wires none, so `handleTextTurn` returns before dispatching
-   * and every silence assertion against it passes for the wrong reason.
-   */
-  async function endAfterTypedTurn(frame: {
-    text: string;
-    hidden?: boolean;
-  }): Promise<void> {
-    let started = false;
-    const session = new LiveVoiceSession(createContext(), {
-      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
-      resolveCredentialReadiness: mock(
-        async (): Promise<LiveVoiceCredentialReadiness> => ({
-          status: "ready",
-        }),
-      ),
-      startVoiceTurn: mock(async () => {
-        started = true;
-        return { turnId: "bridge-turn-1", abort: mock() };
-      }),
-      emitMetrics: false,
-    });
-    await session.start();
-    await session.handleClientFrame({ type: "text", ...frame });
-    for (let attempt = 0; attempt < 40 && !started; attempt += 1) {
-      await new Promise((resolve) => setTimeout(resolve, 5));
-    }
-    if (!started) {
-      throw new Error("the typed turn never reached the bridge");
-    }
-    await session.close("client_end");
-  }
-
-  test("the greeting that opens a session does not spend its silence reason", async () => {
-    // The classification answers "did anything come from the person?". A
-    // session that greets and hears nothing back is silent, and counting the
-    // greeting would retire the taxonomy for every greeted session.
-    await endAfterTypedTurn({
-      text: "this message is sent automatically",
-      hidden: true,
-    });
-
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "ended_client_end:silent_no_audio",
-      outcome: "completed",
-    });
-  });
-
-  test("a turn the user really took clears the silence reason", async () => {
-    // The other half, and what keeps the test above honest: the same path with
-    // an ordinary typed turn is the person taking a turn, so the session is
-    // not silent and carries no classification at all.
-    await endAfterTypedTurn({ text: "typed by hand" });
-
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "ended_client_end",
-      outcome: "completed",
-    });
-  });
-
-  test("a dropped socket ends as completed, not failed", async () => {
-    const session = readySession();
-    await session.start();
-
-    await session.close("websocket_close");
-
-    // The session ran and then stopped; only an error makes it `failed`, and
-    // the reason on `screen` is what distinguishes a drop from a hangup.
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "ended_websocket_close:silent_no_audio",
-      outcome: "completed",
-    });
-  });
-
-  test("a failed session records an ended row carrying the failure code", async () => {
-    const session = new LiveVoiceSession(createContext(), {
-      resolveTranscriber: mock(async () => new MockStreamingTranscriber()),
-      resolveCredentialReadiness: mock(async () => NOT_READY),
-    });
-    await expect(session.start()).rejects.toBeInstanceOf(
-      LiveVoiceSessionStartupError,
-    );
-
-    // What the manager does after a startup failure.
-    await session.close("error");
-
-    // A failed session suppresses the client-facing `metrics` frame; the end
-    // row must not be suppressed with it.
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledWith({
-      sessionId: "session-123",
-      screen: "ended_error:credentials_unavailable",
-      outcome: "failed",
-    });
-  });
-
-  test("records exactly one ended row when close is called twice", async () => {
-    const session = readySession();
-    await session.start();
-
-    await session.close("client_end");
-    await session.close("websocket_close");
-
-    expect(recordLiveVoiceSessionEnded).toHaveBeenCalledTimes(1);
-  });
-});
-
-describe("live-voice turn attribution", () => {
-  /** Drives one push-to-talk turn and returns the options the bridge saw. */
-  async function captureTurnOptions(
-    startFrame: LiveVoiceClientStartFrame,
-  ): Promise<VoiceTurnOptions> {
-    let captured: VoiceTurnOptions | undefined;
-    const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
-      captured = options;
-      return { turnId: "bridge-turn-1", abort: mock() };
-    });
-    const session = new LiveVoiceSession(createContext(startFrame), {
-      resolveTranscriber: mock(
-        async () =>
-          new MockStreamingTranscriber([
-            { type: "final", text: "hello" },
-            { type: "closed" },
-          ]),
-      ),
-      startVoiceTurn,
-      emitMetrics: false,
-    });
-
-    await session.start();
-    await session.handleClientFrame({ type: "ptt_release" });
-    for (let attempt = 0; attempt < 40 && !captured; attempt += 1) {
-      await new Promise((resolve) => setTimeout(resolve, 5));
-    }
-    await session.close("client_end");
-
-    if (!captured) {
-      throw new Error("the live-voice session never started a bridge turn");
-    }
-    return captured;
-  }
-
-  test("carries the session id and originating client onto the turn", async () => {
-    const options = await captureTurnOptions({ ...START_FRAME, client: "ios" });
-
-    expect(options.voiceTelemetry).toEqual({
-      sessionId: "session-123",
-      client: "ios",
-    });
-  });
-
-  test("leaves the turn's interface id alone while attributing the client", async () => {
-    const options = await captureTurnOptions({ ...START_FRAME, client: "ios" });
-
-    // The load-bearing half of the attribution fix. `userMessageInterface`
-    // resolves the turn's channel capabilities, where `macos` is what grants a
-    // live-voice turn its dynamic surfaces; reporting the true client here
-    // would strip them from every iOS session. Attribution rides
-    // `voiceTelemetry` precisely so this can stay put.
-    expect(options.userMessageInterface).toBe("macos");
-    expect(options.assistantMessageInterface).toBe("macos");
-  });
-
-  test("a session opened from the macOS desktop client asks for the desktop skills", async () => {
-    const options = await captureTurnOptions({
-      ...START_FRAME,
-      client: "macos",
-    });
-
-    expect(options.macosDesktopSession).toBe(true);
-  });
-
-  test("a session from any other client does not ask for the desktop skills", async () => {
-    for (const startFrame of [{ ...START_FRAME, client: "ios" }, START_FRAME]) {
-      const options = await captureTurnOptions(
-        startFrame as LiveVoiceClientStartFrame,
-      );
-
-      expect(options.macosDesktopSession).toBeUndefined();
-    }
-  });
-
-  test("omits the client when the start frame declares none", async () => {
-    const options = await captureTurnOptions(START_FRAME);
-
-    expect(options.voiceTelemetry).toEqual({ sessionId: "session-123" });
-  });
-
-  test("carries the entry point onto the turn beside the client", async () => {
-    const options = await captureTurnOptions({
-      ...START_FRAME,
-      client: "macos",
-      entry: "voice_key",
-    });
-
-    expect(options.voiceTelemetry).toEqual({
-      sessionId: "session-123",
-      client: "macos",
-      entry: "voice_key",
-    });
-  });
-});

package/src/monitoring/__tests__/db-integrity-sample.test.ts

@@ -1,113 +0,0 @@
-/**
- * Tests for the quick_check probe. The corruption seed writes junk over a
- * b-tree page of a rollback-journal database (WAL would keep the data in the
- * -wal file, leaving the main file a bare header the check would pass).
- */
-
-import { closeSync, mkdtempSync, openSync, rmSync, writeSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { Database } from "bun:sqlite";
-import {
-  afterEach,
-  beforeEach,
-  expect,
-  setDefaultTimeout,
-  test,
-} from "bun:test";
-
-import { assertNotLiveDb } from "../../__tests__/assert-not-live-db.js";
-import {
-  boundErrors,
-  type IntegritySampleResult,
-  runIntegrityCheck,
-} from "../db-integrity-check.js";
-
-// quick_check and the cold `bun run` subprocess are disk-bound; loaded CI
-// runners blow past the 5s default.
-setDefaultTimeout(30_000);
-
-let dir: string;
-let dbPath: string;
-
-beforeEach(() => {
-  dir = mkdtempSync(join(tmpdir(), "integrity-sample-"));
-  dbPath = join(dir, "test.db");
-});
-
-afterEach(() => {
-  assertNotLiveDb(dir);
-  rmSync(dir, { recursive: true, force: true });
-});
-
-function seedDb(walMode: boolean): void {
-  const db = new Database(dbPath);
-  try {
-    db.exec(`PRAGMA journal_mode=${walMode ? "WAL" : "DELETE"}`);
-    db.exec("CREATE TABLE t (id TEXT PRIMARY KEY, v TEXT)");
-    const ins = db.prepare("INSERT INTO t (id, v) VALUES (?, ?)");
-    // One transaction: 200 per-insert commits are fsync-bound and take
-    // seconds on loaded CI runners.
-    db.transaction(() => {
-      for (let i = 0; i < 200; i++) {
-        ins.run(`k-${i}`, `v-${i}`);
-      }
-    })();
-  } finally {
-    db.close();
-  }
-}
-
-function corruptDb(): void {
-  const fd = openSync(dbPath, "r+");
-  try {
-    writeSync(fd, Buffer.alloc(32 * 1024, 0xff), 0, 32 * 1024, 4096);
-  } finally {
-    closeSync(fd);
-  }
-}
-
-test("returns null when the database does not exist", () => {
-  expect(runIntegrityCheck(dbPath)).toBeNull();
-});
-
-test("reports ok on a healthy database", () => {
-  seedDb(true);
-  const result = runIntegrityCheck(dbPath);
-  expect(result?.ok).toBe(true);
-  expect(result?.errors).toEqual([]);
-  expect(result?.pageCount).toBeGreaterThan(0);
-});
-
-test("reports corruption instead of throwing", () => {
-  seedDb(false);
-  corruptDb();
-  const result = runIntegrityCheck(dbPath);
-  expect(result?.ok).toBe(false);
-  expect(result?.errors.length).toBeGreaterThan(0);
-});
-
-test("boundErrors caps by UTF-8 bytes without splitting code points", () => {
-  const bounded = boundErrors(Array(20).fill("é".repeat(200)));
-  expect(bounded.length).toBe(10);
-  for (const msg of bounded) {
-    expect(Buffer.byteLength(msg, "utf8")).toBeLessThanOrEqual(160);
-    expect(msg.includes("�")).toBe(false);
-  }
-});
-
-test("subprocess entry prints the JSON verdict", () => {
-  seedDb(false);
-  corruptDb();
-  const entry = fileURLToPath(
-    new URL("../db-integrity-check.ts", import.meta.url),
-  );
-  const proc = Bun.spawnSync({ cmd: ["bun", "run", entry, dbPath] });
-  expect(proc.exitCode).toBe(0);
-  const result = JSON.parse(
-    proc.stdout.toString(),
-  ) as IntegritySampleResult | null;
-  expect(result?.ok).toBe(false);
-  expect(result?.errors.length).toBeGreaterThan(0);
-});