@indigoai-us/hq-cli 5.77.14 → 5.79.0

package/src/lib/db/control-plane.ts

@@ -1,113 +0,0 @@
-/**
- * Control-plane client for remote vault DB (US-009).
- * Injectable fetch for tests — never logs response bodies that might hold secrets.
- */
-
-export interface RemoteProvisionResponse {
-  ok: boolean;
-  companyUid: string;
-  companySlug: string;
-  engineId: string;
-  resourceArn: string;
-  region: string;
-  status: string;
-  secretRef: string;
-  idempotent: boolean;
-}
-
-export interface RemoteStatusResponse {
-  companyUid: string;
-  companySlug?: string;
-  remote: {
-    engineId: string;
-    resourceArn: string;
-    region: string;
-    status: string;
-    secretRef: string;
-  } | null;
-}
-
-export interface ControlPlaneClientOptions {
-  baseUrl: string;
-  /** Bearer access token */
-  getAccessToken: () => Promise<string>;
-  fetchImpl?: typeof fetch;
-}
-
-function assertNoPostgresUrl(label: string, text: string): void {
-  if (/postgres:\/\//i.test(text) || /postgresql:\/\//i.test(text)) {
-    throw new Error(
-      `${label}: control plane returned a connection string (refusing to surface)`,
-    );
-  }
-}
-
-export class ControlPlaneDbClient {
-  private readonly baseUrl: string;
-  private readonly getAccessToken: () => Promise<string>;
-  private readonly fetchImpl: typeof fetch;
-
-  constructor(opts: ControlPlaneClientOptions) {
-    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
-    this.getAccessToken = opts.getAccessToken;
-    this.fetchImpl = opts.fetchImpl ?? fetch;
-  }
-
-  async provision(input: {
-    companyUid: string;
-    companySlug: string;
-    region?: string;
-  }): Promise<RemoteProvisionResponse> {
-    const token = await this.getAccessToken();
-    const res = await this.fetchImpl(`${this.baseUrl}/v1/db/provision`, {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(input),
-    });
-    const text = await res.text();
-    assertNoPostgresUrl("provision", text);
-    if (!res.ok) {
-      let msg = `provision failed (${res.status})`;
-      let code: string | undefined;
-      try {
-        const j = JSON.parse(text) as { error?: string; code?: string };
-        if (j.error) msg = j.error;
-        if (j.code) code = j.code;
-      } catch {
-        /* keep */
-      }
-      const err = new Error(msg) as Error & { status?: number; code?: string };
-      err.status = res.status;
-      if (code) err.code = code;
-      throw err;
-    }
-    return JSON.parse(text) as RemoteProvisionResponse;
-  }
-
-  async status(companyUid: string): Promise<RemoteStatusResponse> {
-    const token = await this.getAccessToken();
-    const url = `${this.baseUrl}/v1/db/status?companyUid=${encodeURIComponent(companyUid)}`;
-    const res = await this.fetchImpl(url, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${token}` },
-    });
-    const text = await res.text();
-    assertNoPostgresUrl("status", text);
-    if (!res.ok) {
-      let msg = `status failed (${res.status})`;
-      try {
-        const j = JSON.parse(text) as { error?: string };
-        if (j.error) msg = j.error;
-      } catch {
-        /* keep */
-      }
-      const err = new Error(msg) as Error & { status?: number };
-      err.status = res.status;
-      throw err;
-    }
-    return JSON.parse(text) as RemoteStatusResponse;
-  }
-}

package/src/lib/db/local.test.ts

@@ -1,81 +0,0 @@
-/**
- * Local vault SQLite open/status tests (vault-databases US-003).
- */
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import {
-  ensureAndStatusLocalDb,
-  openLocalDb,
-  readMigrationHead,
-} from "./local.js";
-import { resolveLocalDbPath } from "./paths.js";
-
-const tempHomes: string[] = [];
-
-function makeTempHome(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "hq-db-local-"));
-  tempHomes.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  while (tempHomes.length > 0) {
-    const dir = tempHomes.pop();
-    if (dir) fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("openLocalDb / ensureAndStatusLocalDb", () => {
-  it("creates SQLite at canonical path with WAL on first open", () => {
-    const home = makeTempHome();
-    const status = ensureAndStatusLocalDb("fixture-co", { home });
-    const dbPath = resolveLocalDbPath("fixture-co", { home });
-
-    expect(status.healthy).toBe(true);
-    expect(status.tier).toBe("local");
-    expect(status.company).toBe("fixture-co");
-    expect(status.path).toBe(dbPath);
-    expect(status.journalMode?.toLowerCase()).toBe("wal");
-    expect(fs.existsSync(dbPath)).toBe(true);
-    expect(status.schemaVersion).toBeNull();
-    // Never a remote URL
-    expect(JSON.stringify(status)).not.toMatch(/postgres:\/\//i);
-  });
-
-  it("second open is idempotent (file survives, no wipe)", () => {
-    const home = makeTempHome();
-    const dbPath = resolveLocalDbPath("idem", { home });
-
-    const db1 = openLocalDb("idem", { home });
-    db1.exec("CREATE TABLE smoke (id INTEGER PRIMARY KEY, v TEXT)");
-    db1.prepare("INSERT INTO smoke (v) VALUES (?)").run("keep-me");
-    db1.close();
-
-    const stat1 = fs.statSync(dbPath);
-    const status2 = ensureAndStatusLocalDb("idem", { home });
-    expect(status2.healthy).toBe(true);
-
-    const db2 = openLocalDb("idem", { home });
-    const row = db2.prepare("SELECT v FROM smoke WHERE id = 1").get() as {
-      v: string;
-    };
-    expect(row.v).toBe("keep-me");
-    db2.close();
-
-    const stat2 = fs.statSync(dbPath);
-    // Size should not collapse (recreate would lose data / shrink oddly)
-    expect(stat2.size).toBeGreaterThanOrEqual(stat1.size);
-  });
-
-  it("readMigrationHead returns null without ledger table", () => {
-    const home = makeTempHome();
-    const db = openLocalDb("noleger", { home });
-    expect(readMigrationHead(db)).toBeNull();
-    db.close();
-  });
-});

package/src/lib/db/local.ts

@@ -1,148 +0,0 @@
-/**
- * Local vault SQLite open/create (C1).
- *
- * File lives at ~/.hq/db/{company}/vault.db with WAL journal mode.
- * Never returns or logs remote connection strings.
- */
-
-import fs from "node:fs";
-
-import Database from "better-sqlite3";
-
-import {
-  ensureLocalDbDir,
-  resolveLocalDbPath,
-  type LocalDbPathEnv,
-} from "./paths.js";
-
-export type LocalDb = Database.Database;
-
-export interface OpenLocalDbOptions extends LocalDbPathEnv {
-  /** When true, do not create the file if missing (throws). Default false. */
-  readonly?: boolean;
-}
-
-export interface LocalDbStatus {
-  company: string;
-  tier: "local";
-  path: string;
-  exists: boolean;
-  healthy: boolean;
-  journalMode: string | null;
-  /** Migration ledger head when present; null if ledger not initialized. */
-  schemaVersion: string | null;
-  /** Fingerprint of path for logs that prefer not to echo full home paths. */
-  pathFingerprint: string;
-}
-
-const MIGRATIONS_TABLE = "hq_schema_migrations";
-
-/**
- * Short non-reversible fingerprint of a path (for status display).
- * Not a secret — just avoids dumping full home paths when preferred.
- */
-export function fingerprintPath(filePath: string): string {
-  let h = 2166136261;
-  for (let i = 0; i < filePath.length; i++) {
-    h ^= filePath.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return `fp_${(h >>> 0).toString(16).padStart(8, "0")}`;
-}
-
-/**
- * Open (and create if missing) the company local vault DB with WAL mode.
- * Idempotent: reopening an existing file does not recreate or wipe it.
- */
-export function openLocalDb(
-  companySlug: string,
-  opts?: OpenLocalDbOptions,
-): LocalDb {
-  const dbPath = resolveLocalDbPath(companySlug, opts);
-  const exists = fs.existsSync(dbPath);
-
-  if (!exists) {
-    if (opts?.readonly) {
-      throw new Error(
-        `local vault DB not found for company ${JSON.stringify(companySlug)} at ${dbPath}`,
-      );
-    }
-    ensureLocalDbDir(companySlug, opts);
-  }
-
-  const db = new Database(dbPath);
-  // WAL for concurrent readers; safe for agent/CLI workloads.
-  db.pragma("journal_mode = WAL");
-  db.pragma("foreign_keys = ON");
-  return db;
-}
-
-/**
- * Read migration head from platform ledger if the table exists.
- */
-export function readMigrationHead(db: LocalDb): string | null {
-  try {
-    const row = db
-      .prepare(
-        `SELECT name FROM sqlite_master WHERE type='table' AND name=?`,
-      )
-      .get(MIGRATIONS_TABLE) as { name?: string } | undefined;
-    if (!row?.name) return null;
-
-    const head = db
-      .prepare(
-        `SELECT version FROM ${MIGRATIONS_TABLE} ORDER BY version DESC LIMIT 1`,
-      )
-      .get() as { version?: string } | undefined;
-    return head?.version ?? null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Ensure local DB exists (create if needed), report status, close handle.
- * Safe for CLI status: never includes connection strings.
- */
-export function ensureAndStatusLocalDb(
-  companySlug: string,
-  opts?: LocalDbPathEnv,
-): LocalDbStatus {
-  const dbPath = resolveLocalDbPath(companySlug, opts);
-  const db = openLocalDb(companySlug, opts);
-  try {
-    const journalMode = String(db.pragma("journal_mode", { simple: true }));
-    const schemaVersion = readMigrationHead(db);
-    // Touch a trivial query to prove the handle is healthy.
-    db.prepare("SELECT 1 AS ok").get();
-
-    return {
-      company: companySlug.trim().toLowerCase(),
-      tier: "local",
-      path: dbPath,
-      exists: true,
-      healthy: true,
-      journalMode,
-      schemaVersion,
-      pathFingerprint: fingerprintPath(dbPath),
-    };
-  } finally {
-    db.close();
-  }
-}
-
-/**
- * Format status for CLI stdout (no secrets).
- */
-export function formatLocalDbStatus(status: LocalDbStatus): string {
-  const lines = [
-    `company: ${status.company}`,
-    `tier: ${status.tier}`,
-    `healthy: ${status.healthy ? "yes" : "no"}`,
-    `path: ${status.path}`,
-    `pathFingerprint: ${status.pathFingerprint}`,
-    `journalMode: ${status.journalMode ?? "unknown"}`,
-    `schemaVersion: ${status.schemaVersion ?? "(none)"}`,
-  ];
-  return lines.join("\n");
-}

package/src/lib/db/migrate.test.ts

@@ -1,133 +0,0 @@
-/**
- * Migration apply/idempotent/failure tests (vault-databases US-005).
- */
-
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import { afterEach, describe, expect, it } from "vitest";
-
-import { openLocalDb } from "./local.js";
-import { migrateLocalDb, resolveMigrationsDir } from "./migrate.js";
-
-const tempRoots: string[] = [];
-
-function makeFixture(): { home: string; hqRoot: string } {
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "hq-db-migrate-"));
-  tempRoots.push(root);
-  const home = path.join(root, "home");
-  const hqRoot = path.join(root, "hq");
-  fs.mkdirSync(home, { recursive: true });
-  fs.mkdirSync(hqRoot, { recursive: true });
-  return { home, hqRoot };
-}
-
-function writeMigration(
-  hqRoot: string,
-  company: string,
-  name: string,
-  sql: string,
-): void {
-  const dir = resolveMigrationsDir(hqRoot, company);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, name), sql, "utf8");
-}
-
-afterEach(() => {
-  while (tempRoots.length > 0) {
-    const dir = tempRoots.pop();
-    if (dir) fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("migrateLocalDb", () => {
-  it("applies one migration and records ledger", () => {
-    const { home, hqRoot } = makeFixture();
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "001_create_t.sql",
-      "CREATE TABLE t (id INTEGER PRIMARY KEY);",
-    );
-
-    const result = migrateLocalDb({ company: "indigo", home, hqRoot });
-    expect(result.applied).toEqual(["001_create_t.sql"]);
-    expect(result.head).toBe("001_create_t");
-
-    const db = openLocalDb("indigo", { home });
-    const row = db
-      .prepare(
-        "SELECT name FROM sqlite_master WHERE type='table' AND name='t'",
-      )
-      .get() as { name: string };
-    expect(row.name).toBe("t");
-    db.close();
-  });
-
-  it("applies two migrations in order", () => {
-    const { home, hqRoot } = makeFixture();
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "001_a.sql",
-      "CREATE TABLE a (id INTEGER PRIMARY KEY);",
-    );
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "002_b.sql",
-      "CREATE TABLE b (id INTEGER PRIMARY KEY);",
-    );
-
-    const result = migrateLocalDb({ company: "indigo", home, hqRoot });
-    expect(result.applied).toEqual(["001_a.sql", "002_b.sql"]);
-    expect(result.head).toBe("002_b");
-  });
-
-  it("re-run is idempotent", () => {
-    const { home, hqRoot } = makeFixture();
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "001_t.sql",
-      "CREATE TABLE t (id INTEGER PRIMARY KEY);",
-    );
-
-    migrateLocalDb({ company: "indigo", home, hqRoot });
-    const second = migrateLocalDb({ company: "indigo", home, hqRoot });
-    expect(second.applied).toEqual([]);
-    expect(second.skipped).toContain("001_t.sql");
-    expect(second.head).toBe("001_t");
-  });
-
-  it("failed migration is not marked applied", () => {
-    const { home, hqRoot } = makeFixture();
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "001_ok.sql",
-      "CREATE TABLE ok (id INTEGER PRIMARY KEY);",
-    );
-    writeMigration(
-      hqRoot,
-      "indigo",
-      "002_bad.sql",
-      "CREATE TABLE ok (id INTEGER PRIMARY KEY);", // duplicate → fail
-    );
-
-    expect(() =>
-      migrateLocalDb({ company: "indigo", home, hqRoot }),
-    ).toThrow(/002_bad\.sql/);
-
-    const db = openLocalDb("indigo", { home });
-    const versions = db
-      .prepare("SELECT version FROM hq_schema_migrations ORDER BY version")
-      .all() as { version: string }[];
-    expect(versions.map((v) => v.version)).toEqual(["001_ok"]);
-    expect(
-      versions.map((v) => v.version).includes("002_bad"),
-    ).toBe(false);
-    db.close();
-  });
-});

package/src/lib/db/migrate.ts

@@ -1,137 +0,0 @@
-/**
- * Vault text migrations for local SQLite (vault-databases US-005).
- *
- * Migrations live as reviewable text under:
- *   companies/{company}/db/migrations/*.sql
- * Applied versions are recorded in hq_schema_migrations inside the local DB.
- */
-
-import fs from "node:fs";
-import path from "node:path";
-
-import type { LocalDb } from "./local.js";
-import { openLocalDb, readMigrationHead } from "./local.js";
-import type { LocalDbPathEnv } from "./paths.js";
-import { normalizeCompanySlugForLocalDb } from "./paths.js";
-
-export const MIGRATIONS_TABLE = "hq_schema_migrations";
-
-export interface MigrateOptions extends LocalDbPathEnv {
-  company: string;
-  /**
-   * Absolute path to HQ root containing companies/{co}/db/migrations.
-   * Required for vault-relative migrations.
-   */
-  hqRoot: string;
-}
-
-export interface MigrateResult {
-  company: string;
-  migrationsDir: string;
-  applied: string[];
-  skipped: string[];
-  head: string | null;
-}
-
-export function resolveMigrationsDir(hqRoot: string, companySlug: string): string {
-  const slug = normalizeCompanySlugForLocalDb(companySlug);
-  return path.join(hqRoot, "companies", slug, "db", "migrations");
-}
-
-/**
- * Ensure migrations directory exists (creates empty dir on first migrate).
- */
-export function ensureMigrationsDir(hqRoot: string, companySlug: string): string {
-  const dir = resolveMigrationsDir(hqRoot, companySlug);
-  fs.mkdirSync(dir, { recursive: true });
-  return dir;
-}
-
-/**
- * List pending migration files in lexical/version order (filename sort).
- */
-export function listMigrationFiles(migrationsDir: string): string[] {
-  if (!fs.existsSync(migrationsDir)) return [];
-  return fs
-    .readdirSync(migrationsDir)
-    .filter((f) => f.endsWith(".sql"))
-    .sort((a, b) => a.localeCompare(b, "en"));
-}
-
-export function ensureMigrationsLedger(db: LocalDb): void {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ${MIGRATIONS_TABLE} (
-      version TEXT PRIMARY KEY NOT NULL,
-      applied_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-  `);
-}
-
-export function listAppliedVersions(db: LocalDb): Set<string> {
-  ensureMigrationsLedger(db);
-  const rows = db
-    .prepare(`SELECT version FROM ${MIGRATIONS_TABLE} ORDER BY version`)
-    .all() as { version: string }[];
-  return new Set(rows.map((r) => r.version));
-}
-
-/**
- * Apply pending migrations. On failure, does not mark the failed file applied.
- */
-export function migrateLocalDb(opts: MigrateOptions): MigrateResult {
-  const company = normalizeCompanySlugForLocalDb(opts.company);
-  if (!opts.hqRoot?.trim()) {
-    throw new Error("hqRoot is required for vault migrations");
-  }
-
-  const migrationsDir = ensureMigrationsDir(opts.hqRoot, company);
-  const files = listMigrationFiles(migrationsDir);
-
-  const db = openLocalDb(company, opts);
-  const applied: string[] = [];
-  const skipped: string[] = [];
-
-  try {
-    ensureMigrationsLedger(db);
-    const already = listAppliedVersions(db);
-
-    for (const file of files) {
-      const version = file.replace(/\.sql$/i, "");
-      if (already.has(version) || already.has(file)) {
-        skipped.push(file);
-        continue;
-      }
-
-      const fullPath = path.join(migrationsDir, file);
-      const sql = fs.readFileSync(fullPath, "utf8");
-
-      const run = db.transaction(() => {
-        db.exec(sql);
-        db.prepare(
-          `INSERT INTO ${MIGRATIONS_TABLE} (version) VALUES (?)`,
-        ).run(version);
-      });
-
-      try {
-        run();
-        applied.push(file);
-        already.add(version);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(
-          `migration failed: ${file} — ${msg} (not marked applied)`,
-        );
-      }
-    }
-
-    return {
-      company,
-      migrationsDir,
-      applied,
-      skipped,
-      head: readMigrationHead(db),
-    };
-  } finally {
-    db.close();
-  }
-}