@mycadet/assistant 0.12.9 → 0.12.10

package/src/telemetry/telemetry-events-outbox.test.ts

@@ -1,375 +0,0 @@
-import { beforeEach, describe, expect, test } from "bun:test";
-
-import { getTelemetryDb } from "../persistence/db-connection.js";
-import { telemetryEvents } from "../persistence/schema/index.js";
-import { APP_VERSION } from "../version.js";
-import {
-  resetOutboxTable,
-  setShareAnalytics,
-  withTelemetryDbUnavailable,
-} from "./__tests__/outbox-test-harness.js";
-import {
-  deleteTelemetryOutboxEvents,
-  deleteTelemetryOutboxEventsBefore,
-  discardPendingTelemetryOutboxEvents,
-  insertTelemetryOutboxEvent,
-  insertTelemetryOutboxEvents,
-  queryTelemetryOutboxBatch,
-  recordTelemetryEvent,
-} from "./telemetry-events-outbox.js";
-import type { LifecycleTelemetryEvent } from "./types.js";
-
-function lifecycleEvent(
-  id: string,
-  createdAt: number,
-): LifecycleTelemetryEvent {
-  return {
-    type: "lifecycle",
-    daemon_event_id: id,
-    event_name: "app_open",
-    recorded_at: createdAt,
-    assistant_version: "1.2.3",
-  };
-}
-
-function insert(
-  id: string,
-  createdAt: number,
-  name = "lifecycle",
-  conversationId?: string | null,
-): boolean {
-  return insertTelemetryOutboxEvent({
-    id,
-    name,
-    createdAt,
-    conversationId,
-    event: lifecycleEvent(id, createdAt),
-  });
-}
-
-function allIds(): string[] {
-  return queryTelemetryOutboxBatch("lifecycle", 10_000).map((r) => r.id);
-}
-
-describe("telemetry-events-outbox", () => {
-  beforeEach(() => {
-    setShareAnalytics(true);
-    resetOutboxTable();
-  });
-
-  test("insert + query round-trips the wire payload", () => {
-    expect(insert("evt-1", 1000)).toBe(true);
-
-    const rows = queryTelemetryOutboxBatch("lifecycle", 10);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]).toMatchObject({ id: "evt-1", createdAt: 1000 });
-    expect(JSON.parse(rows[0]!.payload)).toEqual(lifecycleEvent("evt-1", 1000));
-  });
-
-  test("batch insert lands every row", () => {
-    const inserted = insertTelemetryOutboxEvents([
-      {
-        id: "evt-1",
-        name: "lifecycle",
-        createdAt: 1000,
-        event: lifecycleEvent("evt-1", 1000),
-      },
-      {
-        id: "evt-2",
-        name: "lifecycle",
-        createdAt: 2000,
-        event: lifecycleEvent("evt-2", 2000),
-      },
-      {
-        id: "evt-3",
-        name: "lifecycle",
-        createdAt: 3000,
-        event: lifecycleEvent("evt-3", 3000),
-      },
-    ]);
-    expect(inserted).toBe(true);
-    expect(allIds()).toEqual(["evt-1", "evt-2", "evt-3"]);
-  });
-
-  test("batch insert is all-or-nothing on a mid-batch failure", () => {
-    insert("evt-dup", 500);
-
-    expect(() =>
-      insertTelemetryOutboxEvents([
-        {
-          id: "evt-new-1",
-          name: "lifecycle",
-          createdAt: 1000,
-          event: lifecycleEvent("evt-new-1", 1000),
-        },
-        {
-          id: "evt-dup",
-          name: "lifecycle",
-          createdAt: 2000,
-          event: lifecycleEvent("evt-dup", 2000),
-        },
-        {
-          id: "evt-new-2",
-          name: "lifecycle",
-          createdAt: 3000,
-          event: lifecycleEvent("evt-new-2", 3000),
-        },
-      ]),
-    ).toThrow();
-
-    // The primary-key conflict aborts the whole statement — no partial batch.
-    expect(allIds()).toEqual(["evt-dup"]);
-  });
-
-  test("batch insert returns false when the telemetry DB is unavailable", () => {
-    withTelemetryDbUnavailable(() => {
-      expect(
-        insertTelemetryOutboxEvents([
-          {
-            id: "evt-1",
-            name: "lifecycle",
-            createdAt: 1000,
-            event: lifecycleEvent("evt-1", 1000),
-          },
-        ]),
-      ).toBe(false);
-    });
-    expect(allIds()).toEqual([]);
-  });
-
-  test("empty batch is a successful no-op", () => {
-    expect(insertTelemetryOutboxEvents([])).toBe(true);
-    expect(allIds()).toEqual([]);
-  });
-
-  test("conversation_id persists in its dedicated column", () => {
-    insert("evt-conv", 1000, "lifecycle", "conv-1");
-    insert("evt-null", 2000, "lifecycle");
-
-    const rows = getTelemetryDb()!
-      .select({
-        id: telemetryEvents.id,
-        conversationId: telemetryEvents.conversationId,
-      })
-      .from(telemetryEvents)
-      .all()
-      .sort((a, b) => a.id.localeCompare(b.id));
-    expect(rows).toEqual([
-      { id: "evt-conv", conversationId: "conv-1" },
-      { id: "evt-null", conversationId: null },
-    ]);
-  });
-
-  test("orders by (created_at, id) with id as tiebreaker", () => {
-    insert("evt-b", 2000);
-    insert("evt-c", 1000);
-    insert("evt-a", 1000);
-
-    expect(allIds()).toEqual(["evt-a", "evt-c", "evt-b"]);
-  });
-
-  test("honors the limit", () => {
-    insert("evt-1", 1000);
-    insert("evt-2", 2000);
-    insert("evt-3", 3000);
-
-    const rows = queryTelemetryOutboxBatch("lifecycle", 2);
-    expect(rows.map((r) => r.id)).toEqual(["evt-1", "evt-2"]);
-  });
-
-  test("queries are isolated per event name", () => {
-    insert("evt-life", 1000, "lifecycle");
-    insert("evt-watch", 1000, "watchdog");
-
-    expect(allIds()).toEqual(["evt-life"]);
-    expect(queryTelemetryOutboxBatch("watchdog", 10).map((r) => r.id)).toEqual([
-      "evt-watch",
-    ]);
-    expect(queryTelemetryOutboxBatch("onboarding", 10)).toEqual([]);
-  });
-
-  test("deletes rows by id", () => {
-    insert("evt-1", 1000);
-    insert("evt-2", 2000);
-    insert("evt-3", 3000);
-
-    deleteTelemetryOutboxEvents(["evt-1", "evt-3"]);
-
-    expect(allIds()).toEqual(["evt-2"]);
-  });
-
-  test("delete with an empty id list is a no-op", () => {
-    insert("evt-1", 1000);
-
-    deleteTelemetryOutboxEvents([]);
-
-    expect(allIds()).toEqual(["evt-1"]);
-  });
-
-  test("deletes more than one chunk of ids", () => {
-    const ids: string[] = [];
-    for (let i = 0; i < 501; i++) {
-      const id = `evt-${String(i).padStart(4, "0")}`;
-      ids.push(id);
-      insert(id, i);
-    }
-    insert("evt-keep", 9999);
-
-    deleteTelemetryOutboxEvents(ids);
-
-    expect(allIds()).toEqual(["evt-keep"]);
-  });
-
-  test("recordTelemetryEvent stamps the base fields", () => {
-    const fields = {
-      check_name: "db_size",
-      value: 42,
-      detail: { table: "messages" },
-    };
-    const recorded = recordTelemetryEvent("watchdog", fields);
-    expect(recorded).not.toBeNull();
-
-    const rows = queryTelemetryOutboxBatch("watchdog", 10);
-    expect(rows).toHaveLength(1);
-    expect(rows[0]!.id).toBe(recorded!.id);
-    expect(JSON.parse(rows[0]!.payload)).toEqual({
-      type: "watchdog",
-      daemon_event_id: recorded!.id,
-      recorded_at: recorded!.createdAt,
-      assistant_version: APP_VERSION,
-      ...fields,
-    });
-  });
-
-  test("recordTelemetryEvent stamps win over base keys smuggled in via a widened fields value", () => {
-    // A variable (not a literal) skips excess-property checking, so base
-    // keys can reach the helper structurally. The stamps must still win.
-    const widened = {
-      check_name: "db_size",
-      value: null,
-      detail: null,
-      daemon_event_id: "spoofed-id",
-      recorded_at: 1,
-      assistant_version: "0.0.0-spoof",
-    };
-    const recorded = recordTelemetryEvent("watchdog", widened);
-    expect(recorded).not.toBeNull();
-
-    const payload = JSON.parse(
-      queryTelemetryOutboxBatch("watchdog", 10)[0]!.payload,
-    ) as Record<string, unknown>;
-    expect(payload.daemon_event_id).toBe(recorded!.id);
-    expect(payload.recorded_at).toBe(recorded!.createdAt);
-    expect(payload.assistant_version).toBe(APP_VERSION);
-  });
-
-  test("recordTelemetryEvent persists conversation_id in its column", () => {
-    const withConv = recordTelemetryEvent(
-      "watchdog",
-      { check_name: "c1", value: null, detail: null },
-      { conversationId: "conv-1" },
-    );
-    const withoutConv = recordTelemetryEvent("watchdog", {
-      check_name: "c2",
-      value: null,
-      detail: null,
-    });
-
-    const rows = getTelemetryDb()!
-      .select({
-        id: telemetryEvents.id,
-        conversationId: telemetryEvents.conversationId,
-      })
-      .from(telemetryEvents)
-      .all();
-    expect(rows).toHaveLength(2);
-    expect(rows.find((r) => r.id === withConv!.id)!.conversationId).toBe(
-      "conv-1",
-    );
-    expect(rows.find((r) => r.id === withoutConv!.id)!.conversationId).toBe(
-      null,
-    );
-  });
-
-  test("recordTelemetryEvent honors a confirmed share_analytics opt-out", () => {
-    setShareAnalytics(false);
-    expect(
-      recordTelemetryEvent("watchdog", {
-        check_name: "c",
-        value: null,
-        detail: null,
-      }),
-    ).toBeNull();
-    expect(queryTelemetryOutboxBatch("watchdog", 10)).toEqual([]);
-  });
-
-  test("recordTelemetryEvent records while consent is unknown (cold cache)", () => {
-    setShareAnalytics("unknown");
-    const recorded = recordTelemetryEvent("watchdog", {
-      check_name: "c",
-      value: null,
-      detail: null,
-    });
-    expect(recorded).not.toBeNull();
-    expect(queryTelemetryOutboxBatch("watchdog", 10).map((r) => r.id)).toEqual([
-      recorded!.id,
-    ]);
-  });
-
-  test("recordTelemetryEvent returns null when the telemetry DB is unavailable", () => {
-    withTelemetryDbUnavailable(() => {
-      expect(
-        recordTelemetryEvent("watchdog", {
-          check_name: "c",
-          value: null,
-          detail: null,
-        }),
-      ).toBeNull();
-    });
-    expect(queryTelemetryOutboxBatch("watchdog", 10)).toEqual([]);
-  });
-
-  test("prune deletes rows strictly older than the cutoff across every name and returns the count", () => {
-    insert("evt-old-life", 1000, "lifecycle");
-    insert("evt-old-watch", 1500, "watchdog");
-    insert("evt-at-cutoff", 2000, "lifecycle");
-    insert("evt-fresh", 3000, "lifecycle");
-
-    expect(deleteTelemetryOutboxEventsBefore(2000)).toBe(2);
-
-    // Strictly-before semantics: the row AT the cutoff is retained.
-    expect(allIds()).toEqual(["evt-at-cutoff", "evt-fresh"]);
-    expect(queryTelemetryOutboxBatch("watchdog", 10)).toEqual([]);
-  });
-
-  test("prune with nothing expired deletes nothing and returns 0", () => {
-    insert("evt-1", 5000);
-
-    expect(deleteTelemetryOutboxEventsBefore(5000)).toBe(0);
-
-    expect(allIds()).toEqual(["evt-1"]);
-  });
-
-  test("prune returns 0 when the telemetry DB is unavailable", () => {
-    insert("evt-1", 1000);
-
-    withTelemetryDbUnavailable(() => {
-      expect(deleteTelemetryOutboxEventsBefore(2000)).toBe(0);
-    });
-
-    expect(allIds()).toEqual(["evt-1"]);
-  });
-
-  test("discards all pending rows for one name only", () => {
-    insert("evt-1", 1000, "lifecycle");
-    insert("evt-2", 2000, "lifecycle");
-    insert("evt-other", 1000, "watchdog");
-
-    discardPendingTelemetryOutboxEvents("lifecycle");
-
-    expect(allIds()).toEqual([]);
-    expect(queryTelemetryOutboxBatch("watchdog", 10).map((r) => r.id)).toEqual([
-      "evt-other",
-    ]);
-  });
-});

package/src/telemetry/telemetry-events-outbox.ts

@@ -1,237 +0,0 @@
-/**
- * Generic `telemetry_events` outbox on the dedicated telemetry database
- * (`assistant-telemetry.db`). Rows carry the full wire `TelemetryEvent` built
- * at record time and are deleted after a successful flush.
- * `recordTelemetryOutboxEvent` is the consent-owning record layer; the
- * storage seam functions carry no consent logic — their call sites own
- * gating.
- */
-import { asc, eq, inArray } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getRawShareAnalytics } from "../cloud/consent-cache.js";
-import { getSqliteFrom, getTelemetryDb } from "../persistence/db-connection.js";
-import { telemetryEvents } from "../persistence/schema/index.js";
-import { APP_VERSION } from "../version.js";
-import type {
-  OutboxTelemetryEventName,
-  OutboxTelemetryEventOf,
-  TelemetryEvent,
-  TelemetryEventBase,
-} from "./types.js";
-
-/** Ids per DELETE chunk — stays under SQLite's bound-variable limit. */
-const DELETE_CHUNK_SIZE = 500;
-
-/**
- * Max age of a pending outbox row. The reporter prunes older rows at the
- * start of every flush cycle, in every consent state — this is what bounds
- * the unknown-consent buffering (a permanently-unknown state never resolves,
- * and a row this stale is worthless telemetry anyway).
- */
-export const OUTBOX_MAX_ROW_AGE_MS = 30 * 24 * 60 * 60 * 1000;
-
-/** One pending outbox row; `payload` is the wire `TelemetryEvent` JSON. */
-export interface TelemetryOutboxRow {
-  id: string;
-  createdAt: number;
-  payload: string;
-}
-
-/** One pending telemetry event to insert; `event` is the wire payload. */
-export interface TelemetryOutboxInsert {
-  id: string;
-  name: string;
-  createdAt: number;
-  conversationId?: string | null;
-  event: TelemetryEvent;
-}
-
-/**
- * Insert a batch of pending telemetry events as one multi-row INSERT —
- * all-or-nothing, so a mid-batch failure never leaves a partial batch
- * committed. Returns false when the telemetry DB is unavailable (degraded
- * mode), true once every row is inserted (or the batch is empty).
- */
-export function insertTelemetryOutboxEvents(
-  rows: TelemetryOutboxInsert[],
-): boolean {
-  const db = getTelemetryDb();
-  if (!db) {
-    return false;
-  }
-  if (rows.length === 0) {
-    return true;
-  }
-  db.insert(telemetryEvents)
-    .values(
-      rows.map((row) => ({
-        id: row.id,
-        name: row.name,
-        createdAt: row.createdAt,
-        conversationId: row.conversationId ?? null,
-        payload: JSON.stringify(row.event),
-      })),
-    )
-    .run();
-  return true;
-}
-
-/**
- * Insert one pending telemetry event. Returns false when the telemetry DB is
- * unavailable (degraded mode), true once the row is inserted.
- */
-export function insertTelemetryOutboxEvent(
-  row: TelemetryOutboxInsert,
-): boolean {
-  return insertTelemetryOutboxEvents([row]);
-}
-
-/**
- * Lower-level record escape hatch: for payloads that need the record-time
- * `(id, createdAt)` inside type-specific fields (onboarding's activation
- * `daemon_event_id` override and `completed_at`). Drops only on a confirmed
- * `share_analytics` opt-out — the record-time drop is a privacy courtesy for
- * known opt-outs. While consent is unknown (cold cache, no platform session)
- * the event is recorded: dropping on an unresolved state would permanently
- * destroy data, and consent is enforced again at flush time. Unknown-state
- * buffering is bounded — the reporter prunes rows older than
- * {@link OUTBOX_MAX_ROW_AGE_MS} each flush cycle. Generates the
- * outbox row identity, builds the wire payload via `buildEvent` (which owns
- * all stamping), and inserts. Returns the generated row identity, or null
- * when dropped for the opt-out or when the telemetry DB is unavailable
- * (degraded mode). Prefer `recordTelemetryEvent` when the payload doesn't
- * need them.
- */
-export function recordTelemetryOutboxEvent(
-  name: string,
-  buildEvent: (id: string, createdAt: number) => TelemetryEvent,
-  opts?: { conversationId?: string | null },
-): { id: string; createdAt: number } | null {
-  if (getRawShareAnalytics() === false) {
-    return null;
-  }
-  const id = uuid();
-  const createdAt = Date.now();
-  const inserted = insertTelemetryOutboxEvent({
-    id,
-    name,
-    createdAt,
-    conversationId: opts?.conversationId ?? null,
-    event: buildEvent(id, createdAt),
-  });
-  return inserted ? { id, createdAt } : null;
-}
-
-/**
- * Preferred record API for outbox events whose payload does not depend on
- * the record-time `(id, createdAt)`: stamps the `TelemetryEventBase` fields
- * (record-time `assistant_version` included) and inherits
- * `recordTelemetryOutboxEvent`'s consent gate and degraded-mode `null`.
- */
-export function recordTelemetryEvent<N extends OutboxTelemetryEventName>(
-  name: N,
-  fields: Omit<OutboxTelemetryEventOf<N>, keyof TelemetryEventBase>,
-  opts?: { conversationId?: string | null },
-): { id: string; createdAt: number } | null {
-  return recordTelemetryOutboxEvent(
-    name,
-    (id, createdAt) =>
-      // Cast: TS cannot re-associate the `Omit<...>` spread with the stamped
-      // base fields across a generic; `fields`' type guarantees the shape.
-      // Base fields are stamped after the spread so a widened `fields` value
-      // carrying base keys can never override them.
-      ({
-        ...fields,
-        type: name,
-        daemon_event_id: id,
-        recorded_at: createdAt,
-        assistant_version: APP_VERSION,
-      }) as OutboxTelemetryEventOf<N>,
-    opts,
-  );
-}
-
-/**
- * Read the oldest pending rows for one event name in `(created_at, id)`
- * order. Empty when the telemetry DB is unavailable.
- */
-export function queryTelemetryOutboxBatch(
-  name: string,
-  limit: number,
-): TelemetryOutboxRow[] {
-  const db = getTelemetryDb();
-  if (!db) {
-    return [];
-  }
-  return db
-    .select({
-      id: telemetryEvents.id,
-      createdAt: telemetryEvents.createdAt,
-      payload: telemetryEvents.payload,
-    })
-    .from(telemetryEvents)
-    .where(eq(telemetryEvents.name, name))
-    .orderBy(asc(telemetryEvents.createdAt), asc(telemetryEvents.id))
-    .limit(limit)
-    .all();
-}
-
-/** Delete flushed rows by id, in chunks. No-op when db null or ids empty. */
-export function deleteTelemetryOutboxEvents(ids: string[]): void {
-  const db = getTelemetryDb();
-  if (!db || ids.length === 0) {
-    return;
-  }
-  for (let i = 0; i < ids.length; i += DELETE_CHUNK_SIZE) {
-    db.delete(telemetryEvents)
-      .where(inArray(telemetryEvents.id, ids.slice(i, i + DELETE_CHUNK_SIZE)))
-      .run();
-  }
-}
-
-/**
- * Delete rows recorded before `cutoffCreatedAt`, across every event name
- * (age-bound prune). Returns the deleted row count; 0 when the telemetry DB
- * is unavailable.
- */
-export function deleteTelemetryOutboxEventsBefore(
-  cutoffCreatedAt: number,
-): number {
-  const db = getTelemetryDb();
-  if (!db) {
-    return 0;
-  }
-  // Raw statement: drizzle's bun-sqlite `.run()` is typed void, and the
-  // prune's only output is the changed-row count.
-  return getSqliteFrom(db)
-    .prepare("DELETE FROM telemetry_events WHERE created_at < ?")
-    .run(cutoffCreatedAt).changes;
-}
-
-/** Drop all pending rows for one event name (telemetry opt-out). */
-export function discardPendingTelemetryOutboxEvents(name: string): void {
-  const db = getTelemetryDb();
-  if (!db) {
-    return;
-  }
-  db.delete(telemetryEvents).where(eq(telemetryEvents.name, name)).run();
-}
-
-/**
- * Distinct event names with at least one pending row in the outbox. Used by the
- * orphan-drain source to find rows whose type is no longer in the wire contract
- * (e.g. recorded before the cloud removed/renamed a type) so they can be
- * flushed instead of stranded. Empty when the telemetry DB is unavailable.
- */
-export function queryDistinctOutboxEventNames(): string[] {
-  const db = getTelemetryDb();
-  if (!db) {
-    return [];
-  }
-  return db
-    .selectDistinct({ name: telemetryEvents.name })
-    .from(telemetryEvents)
-    .all()
-    .map((row) => row.name);
-}

package/src/telemetry/telemetry-main-db.ts

@@ -1,48 +0,0 @@
-import {
-  type DrizzleDb,
-  getDb,
-  getMainDbReadOnly,
-} from "../persistence/db-connection.js";
-
-/**
- * Main-DB resolution for the telemetry stores' unreported-event queries.
- *
- * The queries run in two processes with different postures: the daemon owns
- * the main DB's read-write connection, while the resource monitor process
- * observes the daemon's main DB through a dedicated read-only connection
- * (WAL permits cross-process readers; the daemon stays the sole writer, and
- * an accidental monitor-side write fails loudly). The monitor opts into the
- * read-only posture once at startup; everything else resolves to the normal
- * read-write connection.
- */
-
-let readOnlyPosture = false;
-
-/**
- * Switch this process's telemetry main-DB reads to the dedicated read-only
- * connection. Called once at resource monitor startup, before the first
- * flush; never unset — the posture is process-scoped by design.
- */
-export function useReadOnlyMainDbForTelemetry(): void {
-  readOnlyPosture = true;
-}
-
-/**
- * The main-DB connection for telemetry queries: `getDb()`'s read-write
- * connection in the daemon, the dedicated read-only connection in the
- * resource monitor. Throws when the read-only connection cannot be opened
- * (e.g. a fresh install where the daemon has not created the file yet) —
- * the reporter's flush treats that as non-fatal and retries next cycle.
- */
-export function getTelemetryMainDb(): DrizzleDb {
-  if (!readOnlyPosture) {
-    return getDb();
-  }
-  const db = getMainDbReadOnly();
-  if (!db) {
-    throw new Error(
-      "read-only main DB connection unavailable — retried next flush cycle",
-    );
-  }
-  return db;
-}

package/src/telemetry/telemetry-wire-source.json

@@ -1,4 +0,0 @@
-{
-  "sourceRepo": "vargasjr-dev/mycadet-platform",
-  "sourceSha": "55599f8f2bc422177cc423020043577d7ee36264"
-}