@calltelemetry/cli 0.12.20 → 0.13.1

package/dist/lib/storage-report.js

@@ -0,0 +1,986 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import os from 'node:os';
+import { execa } from 'execa';
+import { getPaths } from './paths.js';
+import { formatDbSize, runBoundedQuery } from './db-probe.js';
+import { DB_NAME } from './db.js';
+import { redactSecrets } from './redact.js';
+export const STORAGE_REPORT_SCHEMA_VERSION = 1;
+const PURGE_TABLE_NAMES = [
+    'purge_table_configs',
+    'purge_audit_statuses',
+    'user_activity_logs',
+    'purge_table_failure_tracker',
+    'purge_dispatch_cursors',
+    'oban_jobs',
+];
+function clamp(value, min, max) {
+    if (!Number.isFinite(value))
+        return min;
+    return Math.min(max, Math.max(min, Math.round(value)));
+}
+export function normalizeStorageReportOptions(options = {}) {
+    return {
+        top: clamp(options.top ?? 50, 1, 500),
+        scanDepth: clamp(options.scanDepth ?? 2, 1, 8),
+        timeoutMs: clamp(options.timeoutMs ?? 30_000, 5_000, 120_000),
+    };
+}
+function pretty(bytes) {
+    return formatDbSize(Math.max(0, Number.isFinite(bytes) ? bytes : 0));
+}
+function numberValue(value) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function integerValue(value) {
+    const parsed = numberValue(value);
+    return parsed === null ? null : Math.trunc(parsed);
+}
+function booleanValue(value) {
+    if (value === true || value === 't' || value === 'true')
+        return true;
+    if (value === false || value === 'f' || value === 'false')
+        return false;
+    return null;
+}
+function stringValue(value) {
+    return value === null || value === undefined || value === '' ? null : String(value);
+}
+function quoteIdentifier(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+function quoteLiteral(value) {
+    return `'${value.replaceAll("'", "''")}'`;
+}
+async function runExternal(command, args, timeoutMs) {
+    try {
+        const result = await execa(command, args, {
+            timeout: timeoutMs,
+            forceKillAfterDelay: 1_000,
+            maxBuffer: 64 * 1024 * 1024,
+            reject: false,
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+        return {
+            stdout: result.stdout ?? '',
+            stderr: result.stderr ?? '',
+            exitCode: result.exitCode,
+            timedOut: result.timedOut === true,
+        };
+    }
+    catch (error) {
+        return {
+            stdout: error?.stdout ?? '',
+            stderr: error?.stderr ?? error?.message ?? String(error),
+            exitCode: error?.exitCode,
+            timedOut: error?.timedOut === true,
+        };
+    }
+}
+function parseDfOutput(output, path, inodeOutput) {
+    const usageLine = output.trim().split('\n').slice(1).find((line) => /\d+%/.test(line));
+    if (!usageLine)
+        throw new Error(`Could not parse disk usage for ${path}`);
+    const parts = usageLine.trim().split(/\s+/);
+    const capacityIndex = parts.findIndex((part) => /^\d+%$/.test(part));
+    if (capacityIndex < 3)
+        throw new Error(`Could not parse disk usage for ${path}`);
+    const blocks = numberValue(parts[capacityIndex - 3]);
+    const used = numberValue(parts[capacityIndex - 2]);
+    const available = numberValue(parts[capacityIndex - 1]);
+    const usedPercent = numberValue(parts[capacityIndex]?.replace('%', ''));
+    if (blocks === null || used === null || available === null || usedPercent === null) {
+        throw new Error(`Could not parse disk usage for ${path}`);
+    }
+    let inodeUsedPercent = null;
+    const inodeLine = inodeOutput?.trim().split('\n').slice(1).find((line) => /\d+%/.test(line));
+    const inodePercent = inodeLine?.match(/(\d+)%/);
+    if (inodePercent)
+        inodeUsedPercent = Number(inodePercent[1]);
+    return {
+        path,
+        filesystem: parts.slice(0, capacityIndex - 3).join(' ') || 'unknown',
+        mount: parts.slice(capacityIndex + 1).join(' ') || path,
+        sizeBytes: blocks * 1024,
+        usedBytes: used * 1024,
+        availableBytes: available * 1024,
+        usedPercent,
+        inodeUsedPercent,
+    };
+}
+export function parseDuOutput(output, limit) {
+    return output
+        .split('\n')
+        .map((line) => {
+        const match = line.match(/^\s*(\d+)\s+(.+)$/);
+        if (!match)
+            return null;
+        const bytes = Number(match[1]) * 1024;
+        return Number.isFinite(bytes) ? { path: match[2], bytes, pretty: pretty(bytes) } : null;
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, limit);
+}
+export function parseSizedPathOutput(output, limit) {
+    return output
+        .split('\n')
+        .map((line) => {
+        const tab = line.indexOf('\t');
+        if (tab <= 0)
+            return null;
+        const bytes = Number(line.slice(0, tab).trim());
+        const path = line.slice(tab + 1).trim();
+        return Number.isFinite(bytes) && path ? { path, bytes, pretty: pretty(bytes) } : null;
+    })
+        .filter((entry) => entry !== null)
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, limit);
+}
+async function collectFilesystems(options, warnings) {
+    const paths = getPaths();
+    const candidates = [
+        '/',
+        paths.installDir,
+        paths.postgresDataDir,
+        paths.backupDir,
+        paths.dbDumpsDir,
+        paths.certsDir,
+    ];
+    const unique = [...new Set(candidates)];
+    const records = [];
+    for (const path of unique) {
+        if (path !== '/' && !existsSync(path))
+            continue;
+        const usage = await runExternal('df', ['-Pk', path], options.timeoutMs);
+        const inode = await runExternal('df', ['-Pi', path], options.timeoutMs);
+        try {
+            records.push(parseDfOutput(usage.stdout, path, inode.stdout));
+            if (usage.timedOut || usage.exitCode !== 0) {
+                warnings.push(`df reported a non-zero result for ${path}`);
+            }
+        }
+        catch (error) {
+            warnings.push(`filesystem usage for ${path} unavailable: ${redactSecrets(String(error))}`);
+        }
+    }
+    return records;
+}
+function scanRoots(filesystems) {
+    const roots = [];
+    const seenFilesystems = new Set();
+    for (const filesystem of filesystems) {
+        if (seenFilesystems.has(filesystem.filesystem))
+            continue;
+        seenFilesystems.add(filesystem.filesystem);
+        roots.push(filesystem.path);
+    }
+    if (roots.length > 0)
+        return roots;
+    const paths = getPaths();
+    return [...new Set([
+            '/',
+            paths.installDir,
+            paths.postgresDataDir,
+            paths.backupDir,
+            paths.dbDumpsDir,
+            paths.certsDir,
+        ])].filter((path) => path === '/' || existsSync(path));
+}
+async function collectTopDirectories(options, roots, warnings) {
+    const byPath = new Map();
+    const depth = String(options.scanDepth);
+    for (const root of roots) {
+        let result = await runExternal('du', ['-x', '-k', '-d', depth, root], options.timeoutMs);
+        let entries = parseDuOutput(result.stdout, options.top);
+        if (entries.length === 0) {
+            result = await runExternal('du', ['-x', '-k', `--max-depth=${depth}`, root], options.timeoutMs);
+            entries = parseDuOutput(result.stdout, options.top);
+        }
+        for (const entry of entries)
+            byPath.set(entry.path, entry);
+        if (entries.length === 0) {
+            warnings.push(`top folder scan unavailable for ${root}${result.timedOut ? ' (timed out)' : ''}`);
+        }
+        else if (result.exitCode !== undefined && result.exitCode !== 0) {
+            warnings.push(`top folder scan for ${root} completed with permission or traversal errors`);
+        }
+    }
+    return [...byPath.values()].sort((a, b) => b.bytes - a.bytes).slice(0, options.top);
+}
+async function collectTopFiles(options, roots, warnings) {
+    const byPath = new Map();
+    for (const root of roots) {
+        const probes = [
+            ['find', [root, '-xdev', '-type', 'f', '-printf', '%s\\t%p\\n']],
+            ['find', [root, '-xdev', '-type', 'f', '-exec', 'stat', '-c', '%s\\t%n', '{}', '+']],
+            ['find', [root, '-xdev', '-type', 'f', '-exec', 'stat', '-f', '%z\\t%N', '{}', '+']],
+        ];
+        let found = false;
+        for (const [command, args] of probes) {
+            const result = await runExternal(command, args, options.timeoutMs);
+            const entries = parseSizedPathOutput(result.stdout, options.top);
+            if (entries.length > 0) {
+                for (const entry of entries)
+                    byPath.set(entry.path, entry);
+                found = true;
+                if (result.exitCode !== undefined && result.exitCode !== 0) {
+                    warnings.push(`top file scan for ${root} completed with permission or traversal errors`);
+                }
+                break;
+            }
+        }
+        if (!found)
+            warnings.push(`top file scan unavailable for ${root}`);
+    }
+    return [...byPath.values()].sort((a, b) => b.bytes - a.bytes).slice(0, options.top);
+}
+async function queryText(context, label, sql) {
+    try {
+        const raw = await runBoundedQuery(sql, context.options);
+        return raw || null;
+    }
+    catch (error) {
+        const reason = error?.reason ? ` (${error.reason})` : '';
+        context.warnings.push(`${label}: ${redactSecrets(error?.message ?? String(error))}${reason}`);
+        return null;
+    }
+}
+async function queryJson(context, label, sql) {
+    const raw = await queryText(context, label, sql);
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        context.warnings.push(`${label}: database returned invalid JSON (${redactSecrets(String(error))})`);
+        return null;
+    }
+}
+async function tableColumns(context, tableName) {
+    const rows = await queryJson(context, `${tableName} column inspection`, `SELECT COALESCE(jsonb_agg(jsonb_build_object('column_name', column_name) ORDER BY ordinal_position), '[]'::jsonb)
+       FROM information_schema.columns
+      WHERE table_schema = 'public' AND table_name = ${quoteLiteral(tableName)};`);
+    return rows ? new Set(rows.map((row) => row.column_name)) : null;
+}
+function optionalColumn(columns, alias, outputName, candidates, nullType) {
+    const column = candidates.find((candidate) => columns.has(candidate));
+    return column
+        ? `${quoteIdentifier(alias)}.${quoteIdentifier(column)} AS ${quoteIdentifier(outputName)}`
+        : `NULL::${nullType} AS ${quoteIdentifier(outputName)}`;
+}
+function relationMap(relations) {
+    return new Map(relations.map((relation) => [
+        `${relation.schemaName}.${relation.tableName}`,
+        relation,
+    ]));
+}
+const RELATION_QUERY = `
+SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.total_bytes DESC), '[]'::jsonb)
+FROM (
+  SELECT n.nspname AS schema_name,
+         c.relname AS table_name,
+         CASE c.relkind
+           WHEN 'r' THEN 'table'
+           WHEN 'p' THEN 'partitioned_table'
+           WHEN 'm' THEN 'materialized_view'
+           ELSE c.relkind::text
+         END AS relation_kind,
+         c.relispartition AS is_partition,
+         pg_total_relation_size(c.oid)::bigint AS total_bytes,
+         pg_table_size(c.oid)::bigint AS table_bytes,
+         pg_relation_size(c.oid)::bigint AS heap_bytes,
+         pg_indexes_size(c.oid)::bigint AS index_bytes,
+         GREATEST(pg_table_size(c.oid) - pg_relation_size(c.oid), 0)::bigint AS toast_bytes,
+         COALESCE(s.n_live_tup, 0)::bigint AS estimated_live_rows,
+         COALESCE(s.n_dead_tup, 0)::bigint AS estimated_dead_rows,
+         s.last_vacuum,
+         s.last_autovacuum,
+         s.last_analyze,
+         s.last_autoanalyze
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    LEFT JOIN pg_stat_all_tables s ON s.relid = c.oid
+   WHERE n.nspname NOT LIKE 'pg_%'
+     AND n.nspname <> 'information_schema'
+     AND c.relkind IN ('r', 'p', 'm')
+) x;`;
+const OLDEST_CANDIDATE_QUERY = `
+SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.schema_name, x.table_name), '[]'::jsonb)
+FROM (
+  SELECT DISTINCT ON (c.oid)
+         n.nspname AS schema_name,
+         c.relname AS table_name,
+         a.attname AS column_name
+    FROM pg_class c
+    JOIN pg_namespace n ON n.oid = c.relnamespace
+    JOIN pg_attribute a ON a.attrelid = c.oid
+   WHERE n.nspname NOT LIKE 'pg_%'
+     AND n.nspname <> 'information_schema'
+     AND c.relkind = 'r'
+     AND a.attnum > 0
+     AND NOT a.attisdropped
+     AND a.attname = ANY (ARRAY['occurred_at','inserted_at','recorded_at','created_at','captured_at','started_at','completed_at','updated_at'])
+     AND format_type(a.atttypid, a.atttypmod) = ANY (ARRAY['timestamp without time zone','timestamp with time zone','date'])
+     AND (
+       c.relname ILIKE ANY (ARRAY['%history%','%log%','%event%','%audit%','%purge%','%cdr%','%record%'])
+       OR c.relname = 'oban_jobs'
+     )
+   ORDER BY c.oid,
+            array_position(ARRAY['occurred_at','inserted_at','recorded_at','created_at','captured_at','started_at','completed_at','updated_at'], a.attname)
+) x;`;
+async function collectOldestTables(context, relations, limit) {
+    const candidates = await queryJson(context, 'oldest-record candidate discovery', OLDEST_CANDIDATE_QUERY);
+    if (!candidates || candidates.length === 0)
+        return [];
+    const relationSizes = relationMap(relations);
+    const prioritizedCandidates = [...candidates].sort((left, right) => {
+        const leftBytes = relationSizes.get(`${left.schema_name}.${left.table_name}`)?.totalBytes ?? 0;
+        const rightBytes = relationSizes.get(`${right.schema_name}.${right.table_name}`)?.totalBytes ?? 0;
+        return rightBytes - leftBytes
+            || left.schema_name.localeCompare(right.schema_name)
+            || left.table_name.localeCompare(right.table_name);
+    });
+    const selects = prioritizedCandidates.slice(0, limit).map((candidate) => {
+        const relation = relationSizes.get(`${candidate.schema_name}.${candidate.table_name}`);
+        const qualified = `${quoteIdentifier(candidate.schema_name)}.${quoteIdentifier(candidate.table_name)}`;
+        const column = quoteIdentifier(candidate.column_name);
+        return `SELECT ${quoteLiteral(candidate.schema_name)} AS schema_name,
+                   ${quoteLiteral(candidate.table_name)} AS table_name,
+                   ${quoteLiteral(candidate.column_name)} AS column_name,
+                   min(${column})::text AS oldest_at,
+                   max(${column})::text AS newest_at,
+                   ${relation?.totalBytes ?? 0}::bigint AS relation_bytes,
+                   ${relation?.estimatedLiveRows ?? 0}::bigint AS estimated_rows
+              FROM ${qualified}
+             WHERE ${column} IS NOT NULL`;
+    });
+    const rows = await queryJson(context, 'oldest-record timestamp scan', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.oldest_at NULLS LAST), '[]'::jsonb)
+       FROM (${selects.join('\nUNION ALL\n')}) x;`);
+    return (rows ?? []).map((row) => ({
+        schemaName: String(row.schema_name ?? ''),
+        tableName: String(row.table_name ?? ''),
+        columnName: String(row.column_name ?? ''),
+        oldestAt: stringValue(row.oldest_at),
+        newestAt: stringValue(row.newest_at),
+        relationBytes: integerValue(row.relation_bytes) ?? 0,
+        estimatedRows: integerValue(row.estimated_rows) ?? 0,
+    }));
+}
+function configStatus(row, nowMs) {
+    if (booleanValue(row.enabled) === false)
+        return 'disabled';
+    const lastSizeKb = numberValue(row.last_size_kb);
+    const sizeMaxKb = numberValue(row.size_max_kb);
+    const sizeHighKb = numberValue(row.size_threshold_high_kb);
+    if (lastSizeKb !== null && sizeMaxKb !== null && lastSizeKb > sizeMaxKb)
+        return 'over_max';
+    if (lastSizeKb !== null && sizeHighKb !== null && lastSizeKb > sizeHighKb)
+        return 'over_high';
+    const lastActivity = stringValue(row.last_evaluated_at) ?? stringValue(row.last_purge_at);
+    if (lastActivity) {
+        const ageMs = nowMs - Date.parse(lastActivity);
+        if (Number.isFinite(ageMs) && ageMs > 48 * 60 * 60 * 1000)
+            return 'stale';
+        return 'healthy';
+    }
+    return 'unknown';
+}
+async function collectPurgeConfigs(context, relations) {
+    const columns = await tableColumns(context, 'purge_table_configs');
+    if (!columns || columns.size === 0)
+        return [];
+    const fields = [
+        optionalColumn(columns, 'p', 'org_id', ['org_id'], 'bigint'),
+        optionalColumn(columns, 'p', 'table_name', ['table_name'], 'text'),
+        optionalColumn(columns, 'p', 'module_name', ['module_name'], 'text'),
+        optionalColumn(columns, 'p', 'enabled', ['enabled'], 'boolean'),
+        optionalColumn(columns, 'p', 'retention_days_max', ['retention_days_max', 'retention_days_target'], 'integer'),
+        optionalColumn(columns, 'p', 'retention_days_minimum', ['retention_days_minimum'], 'integer'),
+        optionalColumn(columns, 'p', 'retention_days_current', ['retention_days_current'], 'integer'),
+        optionalColumn(columns, 'p', 'size_threshold_high_kb', ['size_threshold_high_kb'], 'bigint'),
+        optionalColumn(columns, 'p', 'size_threshold_low_kb', ['size_threshold_low_kb'], 'bigint'),
+        optionalColumn(columns, 'p', 'size_max_kb', ['size_max_kb'], 'bigint'),
+        optionalColumn(columns, 'p', 'last_size_kb', ['last_size_kb'], 'bigint'),
+        optionalColumn(columns, 'p', 'last_record_count', ['last_record_count'], 'bigint'),
+        optionalColumn(columns, 'p', 'last_purge_at', ['last_purge_at'], 'timestamp'),
+        optionalColumn(columns, 'p', 'last_evaluated_at', ['last_evaluated_at'], 'timestamp'),
+        optionalColumn(columns, 'p', 'purge_strategy', ['purge_strategy'], 'text'),
+        optionalColumn(columns, 'p', 'total_purges', ['total_purges'], 'bigint'),
+        optionalColumn(columns, 'p', 'total_records_purged', ['total_records_purged'], 'bigint'),
+    ];
+    const rows = await queryJson(context, 'purge configuration status', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.table_name, x.org_id), '[]'::jsonb)
+       FROM (SELECT ${fields.join(', ')} FROM public.purge_table_configs p) x;`);
+    const relationSizes = relationMap(relations);
+    const now = Date.now();
+    return (rows ?? []).map((row) => {
+        const tableName = stringValue(row.table_name);
+        const relation = tableName ? relationSizes.get(`public.${tableName}`) : undefined;
+        return {
+            orgId: integerValue(row.org_id),
+            tableName,
+            moduleName: stringValue(row.module_name),
+            enabled: booleanValue(row.enabled),
+            status: configStatus(row, now),
+            retentionDaysMax: integerValue(row.retention_days_max),
+            retentionDaysMinimum: integerValue(row.retention_days_minimum),
+            retentionDaysCurrent: integerValue(row.retention_days_current),
+            sizeThresholdHighKb: integerValue(row.size_threshold_high_kb),
+            sizeThresholdLowKb: integerValue(row.size_threshold_low_kb),
+            sizeMaxKb: integerValue(row.size_max_kb),
+            lastSizeKb: integerValue(row.last_size_kb),
+            lastRecordCount: integerValue(row.last_record_count),
+            lastPurgeAt: stringValue(row.last_purge_at),
+            lastEvaluatedAt: stringValue(row.last_evaluated_at),
+            purgeStrategy: stringValue(row.purge_strategy),
+            totalPurges: integerValue(row.total_purges),
+            totalRecordsPurged: integerValue(row.total_records_purged),
+            relationBytes: relation?.totalBytes ?? null,
+        };
+    });
+}
+async function collectPurgeAuditStatus(context) {
+    const columns = await tableColumns(context, 'purge_audit_statuses');
+    if (!columns || columns.size === 0) {
+        return {
+            available: false,
+            rowCount: 0,
+            successRows: 0,
+            issueRows: 0,
+            issueCount: 0,
+            tablesAudited: 0,
+            tablesHealthy: 0,
+            totalDatabaseSizeKb: 0,
+            oldestAuditAt: null,
+            newestAuditAt: null,
+        };
+    }
+    const expressions = [
+        `count(*)::bigint AS row_count`,
+        columns.has('last_status') ? `count(*) FILTER (WHERE p."last_status" = 'success')::bigint AS success_rows` : `0::bigint AS success_rows`,
+        columns.has('last_status') ? `count(*) FILTER (WHERE p."last_status" <> 'success')::bigint AS issue_rows` : `0::bigint AS issue_rows`,
+        columns.has('issue_count') ? `COALESCE(sum(p."issue_count"), 0)::bigint AS issue_count` : `0::bigint AS issue_count`,
+        columns.has('tables_audited') ? `COALESCE(sum(p."tables_audited"), 0)::bigint AS tables_audited` : `0::bigint AS tables_audited`,
+        columns.has('tables_healthy') ? `COALESCE(sum(p."tables_healthy"), 0)::bigint AS tables_healthy` : `0::bigint AS tables_healthy`,
+        // This value is a database-wide snapshot repeated on each per-org audit row.
+        // Summing it would multiply the apparent database size by the org count.
+        columns.has('total_db_size_kb') ? `COALESCE(max(p."total_db_size_kb"), 0)::bigint AS total_database_size_kb` : `0::bigint AS total_database_size_kb`,
+        columns.has('last_audit_at') ? `min(p."last_audit_at")::text AS oldest_audit_at` : `NULL::text AS oldest_audit_at`,
+        columns.has('last_audit_at') ? `max(p."last_audit_at")::text AS newest_audit_at` : `NULL::text AS newest_audit_at`,
+    ];
+    const row = await queryJson(context, 'purge audit status', `SELECT ${expressions.join(', ')} FROM public.purge_audit_statuses p;`);
+    return {
+        available: row !== null,
+        rowCount: integerValue(row?.row_count) ?? 0,
+        successRows: integerValue(row?.success_rows) ?? 0,
+        issueRows: integerValue(row?.issue_rows) ?? 0,
+        issueCount: integerValue(row?.issue_count) ?? 0,
+        tablesAudited: integerValue(row?.tables_audited) ?? 0,
+        tablesHealthy: integerValue(row?.tables_healthy) ?? 0,
+        totalDatabaseSizeKb: integerValue(row?.total_database_size_kb) ?? 0,
+        oldestAuditAt: stringValue(row?.oldest_audit_at),
+        newestAuditAt: stringValue(row?.newest_audit_at),
+    };
+}
+function activityFilter(columns, alias) {
+    const predicates = [];
+    if (columns.has('action'))
+        predicates.push(`(${quoteIdentifier(alias)}."action" ILIKE '%purge%' OR ${quoteIdentifier(alias)}."action" ILIKE '%prune%')`);
+    if (columns.has('target_type'))
+        predicates.push(`(${quoteIdentifier(alias)}."target_type" ILIKE '%purge%' OR ${quoteIdentifier(alias)}."target_type" ILIKE '%prune%')`);
+    if (predicates.length === 0)
+        return null;
+    return `(${predicates.join(' OR ')})`;
+}
+async function collectPurgeHistory(context, limit) {
+    const columns = await tableColumns(context, 'user_activity_logs');
+    if (!columns || columns.size === 0)
+        return { summary: [], oldest: [] };
+    const filter = activityFilter(columns, 'l');
+    const timeColumn = ['inserted_at', 'created_at', 'updated_at'].find((column) => columns.has(column));
+    if (!filter || !timeColumn) {
+        context.warnings.push('purge history: required action/target and timestamp columns are unavailable');
+        return { summary: [], oldest: [] };
+    }
+    const payloadColumns = ['changes', 'metadata', 'error_message'].filter((column) => columns.has(column));
+    const payloadBytes = payloadColumns.length > 0
+        ? payloadColumns.map((column) => `COALESCE(pg_column_size(l.${quoteIdentifier(column)}), 0)`).join(' + ')
+        : '0';
+    const summary = await queryJson(context, 'purge history summary', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.record_count DESC), '[]'::jsonb)
+       FROM (
+         SELECT ${columns.has('action') ? 'l."action"' : 'NULL::text'} AS action,
+                ${columns.has('status') ? 'l."status"' : 'NULL::text'} AS status,
+                count(*)::bigint AS record_count,
+                min(l.${quoteIdentifier(timeColumn)})::text AS oldest_at,
+                max(l.${quoteIdentifier(timeColumn)})::text AS newest_at,
+                sum(${payloadBytes})::bigint AS payload_bytes
+           FROM public.user_activity_logs l
+          WHERE ${filter}
+          GROUP BY 1, 2
+       ) x;`);
+    const oldest = await queryJson(context, 'oldest purge history records', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.inserted_at ASC NULLS LAST), '[]'::jsonb)
+       FROM (
+         SELECT ${columns.has('id') ? 'l."id"::text' : 'NULL::text'} AS id,
+                ${columns.has('action') ? 'l."action"' : 'NULL::text'} AS action,
+                ${columns.has('status') ? 'l."status"' : 'NULL::text'} AS status,
+                l.${quoteIdentifier(timeColumn)}::text AS inserted_at,
+                COALESCE(pg_column_size(l), 0)::bigint AS record_bytes
+           FROM public.user_activity_logs l
+          WHERE ${filter}
+          ORDER BY l.${quoteIdentifier(timeColumn)} ASC
+          LIMIT ${limit}
+       ) x;`);
+    return {
+        summary: (summary ?? []).map((row) => ({
+            action: stringValue(row.action),
+            status: stringValue(row.status),
+            recordCount: integerValue(row.record_count) ?? 0,
+            oldestAt: stringValue(row.oldest_at),
+            newestAt: stringValue(row.newest_at),
+            payloadBytes: integerValue(row.payload_bytes) ?? 0,
+        })),
+        oldest: (oldest ?? []).map((row) => ({
+            id: stringValue(row.id),
+            action: stringValue(row.action),
+            status: stringValue(row.status),
+            insertedAt: stringValue(row.inserted_at),
+            recordBytes: integerValue(row.record_bytes) ?? 0,
+        })),
+    };
+}
+async function collectFailureStatus(context, limit) {
+    const columns = await tableColumns(context, 'purge_table_failure_tracker');
+    const unavailable = {
+        available: false,
+        rowCount: 0,
+        failingRows: 0,
+        totalConsecutiveFailures: 0,
+        maxConsecutiveFailures: 0,
+        oldestFailureAt: null,
+        newestFailureAt: null,
+        oldestFailures: [],
+    };
+    if (!columns || columns.size === 0)
+        return unavailable;
+    const required = ['org_id', 'table_name', 'consecutive_failures', 'last_failure_at', 'last_success_at', 'inserted_at'];
+    if (!required.every((column) => columns.has(column))) {
+        context.warnings.push('purge failure tracker: required status columns are unavailable');
+        return unavailable;
+    }
+    const summary = await queryJson(context, 'purge failure tracker status', `SELECT count(*)::bigint AS row_count,
+            count(*) FILTER (WHERE f."consecutive_failures" > 0)::bigint AS failing_rows,
+            COALESCE(sum(f."consecutive_failures"), 0)::bigint AS total_consecutive_failures,
+            COALESCE(max(f."consecutive_failures"), 0)::bigint AS max_consecutive_failures,
+            min(f."last_failure_at")::text AS oldest_failure_at,
+            max(f."last_failure_at")::text AS newest_failure_at
+       FROM public.purge_table_failure_tracker f;`);
+    const oldest = await queryJson(context, 'oldest purge failure records', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.last_failure_at ASC NULLS LAST), '[]'::jsonb)
+       FROM (
+         SELECT f."org_id"::bigint AS org_id,
+                f."table_name" AS table_name,
+                f."consecutive_failures"::bigint AS consecutive_failures,
+                f."last_failure_at"::text AS last_failure_at,
+                f."last_success_at"::text AS last_success_at,
+                COALESCE(pg_column_size(f), 0)::bigint AS record_bytes
+           FROM public.purge_table_failure_tracker f
+          WHERE f."consecutive_failures" > 0
+          ORDER BY f."last_failure_at" ASC NULLS LAST
+          LIMIT ${limit}
+       ) x;`);
+    return {
+        available: summary !== null,
+        rowCount: integerValue(summary?.row_count) ?? 0,
+        failingRows: integerValue(summary?.failing_rows) ?? 0,
+        totalConsecutiveFailures: integerValue(summary?.total_consecutive_failures) ?? 0,
+        maxConsecutiveFailures: integerValue(summary?.max_consecutive_failures) ?? 0,
+        oldestFailureAt: stringValue(summary?.oldest_failure_at),
+        newestFailureAt: stringValue(summary?.newest_failure_at),
+        oldestFailures: (oldest ?? []).map((row) => ({
+            orgId: integerValue(row.org_id),
+            tableName: stringValue(row.table_name),
+            consecutiveFailures: integerValue(row.consecutive_failures) ?? 0,
+            lastFailureAt: stringValue(row.last_failure_at),
+            lastSuccessAt: stringValue(row.last_success_at),
+            recordBytes: integerValue(row.record_bytes) ?? 0,
+        })),
+    };
+}
+async function collectDispatchStatus(context) {
+    const columns = await tableColumns(context, 'purge_dispatch_cursors');
+    const unavailable = {
+        available: false,
+        rowCount: 0,
+        coveredCount: 0,
+        totalTables: 0,
+        minNextOffset: null,
+        maxNextOffset: null,
+        oldestUpdatedAt: null,
+        newestUpdatedAt: null,
+    };
+    if (!columns || columns.size === 0)
+        return unavailable;
+    const summary = await queryJson(context, 'purge dispatch cursor status', `SELECT count(*)::bigint AS row_count,
+            COALESCE(sum(${columns.has('last_covered_count') ? 'c."last_covered_count"' : '0'}), 0)::bigint AS covered_count,
+            COALESCE(sum(${columns.has('last_total_tables') ? 'c."last_total_tables"' : '0'}), 0)::bigint AS total_tables,
+            ${columns.has('next_offset') ? 'min(c."next_offset")::bigint' : 'NULL::bigint'} AS min_next_offset,
+            ${columns.has('next_offset') ? 'max(c."next_offset")::bigint' : 'NULL::bigint'} AS max_next_offset,
+            ${columns.has('updated_at') ? 'min(c."updated_at")::text' : 'NULL::text'} AS oldest_updated_at,
+            ${columns.has('updated_at') ? 'max(c."updated_at")::text' : 'NULL::text'} AS newest_updated_at
+       FROM public.purge_dispatch_cursors c;`);
+    return {
+        available: summary !== null,
+        rowCount: integerValue(summary?.row_count) ?? 0,
+        coveredCount: integerValue(summary?.covered_count) ?? 0,
+        totalTables: integerValue(summary?.total_tables) ?? 0,
+        minNextOffset: integerValue(summary?.min_next_offset),
+        maxNextOffset: integerValue(summary?.max_next_offset),
+        oldestUpdatedAt: stringValue(summary?.oldest_updated_at),
+        newestUpdatedAt: stringValue(summary?.newest_updated_at),
+    };
+}
+async function collectOban(context, limit) {
+    const columns = await tableColumns(context, 'oban_jobs');
+    if (!columns || columns.size === 0)
+        return { summaries: [], oldest: [] };
+    const filters = [];
+    if (columns.has('queue'))
+        filters.push(`j."queue" ILIKE 'db_purge%'`);
+    if (columns.has('queue'))
+        filters.push(`j."queue" ILIKE '%partition%'`);
+    if (columns.has('worker'))
+        filters.push(`j."worker" ILIKE '%Purge%'`);
+    if (columns.has('worker'))
+        filters.push(`j."worker" ILIKE '%Prune%'`);
+    if (columns.has('worker'))
+        filters.push(`j."worker" ILIKE '%PartitionMaintenance%'`);
+    const timeColumns = ['attempted_at', 'scheduled_at', 'inserted_at', 'completed_at'].filter((column) => columns.has(column));
+    if (filters.length === 0 || timeColumns.length === 0) {
+        context.warnings.push('Oban purge status: required queue/worker and timestamp columns are unavailable');
+        return { summaries: [], oldest: [] };
+    }
+    const eventTime = `COALESCE(${timeColumns.map((column) => `j.${quoteIdentifier(column)}`).join(', ')})`;
+    const payloadColumns = ['args', 'errors'].filter((column) => columns.has(column));
+    const payloadBytes = payloadColumns.length > 0
+        ? payloadColumns.map((column) => `COALESCE(pg_column_size(j.${quoteIdentifier(column)}), 0)`).join(' + ')
+        : '0';
+    const filter = `(${filters.join(' OR ')})`;
+    const summaries = await queryJson(context, 'Oban purge queue status', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.job_count DESC), '[]'::jsonb)
+       FROM (
+         SELECT ${columns.has('queue') ? 'j."queue"' : 'NULL::text'} AS queue,
+                ${columns.has('state') ? 'j."state"' : 'NULL::text'} AS state,
+                count(*)::bigint AS job_count,
+                min(${eventTime})::text AS oldest_at,
+                max(${eventTime})::text AS newest_at,
+                sum((${payloadBytes})::bigint)::bigint AS payload_bytes
+           FROM public.oban_jobs j
+          WHERE ${filter}
+          GROUP BY 1, 2
+       ) x;`);
+    const oldest = await queryJson(context, 'oldest Oban purge jobs', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.event_at ASC NULLS LAST), '[]'::jsonb)
+       FROM (
+         SELECT ${columns.has('id') ? 'j."id"::bigint' : 'NULL::bigint'} AS id,
+                ${columns.has('queue') ? 'j."queue"' : 'NULL::text'} AS queue,
+                ${columns.has('state') ? 'j."state"' : 'NULL::text'} AS state,
+                ${columns.has('worker') ? 'j."worker"' : 'NULL::text'} AS worker,
+                ${columns.has('attempt') ? 'j."attempt"::integer' : 'NULL::integer'} AS attempts,
+                ${columns.has('max_attempts') ? 'j."max_attempts"::integer' : 'NULL::integer'} AS max_attempts,
+                ${eventTime}::text AS event_at,
+                COALESCE(pg_column_size(j), 0)::bigint AS record_bytes
+           FROM public.oban_jobs j
+          WHERE ${filter}
+          ORDER BY ${eventTime} ASC
+          LIMIT ${limit}
+       ) x;`);
+    return {
+        summaries: (summaries ?? []).map((row) => ({
+            queue: stringValue(row.queue),
+            state: stringValue(row.state),
+            jobCount: integerValue(row.job_count) ?? 0,
+            oldestAt: stringValue(row.oldest_at),
+            newestAt: stringValue(row.newest_at),
+            payloadBytes: integerValue(row.payload_bytes) ?? 0,
+        })),
+        oldest: (oldest ?? []).map((row) => ({
+            id: integerValue(row.id),
+            queue: stringValue(row.queue),
+            state: stringValue(row.state),
+            worker: stringValue(row.worker),
+            attempts: integerValue(row.attempts),
+            maxAttempts: integerValue(row.max_attempts),
+            eventAt: stringValue(row.event_at),
+            recordBytes: integerValue(row.record_bytes) ?? 0,
+        })),
+    };
+}
+async function collectPartitions(context) {
+    const rows = await queryJson(context, 'partition size summary', `SELECT COALESCE(jsonb_agg(to_jsonb(x) ORDER BY x.total_bytes DESC), '[]'::jsonb)
+       FROM (
+         SELECT pn.nspname AS schema_name,
+                parent.relname AS parent_table_name,
+                count(*)::bigint AS partition_count,
+                min(child.relname) AS oldest_partition,
+                max(child.relname) AS newest_partition,
+                sum(pg_total_relation_size(child.oid))::bigint AS total_bytes
+           FROM pg_inherits i
+           JOIN pg_class parent ON parent.oid = i.inhparent
+           JOIN pg_class child ON child.oid = i.inhrelid
+           JOIN pg_namespace pn ON pn.oid = parent.relnamespace
+          WHERE pn.nspname NOT LIKE 'pg_%'
+            AND pn.nspname <> 'information_schema'
+          GROUP BY pn.nspname, parent.relname
+       ) x;`);
+    return (rows ?? []).map((row) => ({
+        schemaName: String(row.schema_name ?? ''),
+        parentTableName: String(row.parent_table_name ?? ''),
+        partitionCount: integerValue(row.partition_count) ?? 0,
+        oldestPartition: stringValue(row.oldest_partition),
+        newestPartition: stringValue(row.newest_partition),
+        totalBytes: integerValue(row.total_bytes) ?? 0,
+    }));
+}
+async function collectDatabase(options, warnings) {
+    const statementTimeoutMs = Math.max(4_000, Math.min(options.timeoutMs - 1_000, 60_000));
+    const context = {
+        options: {
+            timeoutMs: options.timeoutMs,
+            statementTimeoutMs,
+            lockTimeoutMs: 2_000,
+            connectTimeoutS: 5,
+            tuplesOnly: true,
+        },
+        warnings,
+    };
+    const totalRaw = await queryText(context, 'database total size', 'SELECT pg_database_size(current_database())::bigint;');
+    const totalBytes = integerValue(totalRaw);
+    const relationRows = await queryJson(context, 'relation size inventory', RELATION_QUERY);
+    const relations = (relationRows ?? []).map((row) => ({
+        schemaName: String(row.schema_name ?? ''),
+        tableName: String(row.table_name ?? ''),
+        relationKind: String(row.relation_kind ?? ''),
+        isPartition: Boolean(row.is_partition),
+        totalBytes: integerValue(row.total_bytes) ?? 0,
+        tableBytes: integerValue(row.table_bytes) ?? 0,
+        heapBytes: integerValue(row.heap_bytes) ?? 0,
+        indexBytes: integerValue(row.index_bytes) ?? 0,
+        toastBytes: integerValue(row.toast_bytes) ?? 0,
+        estimatedLiveRows: integerValue(row.estimated_live_rows) ?? 0,
+        estimatedDeadRows: integerValue(row.estimated_dead_rows) ?? 0,
+        lastVacuum: stringValue(row.last_vacuum),
+        lastAutovacuum: stringValue(row.last_autovacuum),
+        lastAnalyze: stringValue(row.last_analyze),
+        lastAutoanalyze: stringValue(row.last_autoanalyze),
+    }));
+    const oldestTables = await collectOldestTables(context, relations, options.top);
+    const nonSystemRelationBytes = relations.reduce((sum, relation) => sum + relation.totalBytes, 0);
+    return {
+        name: DB_NAME,
+        totalBytes,
+        nonSystemRelationBytes: relationRows ? nonSystemRelationBytes : null,
+        relationCount: relationRows ? relations.length : null,
+        relations,
+        oldestTables,
+        warnings: [...context.warnings],
+    };
+}
+async function collectPurge(options, relations, warnings) {
+    const statementTimeoutMs = Math.max(4_000, Math.min(options.timeoutMs - 1_000, 60_000));
+    const context = {
+        options: {
+            timeoutMs: options.timeoutMs,
+            statementTimeoutMs,
+            lockTimeoutMs: 2_000,
+            connectTimeoutS: 5,
+            tuplesOnly: true,
+        },
+        warnings,
+    };
+    const configs = await collectPurgeConfigs(context, relations);
+    const auditStatus = await collectPurgeAuditStatus(context);
+    const history = await collectPurgeHistory(context, options.top);
+    const failureStatus = await collectFailureStatus(context, options.top);
+    const dispatchStatus = await collectDispatchStatus(context);
+    const oban = await collectOban(context, options.top);
+    const partitions = await collectPartitions(context);
+    return {
+        configs,
+        auditStatus,
+        historySummary: history.summary,
+        oldestHistory: history.oldest,
+        failureStatus,
+        dispatchStatus,
+        obanQueues: oban.summaries,
+        oldestObanJobs: oban.oldest,
+        partitions,
+        warnings: [...context.warnings],
+    };
+}
+export async function buildStorageReport(options = {}) {
+    const normalized = normalizeStorageReportOptions(options);
+    const paths = getPaths();
+    const scanWarnings = [];
+    const filesystemWarnings = [];
+    const databaseWarnings = [];
+    const purgeWarnings = [];
+    const filesystems = await collectFilesystems(normalized, filesystemWarnings);
+    const roots = scanRoots(filesystems);
+    const topDirectories = await collectTopDirectories(normalized, roots, scanWarnings);
+    const topFiles = await collectTopFiles(normalized, roots, scanWarnings);
+    const database = await collectDatabase(normalized, databaseWarnings);
+    const purge = await collectPurge(normalized, database.relations, purgeWarnings);
+    const warnings = [
+        ...filesystemWarnings,
+        ...scanWarnings,
+        ...databaseWarnings,
+        ...purgeWarnings,
+    ];
+    return {
+        schemaVersion: STORAGE_REPORT_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        hostname: os.hostname(),
+        installDir: paths.installDir,
+        scan: {
+            root: '/',
+            roots,
+            filesystemOnly: true,
+            topLimit: normalized.top,
+            maxDepth: normalized.scanDepth,
+            warnings: scanWarnings,
+        },
+        filesystems,
+        topDirectories,
+        topFiles,
+        database,
+        purge,
+        warnings,
+    };
+}
+function line(label, value) {
+    return `  ${label.padEnd(26)} ${value}`;
+}
+function optionalDate(value) {
+    return value ?? 'unavailable';
+}
+export function renderStorageReportText(report) {
+    const lines = [];
+    lines.push('CallTelemetry storage and database report');
+    lines.push(`Generated: ${report.generatedAt}  Host: ${report.hostname}`);
+    lines.push(`Install:  ${report.installDir}`);
+    lines.push('Read-only report: no rows deleted, purged, vacuumed, or changed.');
+    lines.push('');
+    lines.push('Filesystem utilization');
+    if (report.filesystems.length === 0)
+        lines.push('  unavailable');
+    for (const fs of report.filesystems) {
+        lines.push(line(fs.path, `${fs.usedPercent}% used, ${pretty(fs.usedBytes)} / ${pretty(fs.sizeBytes)}, ${pretty(fs.availableBytes)} free`));
+        lines.push(line('filesystem', `${fs.filesystem} mounted at ${fs.mount}; inodes ${fs.inodeUsedPercent === null ? 'unavailable' : `${fs.inodeUsedPercent}% used`}`));
+    }
+    lines.push('');
+    lines.push(`Top folders (top ${report.scan.topLimit}, same filesystem, depth ${report.scan.maxDepth})`);
+    if (report.topDirectories.length === 0)
+        lines.push('  unavailable');
+    for (const entry of report.topDirectories)
+        lines.push(line(pretty(entry.bytes), entry.path));
+    lines.push('');
+    lines.push(`Top files (top ${report.scan.topLimit}, same filesystem)`);
+    if (report.topFiles.length === 0)
+        lines.push('  unavailable');
+    for (const entry of report.topFiles)
+        lines.push(line(pretty(entry.bytes), entry.path));
+    lines.push('');
+    lines.push('Database relation utilization');
+    lines.push(line('database total', report.database.totalBytes === null ? 'unavailable' : `${pretty(report.database.totalBytes)} (${report.database.totalBytes} bytes)`));
+    lines.push(line('non-system relations', report.database.nonSystemRelationBytes === null ? 'unavailable' : `${pretty(report.database.nonSystemRelationBytes)} (${report.database.nonSystemRelationBytes} bytes)`));
+    lines.push(line('relations', report.database.relationCount === null ? 'unavailable' : String(report.database.relationCount)));
+    for (const relation of report.database.relations.slice(0, report.scan.topLimit)) {
+        const name = `${relation.schemaName}.${relation.tableName}${relation.isPartition ? ' [partition]' : ''}`;
+        lines.push(line(name, `total ${pretty(relation.totalBytes)}; heap ${pretty(relation.heapBytes)}; indexes ${pretty(relation.indexBytes)}; toast ${pretty(relation.toastBytes)}; live/dead ${relation.estimatedLiveRows}/${relation.estimatedDeadRows}`));
+    }
+    lines.push('');
+    lines.push('Oldest timestamp-bearing tables');
+    if (report.database.oldestTables.length === 0)
+        lines.push('  unavailable');
+    for (const row of report.database.oldestTables) {
+        lines.push(line(`${row.schemaName}.${row.tableName}.${row.columnName}`, `oldest ${optionalDate(row.oldestAt)}; newest ${optionalDate(row.newestAt)}; relation ${pretty(row.relationBytes)}; est rows ${row.estimatedRows}`));
+    }
+    lines.push('');
+    lines.push('Purge / prune status');
+    lines.push(line('configured rows', String(report.purge.configs.length)));
+    for (const config of report.purge.configs.slice(0, report.scan.topLimit)) {
+        const name = `${config.tableName ?? 'unknown'}${config.orgId === null ? '' : ` (org ${config.orgId})`}`;
+        const size = config.lastSizeKb === null ? 'size unavailable' : `last ${pretty(config.lastSizeKb * 1024)}`;
+        lines.push(line(name, `${config.status}; ${size}; last purge ${optionalDate(config.lastPurgeAt)}; last evaluation ${optionalDate(config.lastEvaluatedAt)}`));
+    }
+    const audit = report.purge.auditStatus;
+    lines.push(line('audit status', audit.available ? `${audit.successRows} success, ${audit.issueRows} issues, ${audit.issueCount} issue(s); newest ${optionalDate(audit.newestAuditAt)}` : 'unavailable'));
+    lines.push(line('audit DB size', `${pretty(audit.totalDatabaseSizeKb * 1024)}; tables audited/healthy ${audit.tablesAudited}/${audit.tablesHealthy}`));
+    lines.push('Purge / prune history by action/status');
+    if (report.purge.historySummary.length === 0)
+        lines.push('  unavailable or no purge/prune audit records');
+    for (const row of report.purge.historySummary) {
+        lines.push(line(`${row.action ?? 'unknown'} / ${row.status ?? 'unknown'}`, `${row.recordCount} records; ${pretty(row.payloadBytes)} payload; oldest ${optionalDate(row.oldestAt)}; newest ${optionalDate(row.newestAt)}`));
+    }
+    lines.push('Oldest purge history records');
+    if (report.purge.oldestHistory.length === 0)
+        lines.push('  unavailable or none');
+    for (const row of report.purge.oldestHistory) {
+        lines.push(line(row.insertedAt ?? 'unknown', `${row.action ?? 'unknown'} / ${row.status ?? 'unknown'}; ${pretty(row.recordBytes)} record; id ${row.id ?? 'unavailable'}`));
+    }
+    const failures = report.purge.failureStatus;
+    lines.push('Purge failure tracker');
+    lines.push(line('failure status', failures.available ? `${failures.failingRows}/${failures.rowCount} rows failing; total consecutive failures ${failures.totalConsecutiveFailures}; max ${failures.maxConsecutiveFailures}` : 'unavailable'));
+    lines.push(line('failure window', `oldest ${optionalDate(failures.oldestFailureAt)}; newest ${optionalDate(failures.newestFailureAt)}`));
+    for (const row of failures.oldestFailures) {
+        lines.push(line(row.lastFailureAt ?? 'unknown', `${row.tableName ?? 'unknown'} (org ${row.orgId ?? 'unknown'}); consecutive ${row.consecutiveFailures}; ${pretty(row.recordBytes)} record`));
+    }
+    const dispatch = report.purge.dispatchStatus;
+    lines.push('Purge dispatch cursors');
+    lines.push(line('dispatch status', dispatch.available ? `${dispatch.rowCount} rows; covered ${dispatch.coveredCount}; total tables ${dispatch.totalTables}; offset ${dispatch.minNextOffset ?? 'unknown'}..${dispatch.maxNextOffset ?? 'unknown'}` : 'unavailable'));
+    lines.push(line('dispatch window', `oldest update ${optionalDate(dispatch.oldestUpdatedAt)}; newest ${optionalDate(dispatch.newestUpdatedAt)}`));
+    lines.push('Oban purge/prune queues');
+    if (report.purge.obanQueues.length === 0)
+        lines.push('  unavailable or no matching jobs');
+    for (const row of report.purge.obanQueues) {
+        lines.push(line(`${row.queue ?? 'unknown'} / ${row.state ?? 'unknown'}`, `${row.jobCount} jobs; ${pretty(row.payloadBytes)} payload; oldest ${optionalDate(row.oldestAt)}; newest ${optionalDate(row.newestAt)}`));
+    }
+    lines.push('Oldest matching Oban jobs');
+    for (const row of report.purge.oldestObanJobs) {
+        lines.push(line(row.eventAt ?? 'unknown', `${row.queue ?? 'unknown'} / ${row.state ?? 'unknown'} / ${row.worker ?? 'unknown'}; ${pretty(row.recordBytes)} record; id ${row.id ?? 'unavailable'}`));
+    }
+    lines.push('Partition utilization');
+    if (report.purge.partitions.length === 0)
+        lines.push('  no partitioned tables found or unavailable');
+    for (const row of report.purge.partitions) {
+        lines.push(line(`${row.schemaName}.${row.parentTableName}`, `${row.partitionCount} partitions; ${pretty(row.totalBytes)}; ${row.oldestPartition ?? 'unknown'} .. ${row.newestPartition ?? 'unknown'}`));
+    }
+    if (report.warnings.length > 0) {
+        lines.push('');
+        lines.push('Warnings');
+        for (const warning of [...new Set(report.warnings)])
+            lines.push(`  - ${warning}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export async function writeStorageReportJson(path, report) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(report, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+}
+export async function runStorageReportCommand(options = {}) {
+    const report = await buildStorageReport(options);
+    if (options.jsonPath) {
+        await writeStorageReportJson(options.jsonPath, report);
+        console.log(`Storage report written: ${options.jsonPath}`);
+        if (report.warnings.length > 0)
+            console.log(`Warnings: ${new Set(report.warnings).size}`);
+        return;
+    }
+    console.log(renderStorageReportText(report));
+}
+export const PURGE_REPORT_TABLES = PURGE_TABLE_NAMES;
+//# sourceMappingURL=storage-report.js.map