ndomo 0.1.0

package/src/db/resolve-project-dir.ts

@@ -0,0 +1,75 @@
+/**
+ * Resolve the project directory for ndomo DB operations.
+ *
+ * Chains `worktree → directory → process.cwd()`, picking the first VALID
+ * path (absolute, non-root, non-empty). When the opencode SDK passes an
+ * invalid path (e.g. `ctx.directory="/"` for an empty project without
+ * `.opencode/`, as observed with pgadmin), falls back to `process.cwd()`
+ * so `.ndomo/` gets created in the user's actual CWD rather than at the
+ * filesystem root (which would EACCES on `/.ndomo`).
+ *
+ * Validation in `openDb()` remains as a final defense-in-depth guard —
+ * this helper is the "smart" layer, `openDb` is the "strict" layer.
+ *
+ * See plan bb805ff9 (auto-bootstrap-ndomo-dir-with-cwd-fallback).
+ */
+
+import { isAbsolute } from "node:path";
+
+/**
+ * Minimal slice of an opencode tool/plugin context that carries project
+ * path hints. Both `worktree` and `directory` are optional in the SDK
+ * (an empty project may yield `directory="/"`).
+ */
+export interface ProjectDirContext {
+  worktree?: string | undefined;
+  directory?: string | undefined;
+}
+
+/**
+ * A path is "valid" for `.ndomo/` placement when it is:
+ *   - a string (not undefined/null)
+ *   - non-empty
+ *   - not the filesystem root "/"
+ *   - absolute (so `.ndomo` lands at a deterministic location)
+ */
+function isValidPath(p: string | undefined | null): p is string {
+  return typeof p === "string" && p !== "" && p !== "/" && isAbsolute(p);
+}
+
+/**
+ * Resolve the project directory to use for `.ndomo/state.db`.
+ *
+ * Resolution order:
+ *   1. `ctx.worktree`  (git worktree root, when set)
+ *   2. `ctx.directory` (opencode project directory)
+ *   3. `process.cwd()` (default flow for projects without `.opencode/`,
+ *      e.g. pgadmin — the SDK passes `directory="/"` and CWD is the
+ *      expected, normal resolution, NOT an exception)
+ *   4. throw — only if even `process.cwd()` is invalid (extremely unlikely;
+ *      would indicate a misconfigured shell/env).
+ *
+ * Emits a `console.warn` only when `ctx.worktree` is present but invalid
+ * (anomalous SDK config). The CWD fallback is silent because it is the
+ * expected default for marker-only / no-`.opencode/` projects.
+ */
+export function resolveProjectDir(ctx: ProjectDirContext): string {
+  if (isValidPath(ctx.worktree)) {
+    return ctx.worktree;
+  }
+  if (isValidPath(ctx.directory)) {
+    if (ctx.worktree) {
+      console.warn(
+        `[ndomo] ctx.worktree=${JSON.stringify(ctx.worktree)} invalid, using ctx.directory=${JSON.stringify(ctx.directory)}`,
+      );
+    }
+    return ctx.directory;
+  }
+  const cwd = process.cwd();
+  if (isValidPath(cwd)) {
+    return cwd;
+  }
+  throw new Error(
+    `resolveProjectDir: no valid project directory — ctx.worktree=${JSON.stringify(ctx.worktree)}, ctx.directory=${JSON.stringify(ctx.directory)}, process.cwd()=${JSON.stringify(cwd)}`,
+  );
+}

package/src/db/rollbacks.test.ts

@@ -0,0 +1,150 @@
+import { Database } from "bun:sqlite"
+import { beforeEach, describe, expect, test } from "bun:test"
+import { createIncident } from "./incidents.ts"
+import { runMigrations } from "./migrations.ts"
+import { getRollback, listRollbacksForDeployment, listRollbacksForIncident, recordRollback } from "./rollbacks.ts"
+
+function createTestDeployment(db: Database, id = "d1"): string {
+  const now = Date.now()
+  db.query("INSERT OR IGNORE INTO environments (id, name, slug, created_at, updated_at) VALUES (?, ?, ?, ?, ?)").run("e1", "prod", "prod", now, now)
+  db.query("INSERT OR IGNORE INTO releases (id, version, title, created_at) VALUES (?, ?, ?, ?)").run("r1", "1.0.0", "rel", now)
+  db.query("INSERT INTO deployments (id, release_id, environment_id, status, created_at) VALUES (?, ?, ?, ?, ?)").run(id, "r1", "e1", "planned", now)
+  return id
+}
+
+describe("rollbacks.ts", () => {
+  let db: Database
+  beforeEach(() => {
+    db = new Database(":memory:")
+    db.exec("PRAGMA foreign_keys = ON")
+    runMigrations(db)
+  })
+
+  describe("recordRollback", () => {
+    test("happy path — defaults to status=planned", () => {
+      createTestDeployment(db)
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "Revert to previous version" })
+      expect(rb.id).toBeTruthy()
+      expect(rb.deploymentId).toBe("d1")
+      expect(rb.status).toBe("planned")
+      expect(rb.plan).toBe("Revert to previous version")
+      expect(rb.incidentId).toBeNull()
+      expect(rb.newDeploymentId).toBeNull()
+      expect(rb.executedAt).toBeNull()
+      expect(rb.createdAt).toBeGreaterThan(0)
+    })
+
+    test("with explicit status", () => {
+      createTestDeployment(db)
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "Approved rollback", status: "approved" })
+      expect(rb.status).toBe("approved")
+    })
+
+    test("with metadata", () => {
+      createTestDeployment(db)
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "Meta test", metadata: { reason: "regression" } })
+      expect(rb.metadata).toEqual({ reason: "regression" })
+    })
+
+    test("throws on invalid status", () => {
+      createTestDeployment(db)
+      expect(() => recordRollback(db, { deploymentId: "d1", plan: "Bad", status: "invalid" as any })).toThrow("invalid rollback status")
+    })
+
+    test("throws on empty plan (whitespace only)", () => {
+      createTestDeployment(db)
+      expect(() => recordRollback(db, { deploymentId: "d1", plan: "   " })).toThrow("rollback plan cannot be empty")
+    })
+
+    test("trims plan", () => {
+      createTestDeployment(db)
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "  trimmed  " })
+      expect(rb.plan).toBe("trimmed")
+    })
+
+    test("truncates plan >16KB", () => {
+      createTestDeployment(db)
+      const bigPlan = "x".repeat(20_000)
+      const rb = recordRollback(db, { deploymentId: "d1", plan: bigPlan })
+      expect(rb.plan.length).toBeLessThan(20_000)
+      expect(rb.plan).toContain("…[truncated]")
+    })
+
+    test("FK validation — non-existent deployment_id throws", () => {
+      expect(() => recordRollback(db, { deploymentId: "nonexistent", plan: "test" })).toThrow("deployment 'nonexistent' not found")
+    })
+
+    test("FK validation — non-existent incident_id throws", () => {
+      createTestDeployment(db)
+      expect(() => recordRollback(db, { deploymentId: "d1", plan: "test", incidentId: "nonexistent" })).toThrow("incident 'nonexistent' not found")
+    })
+
+    test("FK validation — non-existent new_deployment_id throws", () => {
+      createTestDeployment(db)
+      expect(() => recordRollback(db, { deploymentId: "d1", plan: "test", newDeploymentId: "nonexistent" })).toThrow("new_deployment 'nonexistent' not found")
+    })
+
+    test("with valid incident_id", () => {
+      createTestDeployment(db)
+      const inc = createIncident(db, { title: "Test incident", severity: "sev1" })
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "Rollback for incident", incidentId: inc.id })
+      expect(rb.incidentId).toBe(inc.id)
+    })
+
+    test("with valid new_deployment_id", () => {
+      createTestDeployment(db, "d1")
+      createTestDeployment(db, "d2")
+      const rb = recordRollback(db, { deploymentId: "d1", plan: "Roll forward", newDeploymentId: "d2" })
+      expect(rb.newDeploymentId).toBe("d2")
+    })
+  })
+
+  describe("getRollback", () => {
+    test("returns existing rollback", () => {
+      createTestDeployment(db)
+      const created = recordRollback(db, { deploymentId: "d1", plan: "Find me" })
+      const found = getRollback(db, created.id)
+      expect(found).not.toBeNull()
+      expect(found!.plan).toBe("Find me")
+    })
+
+    test("returns null for non-existent id", () => {
+      expect(getRollback(db, "nonexistent")).toBeNull()
+    })
+  })
+
+  describe("listRollbacksForIncident", () => {
+    test("returns rollbacks linked to incident", () => {
+      createTestDeployment(db)
+      const inc = createIncident(db, { title: "Inc", severity: "sev1" })
+      recordRollback(db, { deploymentId: "d1", plan: "RB1", incidentId: inc.id })
+      recordRollback(db, { deploymentId: "d1", plan: "RB2", incidentId: inc.id })
+      recordRollback(db, { deploymentId: "d1", plan: "RB3", incidentId: inc.id })
+      const rbs = listRollbacksForIncident(db, inc.id)
+      expect(rbs.length).toBe(3)
+    })
+
+    test("returns empty for incident with no rollbacks", () => {
+      createTestDeployment(db)
+      const inc = createIncident(db, { title: "Empty", severity: "sev1" })
+      const rbs = listRollbacksForIncident(db, inc.id)
+      expect(rbs.length).toBe(0)
+    })
+  })
+
+  describe("listRollbacksForDeployment", () => {
+    test("returns rollbacks for deployment", () => {
+      createTestDeployment(db)
+      recordRollback(db, { deploymentId: "d1", plan: "RB1" })
+      recordRollback(db, { deploymentId: "d1", plan: "RB2" })
+      const rbs = listRollbacksForDeployment(db, "d1")
+      expect(rbs.length).toBe(2)
+    })
+
+    test("returns empty for deployment with no rollbacks", () => {
+      createTestDeployment(db)
+      const rbs = listRollbacksForDeployment(db, "d1")
+      expect(rbs.length).toBe(0)
+    })
+  })
+})

package/src/db/rollbacks.ts

@@ -0,0 +1,67 @@
+/**
+ * ndomo DB — Rollback execution CRUD.
+ *
+ * All functions take a Database instance and return camelCase TS types.
+ */
+
+import type { Database } from "bun:sqlite"
+import { rollbackFromRow, type InsertRollback, type RollbackExecution, type RollbackStatus } from "./types.ts"
+
+const MAX_TEXT_BYTES = 16 * 1024
+
+function truncateText(s: string): string {
+  if (s.length <= MAX_TEXT_BYTES) return s
+  return `${s.slice(0, MAX_TEXT_BYTES)}…[truncated]`
+}
+
+const VALID_STATUSES: RollbackStatus[] = ["planned", "approved", "dry_run", "executing", "success", "failed", "cancelled"]
+
+export function recordRollback(
+  db: Database,
+  input: InsertRollback,
+): RollbackExecution {
+  // FK: deployment_id required
+  const dep = db.query("SELECT id FROM deployments WHERE id = ?").get(input.deploymentId)
+  if (!dep) throw new Error(`ndomo: deployment '${input.deploymentId}' not found (FK violation)`)
+  // FK: incident_id optional
+  if (input.incidentId) {
+    const inc = db.query("SELECT id FROM incidents WHERE id = ?").get(input.incidentId)
+    if (!inc) throw new Error(`ndomo: incident '${input.incidentId}' not found (FK violation)`)
+  }
+  // FK: new_deployment_id optional
+  if (input.newDeploymentId) {
+    const newDep = db.query("SELECT id FROM deployments WHERE id = ?").get(input.newDeploymentId)
+    if (!newDep) throw new Error(`ndomo: new_deployment '${input.newDeploymentId}' not found (FK violation)`)
+  }
+  // Status (default planned)
+  const status: RollbackStatus = input.status ?? "planned"
+  if (!VALID_STATUSES.includes(status)) {
+    throw new Error(`ndomo: invalid rollback status '${status}' (must be one of: ${VALID_STATUSES.join(", ")})`)
+  }
+  // Plan: trim + truncate + validate non-empty
+  const plan = truncateText(input.plan.trim())
+  if (plan.length === 0) throw new Error("ndomo: rollback plan cannot be empty")
+  const id = crypto.randomUUID()
+  const now = Date.now()
+  const metadata = input.metadata ? JSON.stringify(input.metadata) : null
+  db.query(
+    `INSERT INTO rollback_executions (id, deployment_id, incident_id, new_deployment_id, status, plan, executed_at, created_at, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, NULL, ?, ?)`,
+  ).run(id, input.deploymentId, input.incidentId ?? null, input.newDeploymentId ?? null, status, plan, now, metadata)
+  return getRollback(db, id)!
+}
+
+export function getRollback(db: Database, id: string): RollbackExecution | null {
+  const row = db.query("SELECT * FROM rollback_executions WHERE id = ?").get(id)
+  return row ? rollbackFromRow(row) : null
+}
+
+export function listRollbacksForIncident(db: Database, incidentId: string): RollbackExecution[] {
+  const rows = db.query("SELECT * FROM rollback_executions WHERE incident_id = ? ORDER BY created_at DESC").all(incidentId)
+  return rows.map(rollbackFromRow)
+}
+
+export function listRollbacksForDeployment(db: Database, deploymentId: string): RollbackExecution[] {
+  const rows = db.query("SELECT * FROM rollback_executions WHERE deployment_id = ? ORDER BY created_at DESC").all(deploymentId)
+  return rows.map(rollbackFromRow)
+}