@c4t4/heyamigo 0.8.15 → 0.9.0

package/dist/db/address.js

@@ -0,0 +1,72 @@
+// Channel-agnostic address shape. Inbound, outbound, async, browser,
+// and crons all carry an Address string. Sender worker parses the
+// channel prefix and dispatches to the matching ChannelAdapter.
+//
+// Serialized form (the wire shape stored in DB columns):
+//   wa:dm:17867@s.whatsapp.net
+//   wa:group:120363@g.us
+//   tg:dm:user_12345
+//   tg:group:-100123456
+//   system:cron:42
+//
+// First two segments are well-known. The third is the platform-native
+// external id, kept verbatim — easier to debug, lossless round-trip.
+export function formatAddress(addr) {
+    return `${addr.channel}:${addr.scope}:${addr.externalId}`;
+}
+export function parseAddress(s) {
+    const idx1 = s.indexOf(':');
+    const idx2 = s.indexOf(':', idx1 + 1);
+    if (idx1 < 0 || idx2 < 0) {
+        throw new Error(`bad address (need channel:scope:external_id): ${s}`);
+    }
+    const channel = s.slice(0, idx1);
+    const scope = s.slice(idx1 + 1, idx2);
+    const externalId = s.slice(idx2 + 1);
+    if (!externalId)
+        throw new Error(`bad address (empty external id): ${s}`);
+    return { channel, scope, externalId };
+}
+// Convert a raw Baileys JID into our address form. JID suffixes:
+//   @s.whatsapp.net → wa:dm
+//   @g.us           → wa:group
+//   @lid            → wa:dm (LID identities; canonicalized to wa:dm)
+//   @newsletter     → wa:group (broadcast/channel, treat as group-like)
+//
+// The full JID stays in externalId so it round-trips losslessly.
+export function jidToAddress(jid) {
+    if (jid.endsWith('@g.us')) {
+        return { channel: 'wa', scope: 'group', externalId: jid };
+    }
+    if (jid.endsWith('@newsletter')) {
+        return { channel: 'wa', scope: 'group', externalId: jid };
+    }
+    if (jid.endsWith('@s.whatsapp.net') || jid.endsWith('@lid')) {
+        return { channel: 'wa', scope: 'dm', externalId: jid };
+    }
+    // Unknown WA jid shape — preserve verbatim, default to DM.
+    return { channel: 'wa', scope: 'dm', externalId: jid };
+}
+// Reverse: pull the platform-native id back out. For WA this is the
+// JID; ChannelAdapter implementations use it directly.
+export function addressToExternalId(addr) {
+    const a = typeof addr === 'string' ? parseAddress(addr) : addr;
+    return a.externalId;
+}
+// Convenience predicates.
+export function isGroup(addr) {
+    const a = typeof addr === 'string' ? parseAddress(addr) : addr;
+    return a.scope === 'group';
+}
+export function isDm(addr) {
+    const a = typeof addr === 'string' ? parseAddress(addr) : addr;
+    return a.scope === 'dm';
+}
+// System addresses for bot-internal flows (cron-fired self-prompts,
+// task-spawned messages without an originating chat).
+export function systemCronAddress(cronId) {
+    return `system:cron:${cronId}`;
+}
+export function systemTaskAddress(taskId) {
+    return `system:task:${taskId}`;
+}

package/dist/db/check.js

@@ -0,0 +1,74 @@
+// Schema drift detector. Runs after migrations succeed. Compares the
+// live database's table set against the set drizzle's schema.ts
+// declares, refuses to start on mismatch.
+//
+// What this catches:
+//   - "Forgot to run `drizzle-kit generate` after editing schema.ts"
+//     → migration didn't include the new table; drift detected.
+//   - "Someone ran `ALTER TABLE` directly in prod" → extra columns or
+//     missing columns vs. schema.ts.
+//
+// What this does NOT catch (intentionally — keeps the check simple
+// and predictable):
+//   - Column type changes that SQLite stored compatibly.
+//   - Index differences (drizzle doesn't always emit identical CREATE
+//     INDEX text; comparing index DDL is fragile).
+//   - Drift in non-drizzle tables (e.g. __drizzle_migrations itself).
+//
+// If we ever need stricter checking, add it here behind a config flag.
+// Start strict-but-narrow; loosen if it bites.
+import { getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
+import { logger } from '../logger.js';
+import * as schema from './schema.js';
+export class SchemaDriftError extends Error {
+    diffs;
+    constructor(diffs) {
+        super(`schema drift detected:\n  - ${diffs.join('\n  - ')}`);
+        this.diffs = diffs;
+        this.name = 'SchemaDriftError';
+    }
+}
+export function checkSchemaDrift(db) {
+    const diffs = [];
+    // Discover declared tables by walking the schema module's exports.
+    // SQLiteTable is a real class; instanceof is the cleanest discriminator.
+    const declared = Object.values(schema)
+        .filter((v) => v instanceof SQLiteTable)
+        .map(t => getTableConfig(t));
+    const liveTables = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' AND name NOT LIKE '__drizzle_%'")
+        .all();
+    const liveTableNames = new Set(liveTables.map(r => r.name));
+    for (const t of declared) {
+        if (!liveTableNames.has(t.name)) {
+            diffs.push(`missing table: ${t.name}`);
+            continue;
+        }
+        const liveCols = db
+            .prepare(`PRAGMA table_info(${t.name})`)
+            .all();
+        const liveColNames = new Set(liveCols.map(c => c.name));
+        const declaredColNames = new Set(t.columns.map(c => c.name));
+        for (const c of t.columns) {
+            if (!liveColNames.has(c.name)) {
+                diffs.push(`${t.name}: missing column "${c.name}"`);
+            }
+        }
+        for (const name of liveColNames) {
+            if (!declaredColNames.has(name)) {
+                diffs.push(`${t.name}: unexpected column "${name}" (drift)`);
+            }
+        }
+    }
+    // Unexpected tables (drift from out-of-band CREATE TABLE)
+    for (const name of liveTableNames) {
+        if (!declared.some(t => t.name === name)) {
+            diffs.push(`unexpected table "${name}" (drift)`);
+        }
+    }
+    if (diffs.length > 0) {
+        logger.fatal({ diffs }, 'schema drift detected; bot refuses to start');
+        throw new SchemaDriftError(diffs);
+    }
+    logger.debug({ tables: declared.map(t => t.name) }, 'schema check passed');
+}

package/dist/db/index.js

@@ -0,0 +1,44 @@
+// Process-wide SQLite handle. Initialized once at boot in src/index.ts
+// (and in any other entry point that needs DB access, like `setup`).
+// Workers and other modules get the handle via `getDb()` — never open
+// their own.
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { resolve } from 'path';
+import * as schema from './schema.js';
+import { runMigrations } from './migrate.js';
+import { checkSchemaDrift } from './check.js';
+let rawDb = null;
+let ormDb = null;
+export function dbPath() {
+    return resolve(process.cwd(), 'storage', 'heyamigo.db');
+}
+// Run migrations + drift check + open the singleton. Call once per
+// process at boot. Idempotent — subsequent calls return the existing
+// handle without re-migrating.
+export function initDb() {
+    if (ormDb)
+        return ormDb;
+    const path = dbPath();
+    rawDb = runMigrations(path);
+    checkSchemaDrift(rawDb);
+    ormDb = drizzle(rawDb, { schema });
+    return ormDb;
+}
+export function getDb() {
+    if (!ormDb)
+        throw new Error('db not initialized; call initDb() at boot');
+    return ormDb;
+}
+export function getRawDb() {
+    if (!rawDb)
+        throw new Error('db not initialized; call initDb() at boot');
+    return rawDb;
+}
+// Used by graceful shutdown.
+export function closeDb() {
+    if (rawDb) {
+        rawDb.close();
+        rawDb = null;
+        ormDb = null;
+    }
+}

package/dist/db/migrate.js

@@ -0,0 +1,113 @@
+// Migration runner. Called once at boot from src/index.ts before any
+// worker spins up. Order: pre-migration backup → drizzle migrator →
+// drift check (in src/db/check.ts). If anything throws, the bot
+// refuses to start.
+import Database from 'better-sqlite3';
+import { drizzle } from 'drizzle-orm/better-sqlite3';
+import { migrate } from 'drizzle-orm/better-sqlite3/migrator';
+import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { logger } from '../logger.js';
+// Resolve `migrations/` relative to the package install, not cwd. When
+// installed via npm, the bot runs from the user's project dir but the
+// migration SQL files ship inside @c4t4/heyamigo. From src/db/migrate.ts:
+//   dist/db/migrate.js  ←  __filename
+//   dist/db/            ←  dirname
+//   dist/               ←  ../
+//   <pkg root>/         ←  ../../
+//   <pkg root>/migrations
+const PKG_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const MIGRATIONS_FOLDER = resolve(PKG_ROOT, 'migrations');
+const BACKUP_DIR_NAME = 'backups';
+const KEEP_PRE_MIGRATION_BACKUPS = 10;
+// VACUUM INTO is atomic and produces a fully consistent copy even
+// while the DB is being written to. Trivial insurance before any
+// schema change. Skip if no pending migrations to avoid noise on
+// no-op boots.
+function preMigrationBackup(dbPath) {
+    // Cheap check: open the DB, ask the migrator what would happen.
+    // We can't easily query "what's pending" without invoking drizzle's
+    // internals, so instead we check whether our migrations folder has
+    // more entries than the drizzle tracking table claims.
+    const sqlFiles = existsSync(MIGRATIONS_FOLDER)
+        ? readdirSync(MIGRATIONS_FOLDER).filter(f => f.endsWith('.sql'))
+        : [];
+    if (sqlFiles.length === 0)
+        return null;
+    let appliedCount = 0;
+    if (existsSync(dbPath)) {
+        const probe = new Database(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            const row = probe
+                .prepare("SELECT count(*) AS n FROM sqlite_master WHERE type='table' AND name='__drizzle_migrations'")
+                .get();
+            if (row.n > 0) {
+                const counted = probe
+                    .prepare('SELECT count(*) AS n FROM __drizzle_migrations')
+                    .get();
+                appliedCount = counted.n;
+            }
+        }
+        finally {
+            probe.close();
+        }
+    }
+    if (appliedCount >= sqlFiles.length)
+        return null; // up to date, nothing to back up for
+    const backupDir = resolve(dirname(dbPath), BACKUP_DIR_NAME);
+    mkdirSync(backupDir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    const backupPath = resolve(backupDir, `pre-migration-${ts}.db`);
+    if (existsSync(dbPath)) {
+        const tmp = new Database(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            tmp.exec(`VACUUM INTO '${backupPath.replace(/'/g, "''")}'`);
+        }
+        finally {
+            tmp.close();
+        }
+        logger.info({ backupPath }, 'pre-migration backup written');
+    }
+    else {
+        // No DB yet — nothing to back up. Boot will create it fresh.
+        return null;
+    }
+    rotatePreMigrationBackups(backupDir);
+    return backupPath;
+}
+function rotatePreMigrationBackups(backupDir) {
+    const files = readdirSync(backupDir)
+        .filter(f => f.startsWith('pre-migration-') && f.endsWith('.db'))
+        .map(f => ({ name: f, path: resolve(backupDir, f), mtime: statSync(resolve(backupDir, f)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime);
+    const toDelete = files.slice(KEEP_PRE_MIGRATION_BACKUPS);
+    for (const f of toDelete) {
+        try {
+            unlinkSync(f.path);
+        }
+        catch (err) {
+            logger.warn({ err, file: f.name }, 'failed to delete old backup');
+        }
+    }
+}
+export function runMigrations(dbPath) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    const backupPath = preMigrationBackup(dbPath);
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL'); // required for litestream
+    db.pragma('foreign_keys = ON');
+    const drizzleDb = drizzle(db);
+    try {
+        migrate(drizzleDb, { migrationsFolder: MIGRATIONS_FOLDER });
+    }
+    catch (err) {
+        logger.fatal({ err, backupPath }, 'migration failed; refusing to start. restore the pre-migration backup if needed.');
+        db.close();
+        throw err;
+    }
+    if (backupPath) {
+        logger.info('migrations applied successfully');
+    }
+    return db;
+}

package/dist/db/schema.js

@@ -0,0 +1,53 @@
+// Schema source of truth. Every DDL change goes here first, then
+// `npx drizzle-kit generate` produces a SQL migration in migrations/.
+// Direct ALTER/CREATE/DROP outside this flow is forbidden — see the
+// "Cardinal rule" section in refactor.md.
+import { sqliteTable, text, integer, primaryKey, index } from 'drizzle-orm/sqlite-core';
+// ──────────────────────────────────────────────────────────────────
+// Identity
+// ──────────────────────────────────────────────────────────────────
+// Canonical humans the bot knows about. One row per real person; same
+// person on multiple channels = multiple rows in `identities`, one row
+// here.
+export const persons = sqliteTable('persons', {
+    id: text('id').primaryKey(),
+    displayName: text('display_name'),
+    timezone: text('timezone'),
+    createdAt: integer('created_at').notNull(),
+});
+// Channel-addressable identities resolving to a person. Address is
+// channel-prefixed: wa:dm:..., wa:group:..., tg:dm:..., etc.
+export const identities = sqliteTable('identities', {
+    personId: text('person_id').notNull().references(() => persons.id),
+    address: text('address').notNull().unique(),
+    addedAt: integer('added_at').notNull(),
+}, t => ({
+    pk: primaryKey({ columns: [t.personId, t.address] }),
+}));
+// ──────────────────────────────────────────────────────────────────
+// Runtime control
+// ──────────────────────────────────────────────────────────────────
+// Worker registry. Every worker (chat, async, browser, sender, memory,
+// orchestrator) inserts a row at startup and updates last_seen as a
+// heartbeat. Orchestrator uses this for liveness detection and
+// graceful shutdown drain (see refactor.md §Workers).
+export const workers = sqliteTable('workers', {
+    id: text('id').primaryKey(), // `${hostname}-${pid}-${slot}`
+    kind: text('kind').notNull(), // 'chat'|'async'|'browser'|'sender'|'memory'|'orchestrator'
+    status: text('status').notNull(), // 'idle'|'busy'|'draining'|'dead'
+    currentJob: text('current_job'), // 'queue:id' if busy
+    lastSeen: integer('last_seen').notNull(),
+    startedAt: integer('started_at').notNull(),
+}, t => ({
+    byKindStatus: index('workers_by_kind_status').on(t.kind, t.status),
+    byLastSeen: index('workers_by_last_seen').on(t.lastSeen),
+}));
+// Bot-wide control signals. Insert a row to request shutdown/pause/
+// reload; orchestrator picks it up on its next tick. Single-key, so
+// using PK on key gives us upsert semantics.
+export const control = sqliteTable('control', {
+    key: text('key').primaryKey(), // 'shutdown'|'pause'|'reload_config'
+    value: text('value'),
+    requestedBy: text('requested_by'),
+    requestedAt: integer('requested_at').notNull(),
+});

package/dist/index.js

@@ -1,3 +1,4 @@
+import { closeDb, initDb } from './db/index.js';
 import { attachIncoming } from './gateway/incoming.js';
 import { handleReply } from './gateway/outgoing.js';
 import { logger } from './logger.js';
@@ -6,6 +7,10 @@ import { replayPending } from './queue/queue.js';
 import { startSocket } from './wa/socket.js';
 async function main() {
     logger.info('heyamigo starting');
+    // Migrations + drift check first; refuses to start on schema mismatch.
+    // Additive — flat-file storage (sessions.json, memory files,
+    // access.json) still authoritative until later phases swap them.
+    initDb();
     startScheduler();
     await startSocket((sock) => {
         attachIncoming(sock);
@@ -18,10 +23,12 @@ async function main() {
 }
 process.on('SIGINT', () => {
     logger.info('SIGINT received, shutting down');
+    closeDb();
     process.exit(0);
 });
 process.on('SIGTERM', () => {
     logger.info('SIGTERM received, shutting down');
+    closeDb();
     process.exit(0);
 });
 main().catch((err) => {

package/migrations/0000_phase0_identity_control.sql

@@ -0,0 +1,34 @@
+CREATE TABLE `control` (
+	`key` text PRIMARY KEY NOT NULL,
+	`value` text,
+	`requested_by` text,
+	`requested_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `identities` (
+	`person_id` text NOT NULL,
+	`address` text NOT NULL,
+	`added_at` integer NOT NULL,
+	PRIMARY KEY(`person_id`, `address`),
+	FOREIGN KEY (`person_id`) REFERENCES `persons`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+CREATE UNIQUE INDEX `identities_address_unique` ON `identities` (`address`);--> statement-breakpoint
+CREATE TABLE `persons` (
+	`id` text PRIMARY KEY NOT NULL,
+	`display_name` text,
+	`timezone` text,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `workers` (
+	`id` text PRIMARY KEY NOT NULL,
+	`kind` text NOT NULL,
+	`status` text NOT NULL,
+	`current_job` text,
+	`last_seen` integer NOT NULL,
+	`started_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `workers_by_kind_status` ON `workers` (`kind`,`status`);--> statement-breakpoint
+CREATE INDEX `workers_by_last_seen` ON `workers` (`last_seen`);

package/migrations/meta/0000_snapshot.json

@@ -0,0 +1,223 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "16f29db1-6a21-41fb-b7e2-933ea7384dad",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "control": {
+      "name": "control",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "requested_by": {
+          "name": "requested_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "requested_at": {
+          "name": "requested_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "identities": {
+      "name": "identities",
+      "columns": {
+        "person_id": {
+          "name": "person_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "identities_address_unique": {
+          "name": "identities_address_unique",
+          "columns": [
+            "address"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "identities_person_id_persons_id_fk": {
+          "name": "identities_person_id_persons_id_fk",
+          "tableFrom": "identities",
+          "tableTo": "persons",
+          "columnsFrom": [
+            "person_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "identities_person_id_address_pk": {
+          "columns": [
+            "person_id",
+            "address"
+          ],
+          "name": "identities_person_id_address_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "persons": {
+      "name": "persons",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workers": {
+      "name": "workers",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "current_job": {
+          "name": "current_job",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "workers_by_kind_status": {
+          "name": "workers_by_kind_status",
+          "columns": [
+            "kind",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "workers_by_last_seen": {
+          "name": "workers_by_last_seen",
+          "columns": [
+            "last_seen"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/migrations/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1779668680508,
+      "tag": "0000_phase0_identity_control",
+      "breakpoints": true
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.8.15",
+  "version": "0.9.0",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist/",
+    "migrations/",
     "config/config.example.json",
     "config/access.example.json",
     "config/personalities/",
@@ -52,15 +53,19 @@
     "@clack/prompts": "^1.2.0",
     "@hapi/boom": "^10.0.1",
     "baileys": "7.0.0-rc.9",
+    "better-sqlite3": "^12.10.0",
     "commander": "^14.0.3",
+    "drizzle-orm": "^0.45.2",
     "fastq": "^1.17.1",
     "pino": "^9.3.2",
     "qrcode": "^1.5.4",
     "zod": "^3.23.8"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/node": "^20.14.10",
     "@types/qrcode": "^1.5.5",
+    "drizzle-kit": "^0.31.10",
     "tsx": "^4.16.2",
     "typescript": "^5.5.3"
   }