@kaeawc/auto-mobile 0.0.85 → 0.0.87

package/dist/src/db/migrations/2026_03_19_001_layout_events.ts

@@ -1,39 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable("layout_events")
-    .ifNotExists()
-    .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
-    .addColumn("device_id", "text")
-    .addColumn("timestamp", "integer", (col) => col.notNull())
-    .addColumn("application_id", "text")
-    .addColumn("session_id", "text")
-    .addColumn("sub_type", "text", (col) => col.notNull())
-    .addColumn("composable_name", "text")
-    .addColumn("composable_id", "text")
-    .addColumn("recomposition_count", "integer")
-    .addColumn("duration_ms", "integer")
-    .addColumn("likely_cause", "text")
-    .addColumn("details_json", "text")
-    .addColumn("created_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .execute();
-
-  await db.schema
-    .createIndex("idx_layout_events_timestamp")
-    .ifNotExists()
-    .on("layout_events")
-    .column("timestamp")
-    .execute();
-
-  await db.schema
-    .createIndex("idx_layout_events_device")
-    .ifNotExists()
-    .on("layout_events")
-    .column("device_id")
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("layout_events").ifExists().execute();
-}

package/dist/src/db/migrations/2026_03_19_002_storage_events_previous_value.ts

@@ -1,23 +0,0 @@
-import type { Kysely } from "kysely";
-import { sql } from "kysely";
-
-async function columnExists(
-  db: Kysely<unknown>,
-  tableName: string,
-  columnName: string,
-): Promise<boolean> {
-  const result = await sql<{ name: string }>`
-    SELECT name FROM pragma_table_info(${tableName}) WHERE name = ${columnName}
-  `.execute(db);
-  return result.rows.length > 0;
-}
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  if (!(await columnExists(db, "storage_events", "previous_value"))) {
-    await db.schema.alterTable("storage_events").addColumn("previous_value", "text").execute();
-  }
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.alterTable("storage_events").dropColumn("previous_value").execute();
-}

package/dist/src/db/migrations/2026_03_19_003_layout_events_screen_name.ts

@@ -1,23 +0,0 @@
-import type { Kysely } from "kysely";
-import { sql } from "kysely";
-
-async function columnExists(
-  db: Kysely<unknown>,
-  tableName: string,
-  columnName: string,
-): Promise<boolean> {
-  const result = await sql<{ name: string }>`
-    SELECT name FROM pragma_table_info(${tableName}) WHERE name = ${columnName}
-  `.execute(db);
-  return result.rows.length > 0;
-}
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  if (!(await columnExists(db, "layout_events", "screen_name"))) {
-    await db.schema.alterTable("layout_events").addColumn("screen_name", "text").execute();
-  }
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.alterTable("layout_events").dropColumn("screen_name").execute();
-}

package/dist/src/db/migrations/2026_03_20_000_network_event_details.ts

@@ -1,32 +0,0 @@
-import type { Kysely } from "kysely";
-import { sql } from "kysely";
-
-async function columnExists(
-  db: Kysely<unknown>,
-  tableName: string,
-  columnName: string,
-): Promise<boolean> {
-  const result = await sql<{ name: string }>`
-    SELECT name FROM pragma_table_info(${tableName}) WHERE name = ${columnName}
-  `.execute(db);
-  return result.rows.length > 0;
-}
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  const columns = [
-    "request_headers_json",
-    "response_headers_json",
-    "request_body",
-    "response_body",
-    "content_type",
-  ];
-  for (const col of columns) {
-    if (!(await columnExists(db, "network_events", col))) {
-      await db.schema.alterTable("network_events").addColumn(col, "text").execute();
-    }
-  }
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  // SQLite doesn't support DROP COLUMN easily; these columns are nullable and safe to leave
-}

package/dist/src/db/migrations/2026_04_01_000_drop_custom_events.ts

@@ -1,41 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("custom_events").ifExists().execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable("custom_events")
-    .ifNotExists()
-    .addColumn("id", "integer", (col) => col.primaryKey().autoIncrement())
-    .addColumn("device_id", "text")
-    .addColumn("timestamp", "integer", (col) => col.notNull())
-    .addColumn("application_id", "text")
-    .addColumn("session_id", "text")
-    .addColumn("name", "text", (col) => col.notNull())
-    .addColumn("properties_json", "text")
-    .addColumn("created_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .execute();
-
-  await db.schema
-    .createIndex("idx_custom_events_timestamp")
-    .ifNotExists()
-    .on("custom_events")
-    .column("timestamp")
-    .execute();
-
-  await db.schema
-    .createIndex("idx_custom_events_name")
-    .ifNotExists()
-    .on("custom_events")
-    .column("name")
-    .execute();
-
-  await db.schema
-    .createIndex("idx_custom_events_device")
-    .ifNotExists()
-    .on("custom_events")
-    .column("device_id")
-    .execute();
-}

package/dist/src/db/migrations/2026_04_02_000_device_sessions.ts

@@ -1,51 +0,0 @@
-import { type Kysely, sql } from "kysely";
-
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.schema
-    .createTable("device_sessions")
-    .ifNotExists()
-    .addColumn("session_uuid", "text", (col) => col.primaryKey())
-    .addColumn("device_id", "text", (col) => col.notNull())
-    .addColumn("platform", "text", (col) => col.notNull())
-    .addColumn("status", "text", (col) => col.notNull())
-    .addColumn("source", "text")
-    .addColumn("autolock_enabled", "integer", (col) => col.notNull().defaultTo(0))
-    .addColumn("mcp_session_id", "text")
-    .addColumn("daemon_session_id", "text")
-    .addColumn("created_at_ms", "integer", (col) => col.notNull())
-    .addColumn("last_used_at_ms", "integer", (col) => col.notNull())
-    .addColumn("expires_at_ms", "integer", (col) => col.notNull())
-    .addColumn("released_at_ms", "integer")
-    .addColumn("release_reason", "text")
-    .addColumn("session_timeout_ms", "integer", (col) => col.notNull())
-    .addColumn("heartbeat_timeout_ms", "integer", (col) => col.notNull())
-    .addColumn("has_received_heartbeat", "integer", (col) => col.notNull().defaultTo(0))
-    .addColumn("created_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .addColumn("updated_at", "text", (col) => col.notNull().defaultTo(sql`(datetime('now'))`))
-    .execute();
-
-  await db.schema
-    .createIndex("idx_device_sessions_device_id")
-    .ifNotExists()
-    .on("device_sessions")
-    .column("device_id")
-    .execute();
-
-  await db.schema
-    .createIndex("idx_device_sessions_status")
-    .ifNotExists()
-    .on("device_sessions")
-    .column("status")
-    .execute();
-
-  await db.schema
-    .createIndex("idx_device_sessions_mcp_session")
-    .ifNotExists()
-    .on("device_sessions")
-    .column("mcp_session_id")
-    .execute();
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.schema.dropTable("device_sessions").execute();
-}

package/dist/src/db/migrations/2026_07_01_000_failure_groups_signature_unique.ts

@@ -1,162 +0,0 @@
-import { Kysely, sql } from "kysely";
-
-/**
- * #2789 — make `failure_groups.signature` uniquely indexed and back-fill any
- * duplicate-signature rows that the original non-unique index allowed to
- * accumulate (the racy get-or-create in `recordFailure` could INSERT two groups
- * for one signature).
- *
- * ORDERING IS LOAD-BEARING. The migration connection runs with
- * `PRAGMA foreign_keys = ON` (`configureSqliteDatabase`, src/db/database.ts) and
- * these SQLite migrations are NOT wrapped in a DDL transaction by the migrator
- * (`SqliteAdapter.supportsTransactionalDdl === false`). `failure_occurrences`
- * and `failure_notifications` carry a CASCADE FK on `failure_occurrences.id` /
- * a plain `group_id`. So we MUST repoint children onto the keeper BEFORE
- * deleting loser groups — delete-first would CASCADE-wipe the occurrences we
- * mean to keep. We wrap the whole de-dup + index swap in ONE transaction so a
- * mid-way `CREATE UNIQUE INDEX` failure cannot leave losers already deleted.
- *
- * Keeper selection is a total order — `ORDER BY first_occurrence ASC, id ASC` —
- * so a same-millisecond burst (two groups tied on `first_occurrence`, the exact
- * scenario this bug produces) still collapses deterministically to one row and
- * `CREATE UNIQUE INDEX` cannot throw on a residual duplicate.
- *
- * Idempotent / safe on an empty DB so it survives #2785's destructive-recovery
- * replay (`resetDatabaseState` drops every table and re-runs all migrations):
- * with no duplicates the de-dup statements are no-ops and the index create uses
- * `IF NOT EXISTS`.
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  await db.transaction().execute(async (trx) => {
-    // 1. Repoint occurrences from loser groups onto their signature's keeper —
-    //    BEFORE any delete, so CASCADE cannot wipe them. A "loser" is any group
-    //    that is not the keeper (earliest first_occurrence, min id tiebreak)
-    //    for its signature.
-    await sql`
-      UPDATE failure_occurrences
-      SET group_id = (
-        SELECT k.id FROM failure_groups k
-        WHERE k.signature = (
-          SELECT g.signature FROM failure_groups g WHERE g.id = failure_occurrences.group_id
-        )
-        ORDER BY k.first_occurrence ASC, k.id ASC
-        LIMIT 1
-      )
-      WHERE group_id IN (
-        SELECT g.id FROM failure_groups g
-        WHERE g.id <> (
-          SELECT k.id FROM failure_groups k
-          WHERE k.signature = g.signature
-          ORDER BY k.first_occurrence ASC, k.id ASC
-          LIMIT 1
-        )
-      )
-    `.execute(trx);
-
-    // 2. Repoint notifications the same way. `failure_notifications.group_id` is
-    //    NOT a foreign key, so nothing cascades and nothing stops us — forget
-    //    this and notifications silently strand on a deleted group id.
-    await sql`
-      UPDATE failure_notifications
-      SET group_id = (
-        SELECT k.id FROM failure_groups k
-        WHERE k.signature = (
-          SELECT g.signature FROM failure_groups g WHERE g.id = failure_notifications.group_id
-        )
-        ORDER BY k.first_occurrence ASC, k.id ASC
-        LIMIT 1
-      )
-      WHERE group_id IN (
-        SELECT g.id FROM failure_groups g
-        WHERE g.id <> (
-          SELECT k.id FROM failure_groups k
-          WHERE k.signature = g.signature
-          ORDER BY k.first_occurrence ASC, k.id ASC
-          LIMIT 1
-        )
-      )
-    `.execute(trx);
-
-    // 3. Back-fill the keeper's aggregates (only for signatures that actually
-    //    had duplicates). total_count is the SUM of the historical counts so we
-    //    do not lose increments that predate retention pruning; last_occurrence
-    //    is the MAX so a collapsed group is not sorted stale on the dashboard
-    //    (getFailureGroups orders by last_occurrence); unique_sessions is
-    //    DERIVED from the now-repointed occurrences via COUNT(DISTINCT), the
-    //    same definition recordFailure uses post-fix (summing would double-count
-    //    a session present in two duplicate groups).
-    //
-    //    Note: single-group signatures whose stored counts drifted from the
-    //    lost-increment path (issue scenario #2, which does NOT create a second
-    //    row) are intentionally left untouched. total_count deliberately
-    //    preserves increments that predate retention pruning, so a blanket
-    //    recompute of COUNT(*) from surviving occurrences would DESTROY
-    //    legitimately-retained historical counts — the two cases are
-    //    indistinguishable after the fact, so we heal only where a duplicate row
-    //    already forces a merge.
-    await sql`
-      UPDATE failure_groups
-      SET
-        total_count = (
-          SELECT COALESCE(SUM(g2.total_count), 0)
-          FROM failure_groups g2
-          WHERE g2.signature = failure_groups.signature
-        ),
-        last_occurrence = (
-          SELECT MAX(g2.last_occurrence)
-          FROM failure_groups g2
-          WHERE g2.signature = failure_groups.signature
-        ),
-        unique_sessions = (
-          SELECT COUNT(DISTINCT o.session_id)
-          FROM failure_occurrences o
-          WHERE o.group_id = failure_groups.id
-        )
-      WHERE
-        (SELECT COUNT(*) FROM failure_groups d WHERE d.signature = failure_groups.signature) > 1
-        AND id = (
-          SELECT k.id FROM failure_groups k
-          WHERE k.signature = failure_groups.signature
-          ORDER BY k.first_occurrence ASC, k.id ASC
-          LIMIT 1
-        )
-    `.execute(trx);
-
-    // 4. Delete the losers. Children were repointed in steps 1-2, so CASCADE has
-    //    nothing left to take.
-    await sql`
-      DELETE FROM failure_groups
-      WHERE id <> (
-        SELECT k.id FROM failure_groups k
-        WHERE k.signature = failure_groups.signature
-        ORDER BY k.first_occurrence ASC, k.id ASC
-        LIMIT 1
-      )
-    `.execute(trx);
-
-    // 5. Swap the plain signature index for a UNIQUE one, and add a composite
-    //    index so the post-fix `COUNT(DISTINCT session_id)` recompute per event
-    //    does not scan every occurrence in the group.
-    await sql`DROP INDEX IF EXISTS idx_failure_groups_signature`.execute(trx);
-    await sql`
-      CREATE UNIQUE INDEX IF NOT EXISTS idx_failure_groups_signature
-      ON failure_groups (signature)
-    `.execute(trx);
-    await sql`
-      CREATE INDEX IF NOT EXISTS idx_failure_occurrences_group_session
-      ON failure_occurrences (group_id, session_id)
-    `.execute(trx);
-  });
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  await db.transaction().execute(async (trx) => {
-    await sql`DROP INDEX IF EXISTS idx_failure_occurrences_group_session`.execute(trx);
-    await sql`DROP INDEX IF EXISTS idx_failure_groups_signature`.execute(trx);
-    // Restore the original non-unique index.
-    await sql`
-      CREATE INDEX IF NOT EXISTS idx_failure_groups_signature
-      ON failure_groups (signature)
-    `.execute(trx);
-  });
-}

package/dist/src/db/migrations/2026_07_02_000_event_composite_indexes.ts

@@ -1,62 +0,0 @@
-import { type Kysely, sql } from "kysely";
-import { EVENT_TABLES } from "../eventTables";
-
-async function tableExists(db: Kysely<unknown>, tableName: string): Promise<boolean> {
-  const result = await sql<{ name: string }>`
-    SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${tableName}
-  `.execute(db);
-  return result.rows.length > 0;
-}
-
-/**
- * Composite (device_id, timestamp) indexes for the telemetry event tables (#2788).
- *
- * Every event getter queries `WHERE device_id=? [AND timestamp>=?]
- * ORDER BY timestamp DESC LIMIT n`, but each table only carries single-column
- * indexes on `device_id` and `timestamp` separately. SQLite uses at most one
- * index per query, so the `device_id` equality filter forces a temp B-tree
- * filesort for the `ORDER BY timestamp DESC`. A composite `(device_id,
- * timestamp)` index lets the planner satisfy the equality filter and produce the
- * ordering from a single index — scanning it backward for the DESC order — which
- * drops the sort entirely.
- *
- * No DESC in the index columns: SQLite scans a plain ascending index backward for
- * `ORDER BY ... DESC`, so a plain composite suffices (mirrors the precedent in
- * 2025_12_30_000_performance_thresholds.ts).
- *
- * Additive and forward-only, per #2788's explicit scope ("do not modify the
- * existing single-column indexes"):
- *   - The standalone `timestamp` index MUST stay — the retention cutoff query
- *     (`ORDER BY timestamp DESC LIMIT 1 OFFSET <cap>`, no device filter) uses it
- *     as a covering scan, and the composite cannot substitute because `device_id`
- *     leads the composite.
- *   - The standalone `device_id` index is now functionally redundant: the
- *     composite's `device_id` left-prefix serves every `device_id=?` access path
- *     (including `COUNT(*) WHERE device_id=?`). It is deliberately RETAINED here
- *     to keep this migration purely additive; dropping the six redundant
- *     `idx_<table>_device` indexes to cut per-insert write amplification is
- *     deferred to a follow-up so the change is reviewed on its own (see #2788).
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  for (const table of EVENT_TABLES) {
-    if (!(await tableExists(db, table))) {
-      continue;
-    }
-    // .ifNotExists() so the migration survives #2785's destructive-recovery
-    // replay (drop-all then replay every migration on an empty DB).
-    await db.schema
-      .createIndex(`idx_${table}_device_timestamp`)
-      .ifNotExists()
-      .on(table as never)
-      .columns(["device_id", "timestamp"] as never[])
-      .execute();
-  }
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  for (const table of EVENT_TABLES) {
-    // .ifExists() so a partial-up followed by down (recovery machinery can
-    // invoke migrations in unusual orders) does not throw.
-    await db.schema.dropIndex(`idx_${table}_device_timestamp`).ifExists().execute();
-  }
-}

package/dist/src/db/migrations/2026_07_03_000_drop_redundant_device_indexes.ts

@@ -1,66 +0,0 @@
-import { type Kysely, sql } from "kysely";
-import { EVENT_TABLES } from "../eventTables";
-
-async function tableExists(db: Kysely<unknown>, tableName: string): Promise<boolean> {
-  const result = await sql<{ name: string }>`
-    SELECT name FROM sqlite_master WHERE type = 'table' AND name = ${tableName}
-  `.execute(db);
-  return result.rows.length > 0;
-}
-
-/**
- * Drop the now-redundant single-column `idx_<table>_device` indexes on the six
- * telemetry event tables (#2893, follow-up to #2788 / PR #2890).
- *
- * PR #2890 added composite `(device_id, timestamp)` indexes
- * (`idx_<table>_device_timestamp`) but was deliberately kept additive-only per
- * #2788's scope ("do not modify the existing single-column indexes"). This
- * migration completes the optimization it deferred.
- *
- * A composite `(device_id, timestamp)` index serves every access path a
- * standalone `(device_id)` index can, via SQLite's left-prefix rule:
- *   - `WHERE device_id=?` — equality on the composite's leading column.
- *   - `WHERE device_id=? ORDER BY timestamp DESC` — filter + order from one index.
- *   - `COUNT(*) WHERE device_id=?` — covering scan of the composite.
- * There is no `ANALYZE`/`sqlite_stat1` in `src/db/`, so the planner chooses
- * structurally and deterministically; the standalone device index is dead weight
- * maintained on every insert for no read benefit. At the retention cap with a
- * high insert rate this is pure write amplification.
- *
- * Left intact (different query shapes — out of scope):
- *   - The standalone `timestamp` index: the retention cutoff query
- *     (`ORDER BY timestamp DESC LIMIT 1 OFFSET <cap>`, no device filter) uses it
- *     as a covering scan, and the composite CANNOT substitute because `device_id`
- *     leads the composite.
- *   - The category/content indexes (`idx_network_events_host`,
- *     `idx_log_events_tag`, `idx_os_events_category`).
- *
- * Forward-only, replay-safe (`.ifExists()` / `.ifNotExists()`) so the migration
- * survives #2785's destructive-recovery replay (drop-all then replay every
- * migration on an empty DB) in unusual orders. Sorts after
- * `2026_07_02_000_event_composite_indexes.ts`, so the composite that subsumes
- * each device index is guaranteed present when its device index is dropped.
- */
-export async function up(db: Kysely<unknown>): Promise<void> {
-  for (const table of EVENT_TABLES) {
-    // .ifExists() so replay on a DB that never had the standalone device index
-    // (or a partial recovery order) does not throw.
-    await db.schema.dropIndex(`idx_${table}_device`).ifExists().execute();
-  }
-}
-
-export async function down(db: Kysely<unknown>): Promise<void> {
-  for (const table of EVENT_TABLES) {
-    if (!(await tableExists(db, table))) {
-      continue;
-    }
-    // Recreate the single-column device index exactly as the base migrations
-    // defined it. .ifNotExists() so a down after a partial-up is idempotent.
-    await db.schema
-      .createIndex(`idx_${table}_device`)
-      .ifNotExists()
-      .on(table as never)
-      .column("device_id" as never)
-      .execute();
-  }
-}