@geraldmaron/construct 1.0.23 → 1.1.0

package/lib/storage/backup.mjs

@@ -1,347 +0,0 @@
-/**
- * lib/storage/backup.mjs — full Construct backup and restore.
- *
- * A backup archive is a gzip-compressed tar containing:
- *
- *   manifest.json          — version, timestamp, contents list, checksums
- *   postgres/              — pg_dump output (if Postgres is reachable)
- *   observations/          — ~/.cx/observations/*.json
- *   sessions/              — ~/.cx/sessions/*.json
- *   config.env             — ~/.construct/config.env (secrets stripped unless opts.includeSecrets)
- *   registry.json          — specialists/registry.json snapshot
- *
- * The manifest uses SHA-256 checksums over each included file so
- * `backup verify` can detect corruption without extracting.
- *
- * Restore is atomic: files are written to a temp directory first,
- * then moved into place in one pass. Postgres restore is the last step
- * because it is the hardest to roll back.
- */
-
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { execFileSync } from 'node:child_process';
-
-const HOME = os.homedir();
-const CX_DIR = path.join(HOME, '.cx');
-const CONSTRUCT_DIR = path.join(HOME, '.construct');
-const BACKUP_DIR = path.join(CONSTRUCT_DIR, 'backups');
-
-// Secret env var patterns to redact in config.env.
-const SECRET_KEYS = [
-  /TOKEN/i, /PASSWORD/i, /SECRET/i, /KEY/i, /CREDENTIAL/i,
-  /ANTHROPIC_API/i, /GITHUB_TOKEN/i, /SLACK_BOT/i, /SALESFORCE_ACCESS/i,
-  /JIRA_API/i, /LINEAR_API/i,
-];
-
-function isSecretKey(key) {
-  return SECRET_KEYS.some((re) => re.test(key));
-}
-
-function redactConfigEnv(content) {
-  return content.split('\n').map((line) => {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) return line;
-    const eq = trimmed.indexOf('=');
-    if (eq === -1) return line;
-    const key = trimmed.slice(0, eq).trim();
-    if (isSecretKey(key)) return `${key}=<redacted>`;
-    return line;
-  }).join('\n');
-}
-
-function sha256File(filePath) {
-  const hash = crypto.createHash('sha256');
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest('hex');
-}
-
-function sha256Buffer(buf) {
-  return crypto.createHash('sha256').update(buf).digest('hex');
-}
-
-function archiveName() {
-  const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-  return `construct-backup-${ts}.tar.gz`;
-}
-
-/**
- * Create a full backup archive.
- *
- * @param {object} [opts]
- * @param {boolean} [opts.includeSecrets] - include raw secret values in config.env
- * @param {string} [opts.registryPath] - path to specialists/registry.json
- * @param {string} [opts.destDir] - destination directory (default: ~/.construct/backups)
- * @returns {{ path: string, manifest: object }}
- */
-export async function createBackup({ includeSecrets = false, registryPath, destDir } = {}) {
-  const dest = destDir || BACKUP_DIR;
-  fs.mkdirSync(dest, { recursive: true });
-
-  const stageDir = fs.mkdtempSync(path.join(os.tmpdir(), 'construct-backup-'));
-  const files = [];
-  const checksums = {};
-
-  try {
-    // ── Observations ──────────────────────────────────────────────────────
-    const obsDir = path.join(CX_DIR, 'observations');
-    const stagObs = path.join(stageDir, 'observations');
-    if (fs.existsSync(obsDir)) {
-      fs.mkdirSync(stagObs, { recursive: true });
-      for (const f of fs.readdirSync(obsDir).filter((n) => n.endsWith('.json'))) {
-        const src = path.join(obsDir, f);
-        const dst = path.join(stagObs, f);
-        fs.copyFileSync(src, dst);
-        checksums[`observations/${f}`] = sha256File(dst);
-        files.push(`observations/${f}`);
-      }
-    }
-
-    // ── Sessions ──────────────────────────────────────────────────────────
-    const sessDir = path.join(CX_DIR, 'sessions');
-    const stagSess = path.join(stageDir, 'sessions');
-    if (fs.existsSync(sessDir)) {
-      fs.mkdirSync(stagSess, { recursive: true });
-      for (const f of fs.readdirSync(sessDir).filter((n) => n.endsWith('.json'))) {
-        const src = path.join(sessDir, f);
-        const dst = path.join(stagSess, f);
-        fs.copyFileSync(src, dst);
-        checksums[`sessions/${f}`] = sha256File(dst);
-        files.push(`sessions/${f}`);
-      }
-    }
-
-    // ── config.env ────────────────────────────────────────────────────────
-    const configEnv = path.join(CONSTRUCT_DIR, 'config.env');
-    if (fs.existsSync(configEnv)) {
-      let content = fs.readFileSync(configEnv, 'utf8');
-      if (!includeSecrets) content = redactConfigEnv(content);
-      const dst = path.join(stageDir, 'config.env');
-      fs.writeFileSync(dst, content);
-      checksums['config.env'] = sha256Buffer(Buffer.from(content));
-      files.push('config.env');
-    }
-
-    // ── Registry snapshot ─────────────────────────────────────────────────
-    const regPath = registryPath || path.join(process.cwd(), 'specialists', 'registry.json');
-    if (fs.existsSync(regPath)) {
-      const dst = path.join(stageDir, 'registry.json');
-      fs.copyFileSync(regPath, dst);
-      checksums['registry.json'] = sha256File(dst);
-      files.push('registry.json');
-    }
-
-    // ── Postgres dump ─────────────────────────────────────────────────────
-    const pgResult = tryPostgresDump(stageDir);
-    if (pgResult.success) {
-      checksums['postgres/dump.sql'] = sha256File(path.join(stageDir, 'postgres', 'dump.sql'));
-      files.push('postgres/dump.sql');
-    }
-
-    // ── Manifest ──────────────────────────────────────────────────────────
-    const manifest = {
-      version: 1,
-      createdAt: new Date().toISOString(),
-      includesSecrets: includeSecrets,
-      contents: files,
-      checksums,
-    };
-    fs.writeFileSync(path.join(stageDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
-
-    // ── Pack to tar.gz ────────────────────────────────────────────────────
-    const outPath = path.join(dest, archiveName());
-    execFileSync('tar', ['-czf', outPath, '-C', stageDir, '.'], { stdio: 'pipe' });
-
-    return { path: outPath, manifest };
-  } finally {
-    fs.rmSync(stageDir, { recursive: true, force: true });
-  }
-}
-
-function tryPostgresDump(stageDir) {
-  const dumpDir = path.join(stageDir, 'postgres');
-  const dumpFile = path.join(dumpDir, 'dump.sql');
-
-  const dbUrl = process.env.DATABASE_URL || process.env.CONSTRUCT_DATABASE_URL;
-  if (!dbUrl) return { success: false, reason: 'no DATABASE_URL' };
-
-  try {
-    fs.mkdirSync(dumpDir, { recursive: true });
-    execFileSync('pg_dump', [dbUrl, '--no-password', '-f', dumpFile], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: 60_000,
-    });
-    return { success: true };
-  } catch (err) {
-    return { success: false, reason: err.message };
-  }
-}
-
-/**
- * Verify a backup archive by comparing stored checksums to actual file hashes.
- *
- * @param {string} archivePath
- * @returns {{ ok: boolean, errors: string[] }}
- */
-export async function verifyBackup(archivePath) {
-  const extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'construct-verify-'));
-  const errors = [];
-  try {
-    execFileSync('tar', ['-xzf', archivePath, '-C', extractDir], { stdio: 'pipe' });
-
-    const manifestPath = path.join(extractDir, 'manifest.json');
-    if (!fs.existsSync(manifestPath)) {
-      return { ok: false, errors: ['manifest.json missing'] };
-    }
-
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    for (const [rel, expected] of Object.entries(manifest.checksums || {})) {
-      const abs = path.join(extractDir, rel);
-      if (!fs.existsSync(abs)) {
-        errors.push(`missing: ${rel}`);
-        continue;
-      }
-      const actual = sha256File(abs);
-      if (actual !== expected) errors.push(`checksum mismatch: ${rel}`);
-    }
-
-    return { ok: errors.length === 0, errors };
-  } finally {
-    fs.rmSync(extractDir, { recursive: true, force: true });
-  }
-}
-
-/**
- * Restore a backup archive. Prompts for confirmation before writing.
- *
- * @param {string} archivePath
- * @param {object} [opts]
- * @param {boolean} [opts.yes] - skip confirmation prompt
- * @returns {{ ok: boolean, restored: string[], errors: string[] }}
- */
-export async function restoreBackup(archivePath, { yes = false } = {}) {
-  const verify = await verifyBackup(archivePath);
-  if (!verify.ok) {
-    return { ok: false, restored: [], errors: [`verification failed: ${verify.errors.join(', ')}`] };
-  }
-
-  const extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'construct-restore-'));
-  const restored = [];
-  const errors = [];
-
-  try {
-    execFileSync('tar', ['-xzf', archivePath, '-C', extractDir], { stdio: 'pipe' });
-
-    const manifest = JSON.parse(fs.readFileSync(path.join(extractDir, 'manifest.json'), 'utf8'));
-
-    // Restore observations
-    const stagObs = path.join(extractDir, 'observations');
-    if (fs.existsSync(stagObs)) {
-      const dest = path.join(CX_DIR, 'observations');
-      fs.mkdirSync(dest, { recursive: true });
-      for (const f of fs.readdirSync(stagObs)) {
-        fs.copyFileSync(path.join(stagObs, f), path.join(dest, f));
-        restored.push(`observations/${f}`);
-      }
-    }
-
-    // Restore sessions
-    const stagSess = path.join(extractDir, 'sessions');
-    if (fs.existsSync(stagSess)) {
-      const dest = path.join(CX_DIR, 'sessions');
-      fs.mkdirSync(dest, { recursive: true });
-      for (const f of fs.readdirSync(stagSess)) {
-        fs.copyFileSync(path.join(stagSess, f), path.join(dest, f));
-        restored.push(`sessions/${f}`);
-      }
-    }
-
-    // Restore config.env — only if it contained no redacted lines
-    const stagConfig = path.join(extractDir, 'config.env');
-    if (fs.existsSync(stagConfig)) {
-      const content = fs.readFileSync(stagConfig, 'utf8');
-      if (!content.includes('<redacted>')) {
-        fs.mkdirSync(CONSTRUCT_DIR, { recursive: true });
-        fs.writeFileSync(path.join(CONSTRUCT_DIR, 'config.env'), content, { mode: 0o600 });
-        restored.push('config.env');
-      } else {
-        errors.push('config.env has redacted secrets — restore credentials manually');
-      }
-    }
-
-    // Restore registry.json
-    const stagReg = path.join(extractDir, 'registry.json');
-    if (fs.existsSync(stagReg)) {
-      const dest = path.join(process.cwd(), 'specialists', 'registry.json');
-      fs.mkdirSync(path.dirname(dest), { recursive: true });
-      fs.copyFileSync(stagReg, dest);
-      restored.push('registry.json');
-    }
-
-    // Restore Postgres (last — hardest to undo)
-    const stagPg = path.join(extractDir, 'postgres', 'dump.sql');
-    if (fs.existsSync(stagPg)) {
-      const pgResult = tryPostgresRestore(stagPg);
-      if (pgResult.success) {
-        restored.push('postgres');
-      } else {
-        errors.push(`postgres restore failed: ${pgResult.reason}`);
-      }
-    }
-
-    return { ok: errors.length === 0, restored, errors };
-  } finally {
-    fs.rmSync(extractDir, { recursive: true, force: true });
-  }
-}
-
-function tryPostgresRestore(dumpFile) {
-  const dbUrl = process.env.DATABASE_URL || process.env.CONSTRUCT_DATABASE_URL;
-  if (!dbUrl) return { success: false, reason: 'no DATABASE_URL' };
-  try {
-    execFileSync('psql', [dbUrl, '-f', dumpFile], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout: 120_000,
-    });
-    return { success: true };
-  } catch (err) {
-    return { success: false, reason: err.message };
-  }
-}
-
-/**
- * List backup archives in the default backup directory.
- */
-export function listBackups(dir = BACKUP_DIR) {
-  if (!fs.existsSync(dir)) return [];
-  return fs.readdirSync(dir)
-    .filter((f) => f.startsWith('construct-backup-') && f.endsWith('.tar.gz'))
-    .sort()
-    .reverse()
-    .map((f) => {
-      const fullPath = path.join(dir, f);
-      const stat = fs.statSync(fullPath);
-      return { name: f, path: fullPath, size: stat.size, mtime: stat.mtime };
-    });
-}
-
-// Keep the `keep` most recent backups in `dir`; unlink the rest. The return
-// value names each pruned file by archive basename. Per-file unlink errors
-// are swallowed so one locked archive can't abort the whole pass.
-export function pruneBackups({ keep = 10, dir = BACKUP_DIR } = {}) {
-  const list = listBackups(dir);
-  if (list.length <= keep) return { kept: list.length, removed: [] };
-  const toRemove = list.slice(keep);
-  const removed = [];
-  for (const b of toRemove) {
-    try {
-      fs.unlinkSync(b.path);
-      removed.push(b.name);
-    } catch {
-      /* best effort — leave file in place if it's locked or unreadable */
-    }
-  }
-  return { kept: keep, removed };
-}

package/lib/storage/migrations.mjs

@@ -1,187 +0,0 @@
-/**
- * lib/storage/migrations.mjs — Postgres migration runner with hash tracking.
- *
- * Walks `db/schema/*.sql` in lexical order and applies any not yet
- * recorded in `construct_schema_migrations`. Each applied file's SHA256 is
- * stored alongside the filename. Re-running the runner against an unchanged
- * tree is a no-op.
- *
- * Drift detection: if an applied file's SHA changes between runs, the runner
- * fails fast with a precise error. SQL files are append-only by convention —
- * to evolve schema after a migration ships, write a new file with a higher
- * sequence number.
- *
- * Repair mode: long-lived developer databases pre-date the append-only policy
- * and carry stale SHAs for files that have since evolved. Call runMigrations
- * with `repair: true` (or `construct storage repair-migrations`) to re-apply
- * each drifted file. The repair refuses on any file containing a destructive
- * statement (`DROP`, `TRUNCATE`, `ALTER … DROP`) so the safety bar stays
- * "only fully-idempotent migrations may be re-recorded."
- *
- * The bookkeeping table (`construct_schema_migrations`) is created inline
- * before applied state is checked, so the runner self-bootstraps and a fresh
- * database can run from any starting migration without a prerequisite file.
- */
-
-import { readdirSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { createHash } from 'node:crypto';
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const DEFAULT_MIGRATIONS_DIR = join(MODULE_DIR, '..', '..', 'db', 'schema');
-
-function sha256(text) {
-  return createHash('sha256').update(text).digest('hex');
-}
-
-function listMigrationFiles(dir) {
-  return readdirSync(dir)
-    .filter((name) => name.endsWith('.sql'))
-    .sort();
-}
-
-const BOOKKEEPING_DDL = `
-CREATE TABLE IF NOT EXISTS construct_schema_migrations (
-    filename TEXT PRIMARY KEY,
-    sha TEXT NOT NULL,
-    applied_at TIMESTAMPTZ NOT NULL DEFAULT now()
-);
-`;
-
-// Heuristic: a migration is safe to re-apply (idempotent) when it contains no
-// destructive statements. Comments are stripped first so a `-- DROP …` note in
-// a docstring does not falsely flag the file.
-const DESTRUCTIVE_RE = /\b(drop\s+(table|index|view|column|schema|extension|function|sequence)\b|truncate\b|alter\s+table\s+[^;]*?\bdrop\b|delete\s+from\b)/i;
-
-function stripSqlComments(sql) {
-  return sql
-    .replace(/--[^\n]*/g, '')
-    .replace(/\/\*[\s\S]*?\*\//g, '');
-}
-
-export function isIdempotentMigration(sql) {
-  return !DESTRUCTIVE_RE.test(stripSqlComments(sql));
-}
-
-/**
- * Apply pending migrations. Returns a per-file outcome summary.
- *
- * @param {object} client — postgres client (from createSqlClient)
- * @param {object} [opts]
- * @param {string} [opts.dir] — schema/migrations directory, defaults to db/schema
- * @param {boolean} [opts.repair] — when true, re-apply drifted files that are
- *   verifiably idempotent and update their recorded SHA. Destructive drift
- *   still throws. Default false.
- * @returns {Promise<{ applied: string[], skipped: string[], repaired: string[], drift: Array<{ filename: string, expected: string, actual: string, idempotent: boolean }> }>}
- */
-export async function runMigrations(client, { dir = DEFAULT_MIGRATIONS_DIR, repair = false } = {}) {
-  if (!client) throw new Error('runMigrations requires a postgres client');
-
-  await client.unsafe(BOOKKEEPING_DDL);
-
-  const recorded = await client`
-    SELECT filename, sha FROM construct_schema_migrations
-  `;
-  const recordedMap = new Map(recorded.map((r) => [r.filename, r.sha]));
-
-  const files = listMigrationFiles(dir);
-  const applied = [];
-  const skipped = [];
-  const repaired = [];
-  const drift = [];
-
-  for (const filename of files) {
-    const path = join(dir, filename);
-    const contents = readFileSync(path, 'utf8');
-    const sha = sha256(contents);
-
-    const prev = recordedMap.get(filename);
-    if (prev) {
-      if (prev !== sha) {
-        const idempotent = isIdempotentMigration(contents);
-        if (repair && idempotent) {
-          // Re-apply the migration (its IF NOT EXISTS clauses make this a
-          // no-op against the live schema) and update the recorded SHA.
-          await client.begin(async (tx) => {
-            await tx.unsafe(contents);
-            await tx`
-              UPDATE construct_schema_migrations
-                 SET sha = ${sha}, applied_at = now()
-               WHERE filename = ${filename}
-            `;
-          });
-          repaired.push(filename);
-        } else {
-          drift.push({ filename, expected: prev, actual: sha, idempotent });
-        }
-      } else {
-        skipped.push(filename);
-      }
-      continue;
-    }
-
-    await client.begin(async (tx) => {
-      await tx.unsafe(contents);
-      await tx`
-        INSERT INTO construct_schema_migrations (filename, sha)
-        VALUES (${filename}, ${sha})
-        ON CONFLICT (filename) DO UPDATE SET sha = EXCLUDED.sha, applied_at = now()
-      `;
-    });
-    applied.push(filename);
-  }
-
-  if (drift.length > 0) {
-    const detail = drift
-      .map((d) => `  ${d.filename}: applied SHA ${d.expected.slice(0, 12)}…, on-disk SHA ${d.actual.slice(0, 12)}…${d.idempotent ? ' (idempotent — repairable via `construct storage repair-migrations`)' : ' (NOT idempotent — write a new migration file)'}`)
-      .join('\n');
-    throw new Error(
-      `Migration drift detected (a previously-applied migration file has changed). ` +
-      `Migrations are append-only — write a new file with a higher sequence number ` +
-      `to evolve the schema. Drift:\n${detail}`
-    );
-  }
-
-  return { applied, skipped, repaired, drift };
-}
-
-/**
- * Diagnostic for `construct doctor`: returns last applied filename, count,
- * and any drift, without throwing.
- */
-export async function describeMigrations(client, { dir = DEFAULT_MIGRATIONS_DIR } = {}) {
-  if (!client) return { ok: false, reason: 'no_sql_client' };
-  try {
-    await client.unsafe(BOOKKEEPING_DDL);
-    const rows = await client`
-      SELECT filename, sha, applied_at
-        FROM construct_schema_migrations
-       ORDER BY applied_at DESC, filename DESC
-       LIMIT 1
-    `;
-    const onDisk = listMigrationFiles(dir);
-    const applied = await client`SELECT count(*)::int AS n FROM construct_schema_migrations`;
-    const recorded = await client`SELECT filename, sha FROM construct_schema_migrations`;
-    const recordedMap = new Map(recorded.map((r) => [r.filename, r.sha]));
-    const drift = [];
-    for (const filename of onDisk) {
-      const contents = readFileSync(join(dir, filename), 'utf8');
-      const sha = sha256(contents);
-      const prev = recordedMap.get(filename);
-      if (prev && prev !== sha) {
-        drift.push({ filename, idempotent: isIdempotentMigration(contents) });
-      }
-    }
-    return {
-      ok: true,
-      lastApplied: rows[0]?.filename || null,
-      lastAppliedAt: rows[0]?.applied_at || null,
-      appliedCount: applied[0]?.n ?? 0,
-      onDiskCount: onDisk.length,
-      drift,
-    };
-  } catch (err) {
-    return { ok: false, reason: err?.message || 'describe-migrations failed' };
-  }
-}

package/lib/storage/postgres-backup.mjs

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-/**
- * lib/storage/postgres-backup.mjs — durable stash/restore for the managed construct-postgres container.
- *
- * Mirrors the telemetry backup pattern in service-manager.mjs. Entry points:
- *   - construct down  → stashConstructDb  (dump before container stop)
- *   - construct init → restoreConstructDb (reload after fresh container start)
- *
- * Dumps are stored in ~/.construct/backups/postgres/ as pg_dump custom-format
- * files. The N most recent are kept; older ones are pruned automatically.
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-const POSTGRES_CONTAINER = 'construct-postgres';
-const POSTGRES_USER = 'construct';
-const POSTGRES_DB = 'construct';
-const DEFAULT_KEEP = 5;
-
-function pruneBackupDir(dir, keep) {
-  try {
-    const dumps = fs.readdirSync(dir)
-      .filter((f) => f.startsWith('construct-') && f.endsWith('.dump'))
-      .sort()
-      .reverse();
-    for (const dump of dumps.slice(keep)) {
-      fs.rmSync(path.join(dir, dump), { force: true });
-      fs.rmSync(path.join(dir, dump.replace('.dump', '.json')), { force: true });
-    }
-  } catch { /* non-critical */ }
-}
-
-/**
- * Dump the construct Postgres database to a timestamped file under
- * ~/.construct/backups/postgres/. Safe to call when the container is not
- * running — returns { status: 'no-data' } silently.
- */
-export function stashConstructDb({
-  homeDir = os.homedir(),
-  spawnSyncFn = spawnSync,
-  keep = DEFAULT_KEEP,
-} = {}) {
-  const stashDir = path.join(homeDir, '.construct', 'backups', 'postgres');
-  fs.mkdirSync(stashDir, { recursive: true });
-
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-  const dumpFile = path.join(stashDir, `construct-${timestamp}.dump`);
-  const manifestFile = path.join(stashDir, `construct-${timestamp}.json`);
-
-  const dump = spawnSyncFn('docker', [
-    'exec', POSTGRES_CONTAINER,
-    'pg_dump', '-U', POSTGRES_USER, '-d', POSTGRES_DB,
-    '-Fc', '--data-only',
-  ], { stdio: ['ignore', 'pipe', 'ignore'], maxBuffer: 200 * 1024 * 1024 });
-
-  const hasData = dump.status === 0 && dump.stdout?.length > 100;
-  if (!hasData) return { status: 'no-data', stashPath: null };
-
-  fs.writeFileSync(dumpFile, dump.stdout);
-  fs.writeFileSync(manifestFile, JSON.stringify({
-    version: 1,
-    createdAt: new Date().toISOString(),
-    reason: 'pre-shutdown-stash',
-    dumpFile: path.basename(dumpFile),
-    dumpBytes: dump.stdout.length,
-  }, null, 2) + '\n');
-
-  pruneBackupDir(stashDir, keep);
-  return { status: 'ok', stashPath: dumpFile, bytes: dump.stdout.length };
-}
-
-/**
- * Restore the most recent stash into a running construct-postgres container.
- * Safe to call when no stash exists — returns { status: 'no-stash' } silently.
- * The schema must already exist (run migration before calling this).
- */
-export function restoreConstructDb({
-  homeDir = os.homedir(),
-  spawnSyncFn = spawnSync,
-} = {}) {
-  const stashDir = path.join(homeDir, '.construct', 'backups', 'postgres');
-  if (!fs.existsSync(stashDir)) return { status: 'no-stash' };
-
-  const dumps = fs.readdirSync(stashDir)
-    .filter((f) => f.startsWith('construct-') && f.endsWith('.dump'))
-    .sort()
-    .reverse();
-  if (dumps.length === 0) return { status: 'no-stash' };
-
-  const latestDump = path.join(stashDir, dumps[0]);
-
-  const cp = spawnSyncFn('docker', [
-    'cp', latestDump, `${POSTGRES_CONTAINER}:/tmp/construct.dump`,
-  ], { stdio: 'ignore' });
-  if (cp.status !== 0) return { status: 'copy-failed', stashPath: latestDump };
-
-  const restore = spawnSyncFn('docker', [
-    'exec', POSTGRES_CONTAINER,
-    'pg_restore', '-U', POSTGRES_USER, '-d', POSTGRES_DB,
-    '--data-only', '--disable-triggers', '--no-owner',
-    '--if-exists',
-    '/tmp/construct.dump',
-  ], { stdio: 'ignore' });
-
-  return {
-    status: restore.status === 0 ? 'restored' : 'restore-failed',
-    stashPath: latestDump,
-    exitCode: restore.status,
-  };
-}
-
-/**
- * Delete all stashed backups under ~/.construct/backups/postgres/.
- * Called by `construct storage reset` and uninstall flows.
- */
-export function purgeConstructDbStashes({ homeDir = os.homedir() } = {}) {
-  const stashDir = path.join(homeDir, '.construct', 'backups', 'postgres');
-  if (!fs.existsSync(stashDir)) return { status: 'ok', deletedCount: 0 };
-  const files = fs.readdirSync(stashDir).map((f) => path.join(stashDir, f));
-  for (const f of files) fs.rmSync(f, { force: true });
-  return { status: 'ok', deletedCount: files.length };
-}