zubo 0.1.0

package/tests/compaction.test.ts

@@ -0,0 +1,44 @@
+import { describe, it, expect } from "bun:test";
+import { compactMessages } from "../src/agent/compaction";
+import type { LlmMessage } from "../src/llm/provider";
+
+function makeMessages(count: number, charsEach: number): LlmMessage[] {
+  return Array.from({ length: count }, (_, i) => ({
+    role: (i % 2 === 0 ? "user" : "assistant") as "user" | "assistant",
+    content: "x".repeat(charsEach),
+  }));
+}
+
+describe("compactMessages", () => {
+  it("returns messages unchanged when under limit", () => {
+    const msgs = makeMessages(4, 100);
+    const result = compactMessages(msgs, 150_000);
+    expect(result.length).toBe(4);
+  });
+
+  it("trims messages when over context window", () => {
+    // 50 messages x 10000 chars each = 500k chars ≈ 125k tokens
+    // With contextWindow of 1000 tokens, should compact heavily
+    const msgs = makeMessages(50, 10_000);
+    const result = compactMessages(msgs, 1_000);
+    expect(result.length).toBeLessThan(50);
+  });
+
+  it("ensures first message is from user after compaction", () => {
+    const msgs = makeMessages(50, 10_000);
+    const result = compactMessages(msgs, 1_000);
+    expect(result[0].role).toBe("user");
+  });
+
+  it("keeps at least 2 messages", () => {
+    const msgs = makeMessages(50, 10_000);
+    const result = compactMessages(msgs, 1_000);
+    expect(result.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it("uses default context window when none provided", () => {
+    const msgs = makeMessages(4, 100);
+    const result = compactMessages(msgs);
+    expect(result.length).toBe(4);
+  });
+});

package/tests/config.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from "bun:test";
+import { configSchema } from "../src/config/schema";
+
+describe("Config Schema", () => {
+  it("should validate minimal config", () => {
+    const result = configSchema.safeParse({
+      anthropicApiKey: "test-key",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("should provide defaults", () => {
+    const result = configSchema.parse({
+      anthropicApiKey: "test-key",
+    });
+    expect(result.maxTurns).toBe(50);
+    expect(result.heartbeatMinutes).toBe(30);
+    expect(result.telegramAllowedUsers).toEqual([]);
+  });
+
+  it("should validate multi-provider config", () => {
+    const result = configSchema.safeParse({
+      providers: {
+        anthropic: { model: "claude-sonnet-4-5-20250929", apiKey: "test" },
+        openai: { model: "gpt-4o", apiKey: "test", baseUrl: "https://api.openai.com/v1" },
+      },
+      activeProvider: "anthropic",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("should validate channel config", () => {
+    const result = configSchema.safeParse({
+      anthropicApiKey: "test",
+      channels: {
+        telegram: { botToken: "123:abc", allowedUsers: [12345] },
+        discord: { botToken: "discord-token" },
+        webchat: { port: 3000 },
+      },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("should reject invalid heartbeat values", () => {
+    const result = configSchema.safeParse({
+      anthropicApiKey: "test",
+      heartbeatMinutes: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+});

package/tests/costs.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "bun:test";
+import { estimateCost } from "../src/util/costs";
+
+describe("Cost Estimation", () => {
+  it("should estimate cost for known models", () => {
+    const cost = estimateCost("gpt-4o", 1000, 500);
+    expect(cost).toBeGreaterThan(0);
+  });
+
+  it("should return 0 for unknown/local models", () => {
+    const cost = estimateCost("llama3:latest", 1000, 500);
+    expect(cost).toBe(0);
+  });
+
+  it("should handle zero tokens", () => {
+    const cost = estimateCost("gpt-4o", 0, 0);
+    expect(cost).toBe(0);
+  });
+});

package/tests/cron.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from "bun:test";
+import { createTestDb } from "./helpers/test-db";
+
+describe("Cron Jobs", () => {
+  it("should create cron_jobs table", () => {
+    const db = createTestDb();
+    const result = db.query("SELECT name FROM sqlite_master WHERE type='table' AND name='cron_jobs'").get() as any;
+    expect(result).toBeTruthy();
+    db.close();
+  });
+
+  it("should add a cron job", () => {
+    const db = createTestDb();
+    db.prepare("INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, ?)").run("test_job", "0 9 * * 1-5", "Send morning report", 1);
+
+    const jobs = db.query("SELECT * FROM cron_jobs").all() as any[];
+    expect(jobs.length).toBe(1);
+    expect(jobs[0].name).toBe("test_job");
+    expect(jobs[0].schedule).toBe("0 9 * * 1-5");
+    db.close();
+  });
+
+  it("should remove a cron job", () => {
+    const db = createTestDb();
+    db.prepare("INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, ?)").run("to_remove", "* * * * *", "test", 1);
+    db.prepare("DELETE FROM cron_jobs WHERE name = ?").run("to_remove");
+
+    const jobs = db.query("SELECT * FROM cron_jobs").all() as any[];
+    expect(jobs.length).toBe(0);
+    db.close();
+  });
+
+  it("should list cron jobs", () => {
+    const db = createTestDb();
+    db.prepare("INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, ?)").run("job1", "0 9 * * *", "task1", 1);
+    db.prepare("INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, ?)").run("job2", "0 17 * * *", "task2", 1);
+
+    const jobs = db.query("SELECT * FROM cron_jobs ORDER BY name").all() as any[];
+    expect(jobs.length).toBe(2);
+    expect(jobs[0].name).toBe("job1");
+    expect(jobs[1].name).toBe("job2");
+    db.close();
+  });
+
+  it("should enforce max jobs limit at DB level", () => {
+    const db = createTestDb();
+    // Insert many jobs -- there's no hard DB limit, but we can test we can add many
+    for (let i = 0; i < 50; i++) {
+      db.prepare("INSERT INTO cron_jobs (name, schedule, task, enabled) VALUES (?, ?, ?, ?)").run(`job_${i}`, "* * * * *", `task_${i}`, 1);
+    }
+    const count = (db.query("SELECT COUNT(*) as c FROM cron_jobs").get() as any)?.c;
+    expect(count).toBe(50);
+    db.close();
+  });
+});

package/tests/db/export.test.ts

@@ -0,0 +1,219 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { exportDatabase, importDatabase } from "../../src/db/export";
+
+function createTestDb(): Database {
+  const db = new Database(":memory:");
+
+  // Create the tables that EXPORT_TABLES references
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      channel TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS memory_chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      source_file TEXT NOT NULL,
+      chunk_index INTEGER NOT NULL,
+      content TEXT NOT NULL,
+      embedding BLOB,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(source_file, chunk_index)
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS cron_jobs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      schedule TEXT NOT NULL,
+      task TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_run TEXT,
+      next_run TEXT,
+      retry_count INTEGER NOT NULL DEFAULT 0,
+      max_retries INTEGER NOT NULL DEFAULT 3,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS cron_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      job_id INTEGER NOT NULL REFERENCES cron_jobs(id),
+      status TEXT NOT NULL,
+      output TEXT,
+      error TEXT,
+      started_at TEXT NOT NULL DEFAULT (datetime('now')),
+      finished_at TEXT
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS usage (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      session_id TEXT,
+      provider TEXT NOT NULL,
+      model TEXT NOT NULL,
+      input_tokens INTEGER NOT NULL DEFAULT 0,
+      output_tokens INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS uploads (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      filename TEXT NOT NULL,
+      original_name TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      chunk_count INTEGER NOT NULL DEFAULT 0,
+      uploaded_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tool_metrics (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tool_name TEXT NOT NULL,
+      session_id TEXT,
+      duration_ms INTEGER NOT NULL,
+      success INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS perf_snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      rss_mb REAL,
+      heap_mb REAL,
+      db_size_mb REAL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+
+  return db;
+}
+
+describe("importDatabase", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "orba-export-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("rejects unknown table names by skipping them", () => {
+    const db = createTestDb();
+    const importFile = join(tempDir, "import.json");
+
+    const data = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      tables: {
+        evil_table: [{ id: 1, payload: "malicious" }],
+      },
+    };
+    writeFileSync(importFile, JSON.stringify(data));
+
+    const result = importDatabase(db, importFile);
+    // The unknown table should be skipped entirely (not in EXPORT_TABLES)
+    expect(result.imported).toBe(0);
+  });
+
+  test("handles empty data gracefully", () => {
+    const db = createTestDb();
+    const importFile = join(tempDir, "empty.json");
+
+    const data = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      tables: {},
+    };
+    writeFileSync(importFile, JSON.stringify(data));
+
+    const result = importDatabase(db, importFile);
+    expect(result.imported).toBe(0);
+    expect(result.skipped).toBe(0);
+  });
+
+  test("rejects unsupported export version", () => {
+    const db = createTestDb();
+    const importFile = join(tempDir, "bad-version.json");
+
+    const data = {
+      version: 99,
+      exportedAt: new Date().toISOString(),
+      tables: {},
+    };
+    writeFileSync(importFile, JSON.stringify(data));
+
+    expect(() => importDatabase(db, importFile)).toThrow("Unsupported export version");
+  });
+});
+
+describe("export/import round-trip", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "orba-roundtrip-test-"));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("preserves data through export and import", () => {
+    const sourceDb = createTestDb();
+
+    // Insert test data into sessions
+    sourceDb
+      .prepare("INSERT INTO sessions (id, channel, user_id) VALUES (?, ?, ?)")
+      .run("sess-1", "discord", "user-42");
+    sourceDb
+      .prepare("INSERT INTO sessions (id, channel, user_id) VALUES (?, ?, ?)")
+      .run("sess-2", "telegram", "user-99");
+
+    // Insert test data into memory_chunks
+    sourceDb
+      .prepare(
+        "INSERT INTO memory_chunks (source_file, chunk_index, content) VALUES (?, ?, ?)"
+      )
+      .run("notes.md", 0, "Remember this fact");
+
+    // Export
+    const exportPath = join(tempDir, "export.json");
+    exportDatabase(sourceDb, exportPath);
+
+    // Verify the export file was created
+    const exportContent = JSON.parse(readFileSync(exportPath, "utf-8"));
+    expect(exportContent.version).toBe(1);
+    expect(exportContent.tables.sessions).toHaveLength(2);
+    expect(exportContent.tables.memory_chunks).toHaveLength(1);
+
+    // Import into a fresh database
+    const targetDb = createTestDb();
+    const result = importDatabase(targetDb, exportPath);
+
+    expect(result.imported).toBe(3); // 2 sessions + 1 memory chunk
+
+    // Verify the data
+    const sessions = targetDb.query("SELECT * FROM sessions ORDER BY id").all() as any[];
+    expect(sessions).toHaveLength(2);
+    expect(sessions[0].id).toBe("sess-1");
+    expect(sessions[0].channel).toBe("discord");
+    expect(sessions[1].id).toBe("sess-2");
+    expect(sessions[1].channel).toBe("telegram");
+
+    const chunks = targetDb.query("SELECT * FROM memory_chunks").all() as any[];
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0].content).toBe("Remember this fact");
+  });
+});

package/tests/executor.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { registerTool, unregisterTool } from "../src/tools/registry";
+import { executeTool } from "../src/tools/executor";
+
+describe("Tool Executor", () => {
+  beforeEach(() => {
+    // Register a test tool
+    registerTool({
+      definition: {
+        name: "test_tool",
+        description: "A test tool",
+        input_schema: { type: "object", properties: { msg: { type: "string" } } },
+      },
+      async execute(input) {
+        return `echo: ${input.msg}`;
+      },
+    });
+  });
+
+  afterEach(() => {
+    unregisterTool("test_tool");
+    unregisterTool("error_tool");
+  });
+
+  it("should execute a registered tool", async () => {
+    const result = await executeTool("test_tool", "t1", { msg: "hello" });
+    expect(result.content).toBe("echo: hello");
+    expect(result.is_error).toBe(false);
+    expect(result.tool_use_id).toBe("t1");
+  });
+
+  it("should return error for unknown tool", async () => {
+    const result = await executeTool("nonexistent_tool", "t2", {});
+    expect(result.is_error).toBe(true);
+    expect(result.content).toContain("Unknown tool");
+  });
+
+  it("should block tools not in allowedTools", async () => {
+    const result = await executeTool("test_tool", "t3", { msg: "hi" }, ["other_tool"]);
+    expect(result.is_error).toBe(true);
+    expect(result.content).toContain("not available");
+  });
+
+  it("should handle tool execution errors", async () => {
+    registerTool({
+      definition: {
+        name: "error_tool",
+        description: "Always fails",
+        input_schema: { type: "object" },
+      },
+      async execute() {
+        throw new Error("intentional failure");
+      },
+    });
+
+    const result = await executeTool("error_tool", "t4", {});
+    expect(result.is_error).toBe(true);
+    expect(result.content).toContain("intentional failure");
+  });
+
+  it("should require confirmation for confirm-permission tools", async () => {
+    // Register the shell tool so executeTool can find it
+    registerTool({
+      definition: {
+        name: "shell",
+        description: "Run shell commands",
+        input_schema: { type: "object", properties: { command: { type: "string" } } },
+      },
+      async execute(input) {
+        return `ran: ${input.command}`;
+      },
+    });
+
+    const result = await executeTool("shell", "t5", { command: "ls" });
+    // shell has "confirm" permission, so it should request confirmation
+    expect(result.content).toContain("CONFIRMATION REQUIRED");
+    expect(result.content).toContain("Confirmation Token:");
+
+    unregisterTool("shell");
+  });
+
+  it("should accept valid confirmation token", async () => {
+    registerTool({
+      definition: {
+        name: "shell",
+        description: "Run shell commands",
+        input_schema: { type: "object", properties: { command: { type: "string" } } },
+      },
+      async execute(input) {
+        return `ran: ${input.command}`;
+      },
+    });
+
+    // First call gets the token
+    const first = await executeTool("shell", "t6", { command: "ls" });
+    expect(first.content).toContain("Confirmation Token:");
+    const tokenMatch = first.content.match(/Confirmation Token: ([a-f0-9-]+)/);
+    expect(tokenMatch).toBeTruthy();
+
+    // Second call with valid token should execute
+    const second = await executeTool("shell", "t7", { command: "ls", _confirmToken: tokenMatch![1] });
+    expect(second.is_error).toBe(false);
+    expect(second.content).toBe("ran: ls");
+
+    unregisterTool("shell");
+  });
+
+  it("should reject spoofed _confirmed without token", async () => {
+    registerTool({
+      definition: {
+        name: "shell",
+        description: "Run shell commands",
+        input_schema: { type: "object", properties: { command: { type: "string" } } },
+      },
+      async execute(input) {
+        return `ran: ${input.command}`;
+      },
+    });
+
+    // Try to bypass with _confirmed: true — should still require token
+    const result = await executeTool("shell", "t8", { command: "rm -rf /", _confirmed: true });
+    expect(result.content).toContain("CONFIRMATION REQUIRED");
+
+    unregisterTool("shell");
+  });
+
+  it("should reject invalid confirmation token", async () => {
+    registerTool({
+      definition: {
+        name: "shell",
+        description: "Run shell commands",
+        input_schema: { type: "object", properties: { command: { type: "string" } } },
+      },
+      async execute(input) {
+        return `ran: ${input.command}`;
+      },
+    });
+
+    const result = await executeTool("shell", "t9", { command: "ls", _confirmToken: "fake-token-12345" });
+    expect(result.content).toContain("Invalid or expired confirmation token");
+
+    unregisterTool("shell");
+  });
+});

package/tests/export.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { Database } from "bun:sqlite";
+import { existsSync, readFileSync, unlinkSync, mkdirSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { exportDatabase, importDatabase, getDbStats, backupDatabase } from "../src/db/export";
+
+function createExportTestDb(): Database {
+  const db = new Database(":memory:");
+
+  // Create tables that export uses
+  db.run(`CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, channel TEXT, user_id TEXT, created_at TEXT, updated_at TEXT)`);
+  db.run(`CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY, session_id TEXT, role TEXT, content TEXT, created_at TEXT)`);
+  db.run(`CREATE TABLE IF NOT EXISTS memory_chunks (id INTEGER PRIMARY KEY, source_file TEXT, chunk_index INTEGER, content TEXT)`);
+  db.run(`CREATE TABLE IF NOT EXISTS cron_jobs (id INTEGER PRIMARY KEY, name TEXT, schedule TEXT, task TEXT, enabled INTEGER DEFAULT 1, last_run TEXT, next_run TEXT)`);
+  db.run(`CREATE TABLE IF NOT EXISTS usage (id INTEGER PRIMARY KEY, session_id TEXT, provider TEXT, model TEXT, input_tokens INTEGER, output_tokens INTEGER, created_at TEXT)`);
+  db.run(`CREATE TABLE IF NOT EXISTS uploads (id INTEGER PRIMARY KEY, filename TEXT, original_name TEXT, mime_type TEXT, size_bytes INTEGER, chunk_count INTEGER)`);
+
+  return db;
+}
+
+describe("Database Export", () => {
+  let db: Database;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    db = createExportTestDb();
+    tmpDir = join(tmpdir(), `zubo-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  it("should export database as valid JSON", () => {
+    // Insert test data
+    db.run("INSERT INTO sessions (id, channel, user_id, created_at, updated_at) VALUES ('s1', 'webchat', 'user1', '2024-01-01', '2024-01-01')");
+    db.run("INSERT INTO messages (session_id, role, content, created_at) VALUES ('s1', 'user', 'Hello', '2024-01-01')");
+    db.run("INSERT INTO memory_chunks (source_file, chunk_index, content) VALUES ('test.md', 0, 'Test memory')");
+
+    const outputPath = join(tmpDir, "export.json");
+    exportDatabase(db, outputPath);
+
+    expect(existsSync(outputPath)).toBe(true);
+
+    const data = JSON.parse(readFileSync(outputPath, "utf-8"));
+    expect(data.version).toBe(1);
+    expect(data.exportedAt).toBeTruthy();
+    expect(data.tables.sessions).toHaveLength(1);
+    expect(data.tables.messages).toHaveLength(1);
+    expect(data.tables.memory_chunks).toHaveLength(1);
+
+    try { unlinkSync(outputPath); } catch {}
+  });
+
+  it("should import data from JSON", () => {
+    const exportData = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      tables: {
+        sessions: [{ id: "s1", channel: "webchat", user_id: "user1", created_at: "2024-01-01", updated_at: "2024-01-01" }],
+        messages: [{ id: 1, session_id: "s1", role: "user", content: "Hello", created_at: "2024-01-01" }],
+      },
+    };
+
+    const inputPath = join(tmpDir, "import.json");
+    const { writeFileSync } = require("fs");
+    writeFileSync(inputPath, JSON.stringify(exportData));
+
+    const result = importDatabase(db, inputPath);
+    expect(result.imported).toBeGreaterThan(0);
+
+    // Verify data was imported
+    const sessions = db.query("SELECT * FROM sessions").all();
+    expect(sessions).toHaveLength(1);
+
+    const messages = db.query("SELECT * FROM messages").all();
+    expect(messages).toHaveLength(1);
+
+    try { unlinkSync(inputPath); } catch {}
+  });
+
+  it("should skip duplicate rows on import", () => {
+    // Insert existing data
+    db.run("INSERT INTO sessions (id, channel, user_id, created_at, updated_at) VALUES ('s1', 'webchat', 'user1', '2024-01-01', '2024-01-01')");
+
+    const exportData = {
+      version: 1,
+      exportedAt: new Date().toISOString(),
+      tables: {
+        sessions: [{ id: "s1", channel: "webchat", user_id: "user1", created_at: "2024-01-01", updated_at: "2024-01-01" }],
+      },
+    };
+
+    const inputPath = join(tmpDir, "import-dup.json");
+    const { writeFileSync } = require("fs");
+    writeFileSync(inputPath, JSON.stringify(exportData));
+
+    const result = importDatabase(db, inputPath);
+    // Should have been handled (either imported or skipped, no error)
+    expect(result.imported + result.skipped).toBeGreaterThanOrEqual(1);
+
+    // Should still have exactly one session
+    const sessions = db.query("SELECT * FROM sessions").all();
+    expect(sessions).toHaveLength(1);
+
+    try { unlinkSync(inputPath); } catch {}
+  });
+
+  it("should get database stats", () => {
+    db.run("INSERT INTO sessions (id, channel, user_id, created_at, updated_at) VALUES ('s1', 'webchat', 'user1', '2024-01-01', '2024-01-01')");
+    db.run("INSERT INTO messages (session_id, role, content, created_at) VALUES ('s1', 'user', 'Hello', '2024-01-01')");
+    db.run("INSERT INTO messages (session_id, role, content, created_at) VALUES ('s1', 'assistant', 'Hi', '2024-01-01')");
+
+    const stats = getDbStats(db);
+    expect(stats.tables.sessions).toBe(1);
+    expect(stats.tables.messages).toBe(2);
+  });
+
+  it("should create SQLite backup file", () => {
+    // Create a real on-disk DB for backup test
+    const dbPath = join(tmpDir, "test.db");
+    const diskDb = new Database(dbPath, { create: true });
+    diskDb.run("CREATE TABLE test (id INTEGER PRIMARY KEY, value TEXT)");
+    diskDb.run("INSERT INTO test VALUES (1, 'hello')");
+    diskDb.close();
+
+    const backupPath = backupDatabase(dbPath, tmpDir);
+    expect(existsSync(backupPath)).toBe(true);
+
+    // Verify backup is a valid SQLite database
+    const backupDb = new Database(backupPath, { readonly: true });
+    const rows = backupDb.query("SELECT * FROM test").all() as any[];
+    expect(rows).toHaveLength(1);
+    expect(rows[0].value).toBe("hello");
+    backupDb.close();
+
+    try { unlinkSync(dbPath); unlinkSync(backupPath); } catch {}
+  });
+});