@mycadet/assistant 0.12.9 → 0.12.10

package/src/__tests__/conversation-surfaces-activation-emit.test.ts

@@ -1,400 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-
-import type { AssistantEvent } from "../api/index.js";
-
-// Analytics consent is granted so recordActivationEvent writes rows.
-let shareAnalytics = true;
-
-mock.module("../cloud/consent-cache.js", () => ({
-  getRawShareAnalytics: () => shareAnalytics,
-}));
-
-let broadcastedMessages: AssistantEvent[] = [];
-setBroadcastOverrideForTesting((msg: AssistantEvent) =>
-  broadcastedMessages.push(msg),
-);
-
-// Stub the child-conversation launcher so the launch_conversation commit path
-// runs without spinning up a real conversation.
-mock.module("../daemon/conversation-launch.js", () => ({
-  launchConversation: async () => ({ conversationId: "spawned-conv" }),
-}));
-
-const {
-  createSurfaceMutex,
-  handleSurfaceAction,
-  restoreSurfaceStateEntry,
-  surfaceProxyResolver,
-} = await import("../daemon/conversation-surfaces.js");
-
-import type { Conversation } from "../daemon/conversation.js";
-import type { ProcessMessageOptions } from "../daemon/conversation-process.js";
-import type { SurfaceType, UiSurfaceShow } from "../daemon/message-protocol.js";
-import {
-  getMemorySqlite,
-  getTelemetryDb,
-} from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
-import { telemetryEvents } from "../persistence/schema/index.js";
-import {
-  isActivationSession,
-  markActivationSession,
-} from "../plugins/defaults/memory/activation-session-store.js";
-import { setBroadcastOverrideForTesting } from "../runtime/assistant-event-hub.js";
-import { queryTelemetryOutboxBatch } from "../telemetry/telemetry-events-outbox.js";
-import type { OnboardingTelemetryEvent } from "../telemetry/types.js";
-
-await initializeDb();
-
-/** Pending onboarding outbox payloads, parsed, in `(created_at, id)` order. */
-function pendingOnboardingPayloads(): OnboardingTelemetryEvent[] {
-  return queryTelemetryOutboxBatch("onboarding", 10).map(
-    (row) => JSON.parse(row.payload) as OnboardingTelemetryEvent,
-  );
-}
-
-interface ProcessMessageCall {
-  content: string;
-  activeSurfaceId?: string;
-}
-
-function makeContext(
-  conversationId: string,
-  sent: AssistantEvent[] = [],
-): Conversation & {
-  processMessageCalls: ProcessMessageCall[];
-} {
-  const processMessageCalls: ProcessMessageCall[] = [];
-  return {
-    conversationId,
-    sendToClient: (msg: AssistantEvent) => sent.push(msg),
-    emit: (msg: AssistantEvent) => sent.push(msg),
-    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
-    lastSurfaceAction: new Map<
-      string,
-      { actionId: string; data?: Record<string, unknown> }
-    >(),
-    surfaceState: new Map(),
-    surfaceUndoStacks: new Map<string, string[]>(),
-    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
-    surfaceActionRequestIds: new Set<string>(),
-    currentTurnSurfaces: [],
-    isProcessing: () => false,
-    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
-    getQueueDepth: () => 0,
-    processMessage: async (options: ProcessMessageOptions) => {
-      processMessageCalls.push({
-        content: options.content,
-        activeSurfaceId: options.activeSurfaceId,
-      });
-      return "msg-1";
-    },
-    withSurface: createSurfaceMutex(),
-    processMessageCalls,
-  } as unknown as Conversation & {
-    processMessageCalls: ProcessMessageCall[];
-  };
-}
-
-function resetTables(): void {
-  getTelemetryDb()!.delete(telemetryEvents).run();
-  getMemorySqlite()!.exec("DELETE FROM activation_sessions");
-}
-
-/** Render a choice surface tagged (or not) with an activation_moment. */
-async function showTaggedChoice(
-  ctx: Conversation,
-  sent: AssistantEvent[],
-  activationMoment?: string,
-): Promise<string> {
-  await surfaceProxyResolver(ctx, "ui_show", {
-    surface_type: "choice",
-    title: "Pick an outcome",
-    data: {
-      options: [
-        { id: "inbox", title: "Clean up my inbox" },
-        { id: "calendar", title: "Plan my week" },
-      ],
-    },
-    ...(activationMoment ? { activation_moment: activationMoment } : {}),
-  });
-  const showMessage = sent.find(
-    (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-  ) as UiSurfaceShow;
-  return showMessage.surfaceId;
-}
-
-describe("activation moment emission from ui_show surface commits", () => {
-  beforeEach(() => {
-    shareAnalytics = true;
-    broadcastedMessages = [];
-    resetTables();
-  });
-
-  test("committed tagged surface in a marked session writes exactly one row", async () => {
-    markActivationSession("conv-marked");
-    expect(isActivationSession("conv-marked")).toBe(true);
-
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-marked", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, "moment_2");
-
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-
-    const rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
-    expect(rows[0]!.step_index).toBe(2);
-    expect(rows[0]!.session_id).toBe("conv-marked");
-  });
-
-  test("a queue-rejected commit does NOT emit; the tag survives for the retry", async () => {
-    markActivationSession("conv-rejected");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-rejected", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, "moment_2");
-
-    // First click while the queue is full: enqueue rejects, action not
-    // accepted. Must NOT record a milestone, and must leave the one-shot tag
-    // intact so the user's retry still emits.
-    ctx.enqueueMessage = () => ({
-      queued: false,
-      requestId: "req-rejected",
-      rejected: true,
-    });
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-
-    // Retry is accepted → records exactly one row.
-    ctx.enqueueMessage = () => ({ queued: false, requestId: "req-ok" });
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-    const rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
-  });
-
-  test("first_wow_executed records at SHOW time (no commit) and never double-emits", async () => {
-    markActivationSession("conv-wow");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-wow", sent);
-
-    // A display-only result surface tagged with the execution moment.
-    await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "card",
-      title: "Inbox cleaned",
-      data: { body: "Archived 1,240 emails" },
-      activation_moment: "first_wow_executed",
-    });
-
-    // Recorded immediately on render — no handleSurfaceAction commit needed.
-    let rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_first_wow_executed");
-    expect(rows[0]!.step_index).toBe(4);
-
-    // If the card later receives a commit (e.g. it carried an action), it must
-    // NOT double-emit — a show-timing tag is never stored for the commit path.
-    const showMessage = sent.find(
-      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-    ) as UiSurfaceShow;
-    await handleSurfaceAction(ctx, showMessage.surfaceId, "expand", {});
-    rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-  });
-
-  test("first_wow_executed in an UNMARKED session writes no row at show time", async () => {
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-wow-unmarked", sent);
-    await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "card",
-      title: "Result",
-      data: { body: "x" },
-      activation_moment: "first_wow_executed",
-    });
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-  });
-
-  test("does not forward the daemon-only tag to the client", async () => {
-    markActivationSession("conv-marked-2");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-marked-2", sent);
-    await showTaggedChoice(ctx, sent, "moment_2");
-
-    const showMessage = sent.find(
-      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-    ) as UiSurfaceShow;
-    expect(
-      (showMessage as unknown as Record<string, unknown>).activation_moment,
-    ).toBeUndefined();
-    expect(JSON.stringify(showMessage)).not.toContain("moment_2");
-  });
-
-  test("untagged surface writes no row", async () => {
-    markActivationSession("conv-untagged");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-untagged", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, undefined);
-
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-  });
-
-  test("tagged surface in an UNMARKED session writes no row", async () => {
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-not-rail", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, "moment_2");
-
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-  });
-
-  test("an invalid activation_moment token is ignored (no row)", async () => {
-    markActivationSession("conv-bad-tag");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-bad-tag", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, "bogus_moment");
-
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-  });
-
-  test("FIX 1: launch_conversation commit on a tagged surface records exactly one row", async () => {
-    markActivationSession("conv-launch");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-launch", sent);
-
-    // A launcher card tagged with a commit-timing moment. The committed action
-    // carries `_action: launch_conversation`, so handleSurfaceAction takes the
-    // inline-launch branch (which previously returned before the emit).
-    await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "card",
-      title: "Start something",
-      data: { body: "Kick off a draft" },
-      actions: [{ id: "go", label: "Go", style: "primary" }],
-      activation_moment: "moment_1",
-    });
-    const showMessage = sent.find(
-      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-    ) as UiSurfaceShow;
-    const surfaceId = showMessage.surfaceId;
-
-    await handleSurfaceAction(ctx, surfaceId, "go", {
-      _action: "launch_conversation",
-      title: "Draft",
-      seedPrompt: "Write a draft",
-    });
-
-    const rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_moment_1_complete");
-    expect(rows[0]!.session_id).toBe("conv-launch");
-  });
-
-  test("FIX 2: commit-timing tag survives a surfaceState restore from history", async () => {
-    markActivationSession("conv-restore");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-restore", sent);
-    const surfaceId = await showTaggedChoice(ctx, sent, "moment_2");
-
-    // The daemon-only tag must NOT leak to the client.
-    const showMessage = sent.find(
-      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-    ) as UiSurfaceShow;
-    expect(
-      (showMessage as unknown as Record<string, unknown>).activation_moment,
-    ).toBeUndefined();
-    expect(JSON.stringify(showMessage)).not.toContain("moment_2");
-
-    // Persist the surface into a history block exactly as the agent loop does
-    // (conversation-agent-loop-handlers): copy the activationMoment through.
-    const persisted = ctx.currentTurnSurfaces.map((s) => ({
-      type: "ui_surface" as const,
-      surfaceId: s.surfaceId,
-      surfaceType: s.surfaceType,
-      title: s.title,
-      data: s.data,
-      actions: s.actions,
-      ...(s.activationMoment ? { activationMoment: s.activationMoment } : {}),
-    }));
-    expect(persisted[0]!.activationMoment).toBe("moment_2");
-
-    // Simulate a reload: drop the in-memory surfaceState, then rebuild it
-    // from the persisted history block through the same helper
-    // `restoreSurfaceStateFromHistory` uses (including rehydrating the
-    // daemon-only tag).
-    ctx.surfaceState.clear();
-    for (const b of persisted) {
-      ctx.surfaceState.set(b.surfaceId, restoreSurfaceStateEntry(b));
-    }
-
-    // A commit after restore still records exactly one row.
-    await handleSurfaceAction(ctx, surfaceId, "inbox", {
-      choiceId: "inbox",
-      selectedIds: ["inbox"],
-    });
-
-    const rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_moment_2_complete");
-    expect(rows[0]!.session_id).toBe("conv-restore");
-  });
-
-  test("intermediate selection_changed does NOT emit; the terminal commit does", async () => {
-    markActivationSession("conv-table");
-    const sent: AssistantEvent[] = [];
-    const ctx = makeContext("conv-table", sent);
-
-    // A table surface stays pending across selection_changed (non-terminal).
-    await surfaceProxyResolver(ctx, "ui_show", {
-      surface_type: "table",
-      title: "Tasks",
-      data: {
-        columns: [{ id: "name", label: "Name" }],
-        rows: [
-          { id: "r1", cells: { name: "Task 1" } },
-          { id: "r2", cells: { name: "Task 2" } },
-        ],
-        selectionMode: "multiple",
-      },
-      actions: [{ id: "run", label: "Run", style: "primary" }],
-      activation_moment: "moment_3",
-    });
-    const showMessage = sent.find(
-      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
-    ) as UiSurfaceShow;
-    const surfaceId = showMessage.surfaceId;
-
-    // Intermediate, non-terminal — must NOT emit.
-    await handleSurfaceAction(ctx, surfaceId, "selection_changed", {
-      selectedIds: ["r1"],
-    });
-    expect(pendingOnboardingPayloads()).toHaveLength(0);
-
-    // Terminal commit — emits exactly once.
-    await handleSurfaceAction(ctx, surfaceId, "run", { selectedIds: ["r1"] });
-    const rows = pendingOnboardingPayloads();
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.step_name).toBe("activation_moment_3_complete");
-  });
-});

package/src/__tests__/internal-telemetry-routes.test.ts

@@ -1,213 +0,0 @@
-import { beforeEach, describe, expect, mock, spyOn, test } from "bun:test";
-
-import type { ConsentState } from "../cloud/consent-cache.js";
-
-// Toggle for the share_analytics consent the real store consults. The store
-// module is intentionally NOT mocked here — it has its own DB-backed tests, and
-// Bun's `mock.module` is process-global, so mocking it would leak into those
-// tests when files share an invocation. Exercising the real store keeps every
-// auth-fallback test order-independent.
-let shareAnalytics: ConsentState = true;
-
-mock.module("../cloud/consent-cache.js", () => ({
-  getRawShareAnalytics: () => shareAnalytics,
-}));
-
-// The watchdog relay must go through the direct (unbuffered) emit; capture the
-// forwarded arguments instead of POSTing to the cloud.
-const emitCalls: {
-  checkName: string;
-  detail: Record<string, unknown> | null;
-  value: number | null;
-}[] = [];
-mock.module("../telemetry/watchdog-direct-emit.js", () => ({
-  emitWatchdogEventDirect: async (
-    checkName: string,
-    detail: Record<string, unknown> | null,
-    value: number | null = null,
-  ) => {
-    emitCalls.push({ checkName, detail, value });
-  },
-}));
-
-import * as dbConnection from "../persistence/db-connection.js";
-import { initializeDb } from "../persistence/db-init.js";
-import { GATEWAY_PRINCIPALS } from "../runtime/auth/route-policy.js";
-import {
-  RouteError,
-  ServiceUnavailableError,
-} from "../runtime/routes/errors.js";
-import { ROUTES } from "../runtime/routes/internal-telemetry-routes.js";
-import type { RouteHandlerArgs } from "../runtime/routes/types.js";
-import {
-  discardPendingTelemetryOutboxEvents,
-  queryTelemetryOutboxBatch,
-} from "../telemetry/telemetry-events-outbox.js";
-import type { AuthFallbackTelemetryEvent } from "../telemetry/types.js";
-
-await initializeDb();
-
-function pendingAuthFallbackPayloads(): AuthFallbackTelemetryEvent[] {
-  return queryTelemetryOutboxBatch("auth_fallback", 100).map(
-    (r) => JSON.parse(r.payload) as AuthFallbackTelemetryEvent,
-  );
-}
-
-const route = ROUTES.find(
-  (r) => r.operationId === "internal_telemetry_auth_fallback",
-);
-
-function call(body: unknown) {
-  if (!route) {
-    throw new Error("route not found");
-  }
-  return route.handler({ body } as RouteHandlerArgs);
-}
-
-const VALID_BODY = {
-  window_start: 1000,
-  window_end: 2000,
-  counts: [
-    {
-      guard: "edge",
-      path: "/v1/messages",
-      failure_kind: "missing_authorization",
-      count: 5,
-    },
-  ],
-};
-
-describe("internal-telemetry-routes: auth-fallback", () => {
-  beforeEach(() => {
-    shareAnalytics = true;
-    discardPendingTelemetryOutboxEvents("auth_fallback");
-  });
-
-  test("route is locked to service-token callers (GATEWAY_PRINCIPALS + internal.write)", () => {
-    expect(route).toBeDefined();
-    expect(route?.endpoint).toBe("internal/telemetry/auth-fallback");
-    expect(route?.method).toBe("POST");
-    expect(route?.policy?.allowedPrincipalTypes).toEqual(GATEWAY_PRINCIPALS);
-    expect(route?.policy?.requiredScopes).toEqual(["internal.write"]);
-  });
-
-  test("valid batch is persisted to the outbox as a wire auth_fallback event", () => {
-    const result = call(VALID_BODY);
-    expect(result).toEqual({ recorded: 1 });
-
-    const payloads = pendingAuthFallbackPayloads();
-    expect(payloads.length).toBe(1);
-    expect(payloads[0]).toMatchObject({
-      type: "auth_fallback",
-      guard: "edge",
-      path: "/v1/messages",
-      failure_kind: "missing_authorization",
-      count: 5,
-      window_start: 1000,
-      window_end: 2000,
-    });
-  });
-
-  test("returns skipped and persists nothing under a confirmed opt-out", () => {
-    shareAnalytics = false;
-    expect(call(VALID_BODY)).toEqual({ skipped: true });
-    expect(pendingAuthFallbackPayloads().length).toBe(0);
-  });
-
-  test("records the batch while consent is unknown (a cold cache never drops data)", () => {
-    shareAnalytics = "unknown";
-    expect(call(VALID_BODY)).toEqual({ recorded: 1 });
-    expect(pendingAuthFallbackPayloads().length).toBe(1);
-  });
-
-  test("throws 503 when consent is on but the telemetry DB is unavailable, so the gateway re-queues", () => {
-    const spy = spyOn(dbConnection, "getTelemetryDb").mockReturnValue(null);
-    try {
-      expect(() => call(VALID_BODY)).toThrow(ServiceUnavailableError);
-    } finally {
-      spy.mockRestore();
-    }
-    expect(pendingAuthFallbackPayloads().length).toBe(0);
-
-    // Once the DB is back the same batch records normally.
-    expect(call(VALID_BODY)).toEqual({ recorded: 1 });
-  });
-
-  test("throws 503 (not skipped) when consent is unknown and the telemetry DB is unavailable", () => {
-    shareAnalytics = "unknown";
-    const spy = spyOn(dbConnection, "getTelemetryDb").mockReturnValue(null);
-    try {
-      expect(() => call(VALID_BODY)).toThrow(ServiceUnavailableError);
-    } finally {
-      spy.mockRestore();
-    }
-    expect(pendingAuthFallbackPayloads().length).toBe(0);
-  });
-
-  test("rejects a malformed body without persisting", () => {
-    expect(() => call({ window_start: 1000 })).toThrow(RouteError);
-    expect(() => call({ ...VALID_BODY, counts: [] })).toThrow(RouteError);
-    expect(() =>
-      call({
-        ...VALID_BODY,
-        counts: [{ guard: "edge", path: "/x", failure_kind: "y", count: 0 }],
-      }),
-    ).toThrow(RouteError);
-    expect(pendingAuthFallbackPayloads().length).toBe(0);
-  });
-});
-
-describe("internal-telemetry-routes: watchdog relay", () => {
-  const watchdogRoute = ROUTES.find(
-    (r) => r.operationId === "internal_telemetry_watchdog",
-  );
-
-  function callWatchdog(body: unknown) {
-    if (!watchdogRoute) {
-      throw new Error("route not found");
-    }
-    return watchdogRoute.handler({ body } as RouteHandlerArgs);
-  }
-
-  beforeEach(() => {
-    emitCalls.length = 0;
-  });
-
-  test("route is locked to service-token callers (GATEWAY_PRINCIPALS + internal.write)", () => {
-    expect(watchdogRoute).toBeDefined();
-    expect(watchdogRoute?.endpoint).toBe("internal/telemetry/watchdog");
-    expect(watchdogRoute?.method).toBe("POST");
-    expect(watchdogRoute?.policy?.allowedPrincipalTypes).toEqual(
-      GATEWAY_PRINCIPALS,
-    );
-    expect(watchdogRoute?.policy?.requiredScopes).toEqual(["internal.write"]);
-  });
-
-  test("valid event is forwarded to the direct emit", async () => {
-    const result = await callWatchdog({
-      check_name: "gateway_guardian_missing",
-      detail: { has_contacts: true, has_actor_tokens: false },
-    });
-    expect(result).toEqual({ ok: true });
-    expect(emitCalls).toEqual([
-      {
-        checkName: "gateway_guardian_missing",
-        detail: { has_contacts: true, has_actor_tokens: false },
-        value: null,
-      },
-    ]);
-  });
-
-  test("detail and value are optional", async () => {
-    await callWatchdog({ check_name: "some_check" });
-    expect(emitCalls).toEqual([
-      { checkName: "some_check", detail: null, value: null },
-    ]);
-  });
-
-  test("rejects a malformed body without emitting", async () => {
-    await expect(callWatchdog({})).rejects.toThrow(RouteError);
-    await expect(callWatchdog({ check_name: "" })).rejects.toThrow(RouteError);
-    expect(emitCalls.length).toBe(0);
-  });
-});