chore: import upstream snapshot with attribution

tests/unit/db-versionManager.test.ts

@@ -0,0 +1,470 @@
+import { describe, it, beforeEach, afterEach, after } from "node:test";
+import assert from "node:assert/strict";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import Database from "better-sqlite3";
+
+const fileTmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "omni-dbvm-test-"));
+const moduleDataDir = fs.mkdtempSync(path.join(os.tmpdir(), "omni-dbvm-module-"));
+process.env.DATA_DIR = moduleDataDir;
+
+const coreDb = await import("../../src/lib/db/core.ts");
+const versionManagerDb = await import("../../src/lib/db/versionManager.ts");
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS version_manager (
+  id                INTEGER PRIMARY KEY AUTOINCREMENT,
+  tool              TEXT NOT NULL UNIQUE,
+  current_version   TEXT,
+  installed_version TEXT,
+  pinned_version    TEXT,
+  binary_path       TEXT,
+  status            TEXT NOT NULL DEFAULT 'not_installed',
+  pid               INTEGER,
+  port              INTEGER DEFAULT 8317,
+  api_key           TEXT,
+  management_key    TEXT,
+  auto_update       INTEGER NOT NULL DEFAULT 1,
+  auto_start        INTEGER NOT NULL DEFAULT 0,
+  last_health_check TEXT,
+  last_update_check TEXT,
+  health_status     TEXT DEFAULT 'unknown',
+  config_overrides  TEXT,
+  error_message     TEXT,
+  created_at        TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at        TEXT NOT NULL DEFAULT (datetime('now'))
+);
+`;
+
+let testDb;
+let testDbPath;
+
+beforeEach(() => {
+  testDbPath = path.join(fileTmpDir, `test-${Date.now()}.db`);
+  testDb = new Database(testDbPath);
+  testDb.exec(SCHEMA);
+});
+
+afterEach(() => {
+  testDb.close();
+  try {
+    fs.unlinkSync(testDbPath);
+  } catch {}
+});
+
+after(() => {
+  if (fs.existsSync(fileTmpDir)) fs.rmSync(fileTmpDir, { recursive: true, force: true });
+});
+
+async function resetModuleStorage() {
+  coreDb.resetDbInstance();
+  fs.rmSync(moduleDataDir, { recursive: true, force: true });
+  fs.mkdirSync(moduleDataDir, { recursive: true });
+}
+
+function upsertTool(db, data) {
+  db.prepare(
+    `
+    INSERT INTO version_manager (
+      tool, current_version, installed_version, pinned_version, binary_path,
+      status, pid, port, api_key, management_key, auto_update, auto_start,
+      health_status, config_overrides, error_message, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
+    ON CONFLICT(tool) DO UPDATE SET
+      current_version = excluded.current_version,
+      installed_version = excluded.installed_version,
+      pinned_version = excluded.pinned_version,
+      binary_path = excluded.binary_path,
+      status = excluded.status,
+      pid = excluded.pid,
+      port = excluded.port,
+      api_key = excluded.api_key,
+      management_key = excluded.management_key,
+      auto_update = excluded.auto_update,
+      auto_start = excluded.auto_start,
+      health_status = excluded.health_status,
+      config_overrides = excluded.config_overrides,
+      error_message = excluded.error_message,
+      updated_at = datetime('now')
+  `
+  ).run(
+    data.tool,
+    data.currentVersion ?? null,
+    data.installedVersion ?? null,
+    data.pinnedVersion ?? null,
+    data.binaryPath ?? null,
+    data.status ?? "not_installed",
+    data.pid ?? null,
+    data.port ?? 8317,
+    data.apiKey ?? null,
+    data.managementKey ?? null,
+    data.autoUpdate !== undefined ? (data.autoUpdate ? 1 : 0) : 1,
+    data.autoStart !== undefined ? (data.autoStart ? 1 : 0) : 0,
+    data.healthStatus ?? "unknown",
+    data.configOverrides !== undefined
+      ? data.configOverrides
+        ? JSON.stringify(data.configOverrides)
+        : null
+      : null,
+    data.errorMessage ?? null
+  );
+  return db.prepare("SELECT * FROM version_manager WHERE tool = ?").get(data.tool);
+}
+
+function parseConfigOverrides(value) {
+  if (!value || typeof value !== "string" || value.trim() === "") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return typeof parsed === "object" && parsed !== null ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function toTool(row) {
+  if (!row) return null;
+  return {
+    id: row.id,
+    tool: row.tool,
+    currentVersion: row.current_version,
+    installedVersion: row.installed_version,
+    pinnedVersion: row.pinned_version,
+    binaryPath: row.binary_path,
+    status: row.status,
+    pid: row.pid,
+    port: row.port,
+    apiKey: row.api_key,
+    managementKey: row.management_key,
+    autoUpdate: row.auto_update === 1,
+    autoStart: row.auto_start === 1,
+    lastHealthCheck: row.last_health_check,
+    lastUpdateCheck: row.last_update_check,
+    healthStatus: row.health_status,
+    configOverrides: parseConfigOverrides(row.config_overrides),
+    errorMessage: row.error_message,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+describe("db/versionManager (logic)", () => {
+  describe("upsertVersionManagerTool", () => {
+    it("should insert a new tool and read it back", () => {
+      const tool = toTool(
+        upsertTool(testDb, {
+          tool: "cliproxyapi",
+          installedVersion: "6.9.7",
+          binaryPath: "/tmp/bin/cliproxyapi",
+          status: "installed",
+        })
+      );
+      assert.equal(tool.tool, "cliproxyapi");
+      assert.equal(tool.installedVersion, "6.9.7");
+      assert.equal(tool.binaryPath, "/tmp/bin/cliproxyapi");
+      assert.equal(tool.status, "installed");
+      assert.equal(tool.port, 8317);
+      assert.equal(tool.autoUpdate, true);
+      assert.equal(tool.autoStart, false);
+      assert.equal(tool.healthStatus, "unknown");
+      assert.ok(tool.id > 0);
+    });
+
+    it("should update on conflict (upsert)", () => {
+      upsertTool(testDb, { tool: "test-tool", status: "installed" });
+      const tool = toTool(
+        upsertTool(testDb, { tool: "test-tool", installedVersion: "7.0.0", status: "running" })
+      );
+      assert.equal(tool.installedVersion, "7.0.0");
+      assert.equal(tool.status, "running");
+    });
+
+    it("should store boolean fields as 0/1", () => {
+      const tool = toTool(
+        upsertTool(testDb, { tool: "bool-test", autoUpdate: false, autoStart: true })
+      );
+      assert.equal(tool.autoUpdate, false);
+      assert.equal(tool.autoStart, true);
+    });
+
+    it("should store config overrides as JSON", () => {
+      const tool = toTool(upsertTool(testDb, { tool: "cfg", configOverrides: { port: 9999 } }));
+      assert.deepEqual(tool.configOverrides, { port: 9999 });
+    });
+
+    it("should handle null config overrides", () => {
+      const tool = toTool(upsertTool(testDb, { tool: "null-cfg" }));
+      assert.equal(tool.configOverrides, null);
+    });
+
+    it("should handle pid and error message", () => {
+      const tool = toTool(
+        upsertTool(testDb, { tool: "pid-test", pid: 12345, errorMessage: "err" })
+      );
+      assert.equal(tool.pid, 12345);
+      assert.equal(tool.errorMessage, "err");
+    });
+  });
+
+  describe("getVersionManagerTool", () => {
+    it("should return null for non-existent tool", () => {
+      assert.equal(
+        toTool(testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("ghost")),
+        null
+      );
+    });
+
+    it("should return tool by name", () => {
+      upsertTool(testDb, { tool: "findme", installedVersion: "1.0.0" });
+      const tool = toTool(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("findme")
+      );
+      assert.equal(tool.installedVersion, "1.0.0");
+    });
+  });
+
+  describe("getVersionManagerStatus", () => {
+    it("should return all tools", () => {
+      upsertTool(testDb, { tool: "a" });
+      upsertTool(testDb, { tool: "b" });
+      assert.equal(testDb.prepare("SELECT * FROM version_manager").all().length, 2);
+    });
+
+    it("should return empty when no tools", () => {
+      assert.equal(testDb.prepare("SELECT * FROM version_manager").all().length, 0);
+    });
+  });
+
+  describe("updateVersionManagerTool (partial)", () => {
+    it("should update pinnedVersion and autoUpdate", () => {
+      upsertTool(testDb, { tool: "upd", status: "installed" });
+      testDb
+        .prepare(
+          "UPDATE version_manager SET pinned_version = ?, auto_update = ?, updated_at = datetime('now') WHERE tool = ?"
+        )
+        .run("6.8.0", 0, "upd");
+      const tool = toTool(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("upd")
+      );
+      assert.equal(tool.pinnedVersion, "6.8.0");
+      assert.equal(tool.autoUpdate, false);
+      assert.equal(tool.status, "installed");
+    });
+
+    it("should set fields to null", () => {
+      upsertTool(testDb, { tool: "nulls", installedVersion: "1.0.0", pid: 42 });
+      testDb
+        .prepare("UPDATE version_manager SET installed_version = NULL, pid = NULL WHERE tool = ?")
+        .run("nulls");
+      const tool = toTool(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("nulls")
+      );
+      assert.equal(tool.installedVersion, null);
+      assert.equal(tool.pid, null);
+    });
+  });
+
+  describe("deleteVersionManagerTool", () => {
+    it("should delete existing tool", () => {
+      upsertTool(testDb, { tool: "del" });
+      assert.equal(
+        testDb.prepare("DELETE FROM version_manager WHERE tool = ?").run("del").changes,
+        1
+      );
+      assert.equal(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("del"),
+        undefined
+      );
+    });
+
+    it("should return 0 changes for non-existent", () => {
+      assert.equal(
+        testDb.prepare("DELETE FROM version_manager WHERE tool = ?").run("ghost").changes,
+        0
+      );
+    });
+  });
+
+  describe("updateToolHealth", () => {
+    it("should update health_status and last_health_check", () => {
+      upsertTool(testDb, { tool: "h" });
+      const r = testDb
+        .prepare(
+          "UPDATE version_manager SET health_status = ?, last_health_check = datetime('now') WHERE tool = ?"
+        )
+        .run("healthy", "h");
+      assert.equal(r.changes, 1);
+      const tool = toTool(testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("h"));
+      assert.equal(tool.healthStatus, "healthy");
+      assert.ok(tool.lastHealthCheck);
+    });
+
+    it("should return 0 changes for non-existent", () => {
+      assert.equal(
+        testDb
+          .prepare("UPDATE version_manager SET health_status = ? WHERE tool = ?")
+          .run("healthy", "ghost").changes,
+        0
+      );
+    });
+  });
+
+  describe("updateToolVersion", () => {
+    it("should update current_version", () => {
+      upsertTool(testDb, { tool: "v1" });
+      testDb
+        .prepare("UPDATE version_manager SET current_version = ? WHERE tool = ?")
+        .run("7.0.0", "v1");
+      assert.equal(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("v1").current_version,
+        "7.0.0"
+      );
+    });
+
+    it("should update installed_version", () => {
+      upsertTool(testDb, { tool: "v2" });
+      testDb
+        .prepare("UPDATE version_manager SET installed_version = ? WHERE tool = ?")
+        .run("7.0.0", "v2");
+      assert.equal(
+        testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("v2").installed_version,
+        "7.0.0"
+      );
+    });
+  });
+
+  describe("setToolStatus", () => {
+    it("should update status with pid", () => {
+      upsertTool(testDb, { tool: "s1" });
+      testDb
+        .prepare("UPDATE version_manager SET status = ?, pid = ?, error_message = ? WHERE tool = ?")
+        .run("running", 9999, "ok", "s1");
+      const row = testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("s1");
+      assert.equal(row.status, "running");
+      assert.equal(row.pid, 9999);
+      assert.equal(row.error_message, "ok");
+    });
+
+    it("should update status without pid", () => {
+      upsertTool(testDb, { tool: "s2" });
+      testDb
+        .prepare("UPDATE version_manager SET status = ?, error_message = ? WHERE tool = ?")
+        .run("error", "crashed", "s2");
+      const row = testDb.prepare("SELECT * FROM version_manager WHERE tool = ?").get("s2");
+      assert.equal(row.status, "error");
+    });
+
+    it("should return 0 for non-existent", () => {
+      assert.equal(
+        testDb
+          .prepare("UPDATE version_manager SET status = ? WHERE tool = ?")
+          .run("running", "ghost").changes,
+        0
+      );
+    });
+  });
+
+  describe("parseConfigOverrides", () => {
+    it("should parse valid JSON", () => {
+      assert.deepEqual(parseConfigOverrides('{"key":"val"}'), { key: "val" });
+    });
+
+    it("should return null for invalid JSON", () => {
+      assert.equal(parseConfigOverrides("not-json"), null);
+      assert.equal(parseConfigOverrides(""), null);
+      assert.equal(parseConfigOverrides(null), null);
+      assert.equal(parseConfigOverrides("123"), null);
+    });
+  });
+});
+
+describe("db/versionManager (module coverage)", () => {
+  beforeEach(async () => {
+    await resetModuleStorage();
+  });
+
+  after(async () => {
+    coreDb.resetDbInstance();
+    fs.rmSync(moduleDataDir, { recursive: true, force: true });
+  });
+
+  it("round-trips inserts, updates and status listings through the production module", async () => {
+    const inserted = await versionManagerDb.upsertVersionManagerTool({
+      tool: "cliproxyapi",
+      installedVersion: "6.9.7",
+      binaryPath: "/tmp/cliproxyapi",
+      status: "installed",
+      autoUpdate: false,
+      autoStart: true,
+      configOverrides: { port: 9999 },
+    });
+
+    assert.equal(inserted.tool, "cliproxyapi");
+    assert.equal(inserted.autoUpdate, false);
+    assert.equal(inserted.autoStart, true);
+    assert.deepEqual(inserted.configOverrides, { port: 9999 });
+
+    const updated = await versionManagerDb.updateVersionManagerTool("cliproxyapi", {
+      installedVersion: "7.0.0",
+      configOverrides: { port: 8317, host: "127.0.0.1" },
+      apiKey: null,
+      ignoredField: "noop",
+    });
+
+    assert.equal(updated.installedVersion, "7.0.0");
+    assert.deepEqual(updated.configOverrides, { port: 8317, host: "127.0.0.1" });
+
+    const status = await versionManagerDb.getVersionManagerStatus();
+    const cliproxy = status.find((row) => row.tool === "cliproxyapi");
+    assert.ok(cliproxy, "expected cliproxyapi entry in status listing");
+    assert.equal(cliproxy.tool, "cliproxyapi");
+  });
+
+  it("parses invalid config overrides defensively and returns null for missing updates", async () => {
+    const db = coreDb.getDbInstance();
+    db.prepare(
+      `
+      INSERT INTO version_manager
+      (tool, status, config_overrides, created_at, updated_at)
+      VALUES (?, ?, ?, datetime('now'), datetime('now'))
+    `
+    ).run("broken-tool", "installed", "{not-json");
+
+    const loaded = await versionManagerDb.getVersionManagerTool("broken-tool");
+
+    assert.equal(loaded.configOverrides, null);
+    assert.equal(
+      await versionManagerDb.updateVersionManagerTool("ghost", { status: "running" }),
+      null
+    );
+  });
+
+  it("updates health/version/status fields and deletes tools", async () => {
+    await versionManagerDb.upsertVersionManagerTool({
+      tool: "managed-tool",
+      status: "installed",
+    });
+
+    assert.equal(await versionManagerDb.updateToolHealth("managed-tool", "healthy"), true);
+    assert.equal(
+      await versionManagerDb.updateToolVersion("managed-tool", "current_version", "1.2.3"),
+      true
+    );
+    assert.equal(
+      await versionManagerDb.updateToolVersion("managed-tool", "installed_version", "1.2.0"),
+      true
+    );
+    assert.equal(await versionManagerDb.setToolStatus("managed-tool", "running", 4321, "ok"), true);
+    assert.equal(await versionManagerDb.setToolStatus("managed-tool", "error"), true);
+
+    const stored = await versionManagerDb.getVersionManagerTool("managed-tool");
+    assert.equal(stored.currentVersion, "1.2.3");
+    assert.equal(stored.installedVersion, "1.2.0");
+    assert.equal(stored.status, "error");
+
+    assert.equal(await versionManagerDb.updateToolHealth("ghost", "healthy"), false);
+    assert.equal(await versionManagerDb.setToolStatus("ghost", "running"), false);
+    assert.equal(await versionManagerDb.deleteVersionManagerTool("managed-tool"), true);
+    assert.equal(await versionManagerDb.deleteVersionManagerTool("managed-tool"), false);
+  });
+});