@otto-assistant/otto 0.1.2 → 0.7.16

package/dist/db.js

@@ -0,0 +1,260 @@
+// Prisma client initialization with libsql adapter.
+// Uses OTTO_DB_URL env var when set (plugin process → Hrana HTTP),
+// otherwise falls back to direct file: access (bot process, CLI subcommands).
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import Database from 'libsql';
+import { PrismaLibSql } from '@prisma/adapter-libsql';
+import { PrismaClient, Prisma } from './generated/client.js';
+import { getDataDir } from './config.js';
+import { createLogger, formatErrorWithStack, LogPrefix } from './logger.js';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export { PrismaClient };
+// Under vitest, clear any inherited OTTO_DB_URL from the parent bot process
+// so tests default to file-based access using the auto-isolated temp data dir.
+// Tests that need Hrana (like the e2e test) can set OTTO_DB_URL explicitly
+// after import — getDbUrl() reads process.env dynamically on each call.
+if (process.env.OTTO_VITEST) {
+    delete process.env['OTTO_DB_URL'];
+}
+const dbLogger = createLogger(LogPrefix.DB);
+let prismaInstance = null;
+let initPromise = null;
+/**
+ * Get the singleton Prisma client instance.
+ * Initializes the database on first call, running schema setup if needed.
+ */
+export function getPrisma() {
+    if (prismaInstance) {
+        return Promise.resolve(prismaInstance);
+    }
+    if (initPromise) {
+        return initPromise;
+    }
+    initPromise = initializePrisma();
+    return initPromise;
+}
+/**
+ * Build the libsql connection URL.
+ * OTTO_DB_URL is set by the bot when spawning opencode plugin processes,
+ * pointing them at the in-process Hrana HTTP server. Future-proof for remote
+ * opencode processes on different machines.
+ * Without the env var (bot process, CLI subcommands), uses direct file: access.
+ */
+function getDbUrl() {
+    if (process.env.OTTO_DB_URL) {
+        return process.env.OTTO_DB_URL;
+    }
+    const dataDir = getDataDir();
+    const dbPath = path.join(dataDir, 'discord-sessions.db');
+    return `file:${dbPath}`;
+}
+function getDbAuthToken() {
+    const token = process.env.OTTO_DB_AUTH_TOKEN;
+    if (!token) {
+        return undefined;
+    }
+    return token;
+}
+async function initializePrisma() {
+    const dbUrl = getDbUrl();
+    const isFileMode = dbUrl.startsWith('file:');
+    if (isFileMode) {
+        const dataDir = getDataDir();
+        try {
+            fs.mkdirSync(dataDir, { recursive: true });
+        }
+        catch (e) {
+            dbLogger.error(`Failed to create data directory ${dataDir}:`, e.message);
+        }
+    }
+    dbLogger.log(`Opening database via: ${dbUrl}`);
+    const dbAuthToken = getDbAuthToken();
+    const adapter = new PrismaLibSql({
+        url: dbUrl,
+        ...(dbAuthToken && { authToken: dbAuthToken }),
+    });
+    const prisma = new PrismaClient({ adapter });
+    try {
+        if (isFileMode) {
+            // WAL mode allows concurrent reads while writing instead of blocking.
+            // busy_timeout makes SQLite retry for 5s instead of immediately failing with SQLITE_BUSY.
+            // The Hrana server (serving the plugin process) sets the same pragmas on its own connection.
+            // PRAGMAs are skipped for HTTP connections — they're connection-scoped and the Hrana
+            // server already configures them on its own libsql Database handle.
+            await prisma.$executeRawUnsafe('PRAGMA journal_mode = WAL');
+            await prisma.$executeRawUnsafe('PRAGMA busy_timeout = 5000');
+        }
+        // Always run migrations - schema.sql uses IF NOT EXISTS so it's idempotent
+        dbLogger.log('Running schema migrations...');
+        await migrateSchema(prisma);
+        dbLogger.log('Schema migration complete');
+    }
+    catch (error) {
+        dbLogger.error('Prisma init failed:', formatErrorWithStack(error));
+        throw error;
+    }
+    prismaInstance = prisma;
+    return prisma;
+}
+async function migrateSchema(prisma) {
+    // Helper: ALTER TABLE ADD COLUMN that bypasses Prisma's libsql adapter.
+    // Prisma wraps $executeRawUnsafe in implicit transactions; when a DDL
+    // statement fails (e.g. "duplicate column name") the transaction is
+    // marked as failed and subsequent statements in the same implicit
+    // transaction also fail — even if they would succeed independently.
+    // Direct libsql execution avoids this problem.
+    const alterTableAddColumn = (table, column, extra) => {
+        const dbPath = (() => {
+            const url = getDbUrl();
+            if (url.startsWith('file:')) {
+                return url.slice('file:'.length);
+            }
+            return null;
+        })();
+        if (!dbPath) {
+            // HTTP mode (Hrana) — fall back to Prisma and hope for the best
+            const sql = `ALTER TABLE ${table} ADD COLUMN ${column}${extra ? ` ${extra}` : ''}`;
+            return prisma.$executeRawUnsafe(sql).catch(() => { });
+        }
+        const db = new Database(dbPath);
+        try {
+            const cols = db.prepare(`PRAGMA table_info(${table})`).all();
+            const exists = cols.some((c) => {
+                return c.name === column;
+            });
+            if (exists) {
+                return;
+            }
+            const sql = `ALTER TABLE ${table} ADD COLUMN ${column}${extra ? ` ${extra}` : ''}`;
+            db.exec(sql);
+            dbLogger.log(`[MIGRATION] ${sql}`);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            dbLogger.warn(`[MIGRATION] ALTER TABLE ${table} ADD COLUMN ${column} failed: ${msg}`);
+        }
+        finally {
+            db.close();
+        }
+    };
+    const schemaPath = path.join(__dirname, '../src/schema.sql');
+    const sql = fs.readFileSync(schemaPath, 'utf-8');
+    const statements = sql
+        .split(';')
+        .map((s) => s
+        .split('\n')
+        .filter((line) => !line.trimStart().startsWith('--'))
+        .join('\n')
+        .trim())
+        .filter((s) => s.length > 0 &&
+        !/^CREATE\s+TABLE\s+["']?sqlite_sequence["']?\s*\(/i.test(s))
+        // Make CREATE INDEX idempotent
+        .map((s) => s
+        .replace(/^CREATE\s+UNIQUE\s+INDEX\b(?!\s+IF)/i, 'CREATE UNIQUE INDEX IF NOT EXISTS')
+        .replace(/^CREATE\s+INDEX\b(?!\s+IF)/i, 'CREATE INDEX IF NOT EXISTS'));
+    for (const statement of statements) {
+        await prisma.$executeRawUnsafe(statement);
+    }
+    // Migration: add variant column to model tables (for thinking/reasoning level).
+    alterTableAddColumn('channel_models', 'variant', 'TEXT');
+    alterTableAddColumn('session_models', 'variant', 'TEXT');
+    alterTableAddColumn('global_models', 'variant', 'TEXT');
+    // Migration: add openai_api_key column to bot_api_keys.
+    alterTableAddColumn('bot_api_keys', 'openai_api_key', 'TEXT');
+    // Migration: add gateway bot mode columns to bot_tokens.
+    alterTableAddColumn('bot_tokens', 'bot_mode', "TEXT DEFAULT 'self_hosted'");
+    alterTableAddColumn('bot_tokens', 'thread_deletion_sync_mode', 'TEXT');
+    alterTableAddColumn('bot_tokens', 'client_id', 'TEXT');
+    alterTableAddColumn('bot_tokens', 'client_secret', 'TEXT');
+    alterTableAddColumn('bot_tokens', 'proxy_url', 'TEXT');
+    alterTableAddColumn('bot_tokens', 'last_used_at', 'DATETIME');
+    alterTableAddColumn('thread_sessions', 'source', "TEXT DEFAULT 'otto'");
+    // Migration: move session_thinking data into session_models.variant.
+    // session_thinking table is left in place (not dropped) so older otto versions
+    // that still reference it won't crash on the same database.
+    try {
+        // For sessions that already have a model row, copy the thinking value
+        await prisma.$executeRawUnsafe(`
+      UPDATE session_models SET variant = (
+        SELECT thinking_value FROM session_thinking
+        WHERE session_thinking.session_id = session_models.session_id
+      ) WHERE variant IS NULL AND EXISTS (
+        SELECT 1 FROM session_thinking WHERE session_thinking.session_id = session_models.session_id
+      )
+    `);
+    }
+    catch {
+        // session_thinking table may not exist in fresh installs
+    }
+    // Migration: rename hyphenated verbosity values to underscored for Prisma enum.
+    // Old DBs have 'tools-and-text', 'text-and-essential-tools', 'text-only'.
+    const verbosityRenames = [
+        "UPDATE channel_verbosity SET verbosity = 'tools_and_text' WHERE verbosity = 'tools-and-text'",
+        "UPDATE channel_verbosity SET verbosity = 'text_and_essential_tools' WHERE verbosity = 'text-and-essential-tools'",
+        "UPDATE channel_verbosity SET verbosity = 'text_only' WHERE verbosity = 'text-only'",
+    ];
+    for (const stmt of verbosityRenames) {
+        try {
+            await prisma.$executeRawUnsafe(stmt);
+        }
+        catch {
+            // Table may not exist on first run
+        }
+    }
+    // Defensive migration: rename legacy 'self-hosted' bot_mode to 'self_hosted'.
+    // Also fix NULL worktree status rows that predate the required enum.
+    const defensiveMigrations = [
+        "UPDATE bot_tokens SET bot_mode = 'self_hosted' WHERE bot_mode = 'self-hosted'",
+        "UPDATE bot_tokens SET proxy_url = REPLACE(proxy_url, 'discord-gateway.otto.xyz', 'discord-gateway.otto.dev') WHERE bot_mode = 'gateway' AND proxy_url LIKE '%discord-gateway.otto.xyz%'",
+        "UPDATE thread_worktrees SET status = 'pending' WHERE status IS NULL",
+    ];
+    for (const stmt of defensiveMigrations) {
+        try {
+            await prisma.$executeRawUnsafe(stmt);
+        }
+        catch {
+            // Table may not exist on first run
+        }
+    }
+    // Migration: ensure every bot row has service auth credentials.
+    // These credentials are used for local/internet control-plane auth.
+    try {
+        const botRows = await prisma.bot_tokens.findMany({
+            select: {
+                app_id: true,
+                client_id: true,
+                client_secret: true,
+            },
+        });
+        for (const botRow of botRows) {
+            if (botRow.client_id && botRow.client_secret) {
+                continue;
+            }
+            await prisma.bot_tokens.update({
+                where: { app_id: botRow.app_id },
+                data: {
+                    client_id: crypto.randomUUID(),
+                    client_secret: crypto.randomBytes(32).toString('hex'),
+                },
+            });
+        }
+    }
+    catch {
+        // Defensive migration only; ignore if table shape is not ready yet.
+    }
+}
+/**
+ * Close the Prisma connection.
+ */
+export async function closePrisma() {
+    if (prismaInstance) {
+        await prismaInstance.$disconnect();
+        prismaInstance = null;
+        initPromise = null;
+        dbLogger.log('Prisma connection closed');
+    }
+}

package/dist/db.test.js

@@ -0,0 +1,138 @@
+// Tests for Prisma client initialization and schema migration.
+// Auto-isolated via VITEST guards in config.ts (temp data dir) and db.ts (clears OTTO_DB_URL).
+import { afterAll, describe, expect, test } from 'vitest';
+import { getPrisma, closePrisma } from './db.js';
+import { appendSessionEventsSinceLastTimestamp, createPendingWorktree, getSessionEventSnapshot, } from './database.js';
+afterAll(async () => {
+    await closePrisma();
+});
+describe('getPrisma', () => {
+    test('creates sqlite file and migrates schema automatically', async () => {
+        const prisma = await getPrisma();
+        const session = await prisma.thread_sessions.create({
+            data: { thread_id: 'test-thread-123', session_id: 'test-session-456' },
+        });
+        expect(session.thread_id).toBe('test-thread-123');
+        expect(session.created_at).toBeInstanceOf(Date);
+        const found = await prisma.thread_sessions.findUnique({
+            where: { thread_id: session.thread_id },
+        });
+        expect(found?.session_id).toBe('test-session-456');
+        // Cleanup test data
+        await prisma.thread_sessions.delete({
+            where: { thread_id: 'test-thread-123' },
+        });
+    });
+    test('createPendingWorktree creates parent and child rows', async () => {
+        const prisma = await getPrisma();
+        const threadId = `test-worktree-${Date.now()}`;
+        await createPendingWorktree({
+            threadId,
+            worktreeName: 'regression-worktree',
+            projectDirectory: '/tmp/regression-project',
+        });
+        const session = await prisma.thread_sessions.findUnique({
+            where: { thread_id: threadId },
+        });
+        expect(session).toBeTruthy();
+        expect(session?.session_id).toBe('');
+        const worktree = await prisma.thread_worktrees.findUnique({
+            where: { thread_id: threadId },
+        });
+        expect(worktree).toBeTruthy();
+        expect(worktree?.worktree_name).toBe('regression-worktree');
+        expect(worktree?.project_directory).toBe('/tmp/regression-project');
+        expect(worktree?.status).toBe('pending');
+        await prisma.thread_worktrees.delete({ where: { thread_id: threadId } });
+        await prisma.thread_sessions.delete({ where: { thread_id: threadId } });
+    });
+    test('session event persistence uses (timestamp, event_index) ordering for deterministic same-ms replay', async () => {
+        const prisma = await getPrisma();
+        const threadId = 'test-session-events-thread';
+        const sessionId = 'test-session-events-session';
+        await prisma.session_events.deleteMany({ where: { session_id: sessionId } });
+        await prisma.thread_sessions.deleteMany({ where: { thread_id: threadId } });
+        await prisma.thread_sessions.create({
+            data: { thread_id: threadId, session_id: sessionId },
+        });
+        const baseTimestamp = 1700000000000n;
+        const inserted1 = await appendSessionEventsSinceLastTimestamp({
+            sessionId,
+            events: [
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 2,
+                    event_json: JSON.stringify({ id: 'e2' }),
+                },
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 0,
+                    event_json: JSON.stringify({ id: 'e0' }),
+                },
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 1,
+                    event_json: JSON.stringify({ id: 'e1' }),
+                },
+            ],
+        });
+        const inserted2 = await appendSessionEventsSinceLastTimestamp({
+            sessionId,
+            events: [
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 0,
+                    event_json: JSON.stringify({ id: 'e0' }),
+                },
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 1,
+                    event_json: JSON.stringify({ id: 'e1' }),
+                },
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 2,
+                    event_json: JSON.stringify({ id: 'e2' }),
+                },
+                {
+                    session_id: sessionId,
+                    thread_id: threadId,
+                    timestamp: baseTimestamp,
+                    event_index: 3,
+                    event_json: JSON.stringify({ id: 'e3' }),
+                },
+            ],
+        });
+        const rows = await getSessionEventSnapshot({ sessionId });
+        const orderedIds = rows.map((row) => {
+            const parsed = JSON.parse(row.event_json);
+            return parsed.id;
+        });
+        expect({ inserted1, inserted2, orderedIds }).toMatchInlineSnapshot(`
+      {
+        "inserted1": 3,
+        "inserted2": 1,
+        "orderedIds": [
+          "e0",
+          "e1",
+          "e2",
+          "e3",
+        ],
+      }
+    `);
+        await prisma.session_events.deleteMany({ where: { session_id: sessionId } });
+        await prisma.thread_sessions.deleteMany({ where: { thread_id: threadId } });
+    });
+});

package/dist/debounce-timeout.js

@@ -0,0 +1,28 @@
+// Reusable debounce helper for timeout-based callbacks.
+// Encapsulates the timer handle and exposes trigger/clear/isPending so callers
+// can batch clustered events without leaking timeout state into domain logic.
+export function createDebouncedTimeout({ delayMs, callback, }) {
+    let timeout = null;
+    function clear() {
+        if (!timeout) {
+            return;
+        }
+        clearTimeout(timeout);
+        timeout = null;
+    }
+    function trigger() {
+        clear();
+        timeout = setTimeout(() => {
+            timeout = null;
+            callback();
+        }, delayMs);
+    }
+    function isPending() {
+        return timeout !== null;
+    }
+    return {
+        trigger,
+        clear,
+        isPending,
+    };
+}

package/dist/debounced-process-flush.js

@@ -0,0 +1,77 @@
+// Debounced async callback with centralized shutdown flushing.
+// Used for persistence paths that should batch writes during runtime
+// while allowing the bot's single SIGTERM/SIGINT handler to flush all callbacks.
+const processFlushCallbacks = new Set();
+export async function flushDebouncedProcessCallbacks() {
+    const callbacks = [...processFlushCallbacks];
+    await Promise.allSettled(callbacks.map((callback) => {
+        return callback();
+    }));
+}
+export function createDebouncedProcessFlush({ waitMs, callback, onError, }) {
+    let timeout;
+    let inFlight;
+    let dirty = false;
+    async function run() {
+        if (!dirty) {
+            return;
+        }
+        if (inFlight) {
+            await inFlight;
+            if (!dirty) {
+                return;
+            }
+        }
+        dirty = false;
+        const current = Promise.resolve()
+            .then(() => {
+            return callback();
+        })
+            .catch((error) => {
+            if (onError) {
+                const wrappedError = error instanceof Error
+                    ? error
+                    : new Error('Debounced process flush failed', { cause: error });
+                onError(wrappedError);
+            }
+        });
+        inFlight = current;
+        await current;
+        if (inFlight === current) {
+            inFlight = undefined;
+        }
+        if (dirty) {
+            await run();
+        }
+    }
+    function trigger() {
+        dirty = true;
+        if (timeout) {
+            return;
+        }
+        timeout = setTimeout(() => {
+            timeout = undefined;
+            void run();
+        }, waitMs);
+    }
+    async function flush() {
+        if (timeout) {
+            clearTimeout(timeout);
+            timeout = undefined;
+        }
+        await run();
+    }
+    const processFlushCallback = async () => {
+        await flush();
+    };
+    processFlushCallbacks.add(processFlushCallback);
+    async function dispose() {
+        processFlushCallbacks.delete(processFlushCallback);
+        await flush();
+    }
+    return {
+        trigger,
+        flush,
+        dispose,
+    };
+}