oopsdb 1.0.0

package/dist/commands/restore.js

@@ -0,0 +1,130 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreCommand = restoreCommand;
+const inquirer = __importStar(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const dumper_1 = require("../utils/dumper");
+const preflight_1 = require("../utils/preflight");
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+async function restoreCommand() {
+    const config = (0, config_1.loadConfig)();
+    if (!config) {
+        console.log(chalk_1.default.red('\n  No config found. Run `oopsdb init` first.\n'));
+        process.exit(1);
+    }
+    const snapshots = (0, dumper_1.listSnapshots)();
+    if (snapshots.length === 0) {
+        console.log(chalk_1.default.yellow('\n  No snapshots found. Run `oopsdb snapshot` or `oopsdb watch` first.\n'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.bold('\n  OopsDB Restore\n'));
+    console.log(chalk_1.default.gray(`  Database: ${config.db.type} - ${config.db.database}\n`));
+    // Pre-flight: check that restore tool is available
+    const toolsOk = await (0, preflight_1.preflightCheck)(config.db.type, 'restore');
+    if (!toolsOk) {
+        console.log(chalk_1.default.red('\n  Missing required database tools. Install them and try again.\n'));
+        process.exit(1);
+    }
+    console.log();
+    // Show the last 10 snapshots
+    const recentSnapshots = snapshots.slice(0, 10);
+    const { selectedSnapshot } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'selectedSnapshot',
+            message: 'Which snapshot do you want to restore?',
+            choices: recentSnapshots.map((s, i) => ({
+                name: `${i === 0 ? '(latest) ' : ''}${s.time.toLocaleString()} - ${timeAgo(s.time)} - ${formatSize(s.size)}`,
+                value: s.file,
+            })),
+        },
+    ]);
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk_1.default.yellow('This will overwrite your current database. Are you sure?'),
+            default: false,
+        },
+    ]);
+    if (!confirm) {
+        console.log(chalk_1.default.gray('\n  Restore cancelled.\n'));
+        return;
+    }
+    // Take a safety snapshot before restoring
+    const safetySpinner = (0, ora_1.default)('Taking safety snapshot of current state...').start();
+    try {
+        await (0, dumper_1.createSnapshot)(config.db);
+        safetySpinner.succeed('Safety snapshot saved (just in case)');
+    }
+    catch {
+        safetySpinner.warn('Could not take safety snapshot, proceeding anyway');
+    }
+    // Restore
+    const restoreSpinner = (0, ora_1.default)('Restoring database...').start();
+    try {
+        await (0, dumper_1.restoreSnapshot)(config.db, selectedSnapshot);
+        restoreSpinner.succeed('Database restored successfully!');
+        console.log(chalk_1.default.green('\n  Your database has been rolled back. Crisis averted!\n'));
+    }
+    catch (err) {
+        restoreSpinner.fail(`Restore failed: ${err.message}`);
+        console.log(chalk_1.default.red('\n  The restore did not complete. Your database may be in a partial state.'));
+        console.log(chalk_1.default.yellow('  A safety snapshot was taken before the restore attempt.\n'));
+        process.exit(1);
+    }
+}

package/dist/commands/secure.d.ts

@@ -0,0 +1,4 @@
+export declare function secureCommand(options: {
+    push?: boolean;
+    status?: boolean;
+}): Promise<void>;

package/dist/commands/secure.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.secureCommand = secureCommand;
+const chalk_1 = __importDefault(require("chalk"));
+async function secureCommand(options) {
+    console.log(chalk_1.default.bold('\n  OopsDB Secure'));
+    console.log(chalk_1.default.gray('  Immutable cloud backups that even a rogue AI can\'t delete.\n'));
+    console.log(chalk_1.default.yellow('  Coming Soon!'));
+    console.log(chalk_1.default.white('  We are currently putting the finishing touches on our secure cloud backup infrastructure.'));
+    console.log(chalk_1.default.gray('  Follow us on GitHub for updates: ') + chalk_1.default.cyan('https://github.com/pintayo/oopsdb\n'));
+}
+// ─── Utilities ──────────────────────────────────────────────────────────────
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/snapshot.d.ts

@@ -0,0 +1 @@
+export declare function snapshotCommand(): Promise<void>;

package/dist/commands/snapshot.js

@@ -0,0 +1,73 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snapshotCommand = snapshotCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const dumper_1 = require("../utils/dumper");
+const preflight_1 = require("../utils/preflight");
+const fs = __importStar(require("fs"));
+async function snapshotCommand() {
+    const config = (0, config_1.loadConfig)();
+    if (!config) {
+        console.log(chalk_1.default.red('\n  No config found. Run `oopsdb init` first.\n'));
+        process.exit(1);
+    }
+    console.log(chalk_1.default.bold('\n  OopsDB Manual Snapshot\n'));
+    console.log(chalk_1.default.gray(`  Database: ${config.db.type} - ${config.db.database}\n`));
+    // Pre-flight: check that dump tool is available
+    const toolsOk = await (0, preflight_1.preflightCheck)(config.db.type, 'dump');
+    if (!toolsOk) {
+        console.log(chalk_1.default.red('\n  Missing required database tools. Install them and try again.\n'));
+        process.exit(1);
+    }
+    console.log();
+    const spinner = (0, ora_1.default)('Taking snapshot...').start();
+    try {
+        const file = await (0, dumper_1.createSnapshot)(config.db);
+        const sizeKB = Math.round(fs.statSync(file).size / 1024);
+        spinner.succeed(`Snapshot saved: ${file} (${sizeKB} KB)`);
+        console.log(chalk_1.default.green('\n  Done! Run `oopsdb restore` if you need to roll back.\n'));
+    }
+    catch (err) {
+        spinner.fail(`Snapshot failed: ${err.message}`);
+        console.log(chalk_1.default.yellow('\n  Tip: Make sure your database tools are installed and the database is running.\n'));
+        process.exit(1);
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../utils/config");
+const dumper_1 = require("../utils/dumper");
+const path = __importStar(require("path"));
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function timeAgo(date) {
+    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86400)}d ago`;
+}
+async function statusCommand() {
+    const config = (0, config_1.loadConfig)();
+    if (!config) {
+        console.log(chalk_1.default.red('\n  No config found. Run `oopsdb init` first.\n'));
+        process.exit(1);
+    }
+    const snapshots = (0, dumper_1.listSnapshots)();
+    console.log(chalk_1.default.bold('\n  OopsDB Status\n'));
+    console.log(chalk_1.default.gray('  Database'));
+    const typeLabel = config.db.supabase ? 'supabase (postgres)' : config.db.type;
+    console.log(`    Type:     ${chalk_1.default.cyan(typeLabel)}`);
+    console.log(`    Name:     ${chalk_1.default.cyan(config.db.database)}`);
+    if (config.db.host) {
+        console.log(`    Host:     ${chalk_1.default.cyan(config.db.host + ':' + config.db.port)}`);
+    }
+    console.log(`    Since:    ${chalk_1.default.cyan(new Date(config.createdAt).toLocaleDateString())}`);
+    console.log();
+    console.log(chalk_1.default.gray('  Backups'));
+    console.log(`    Location: ${chalk_1.default.cyan((0, config_1.getBackupsDir)())}`);
+    console.log(`    Total:    ${chalk_1.default.cyan(String(snapshots.length))} snapshot(s)`);
+    if (snapshots.length > 0) {
+        const totalSize = snapshots.reduce((sum, s) => sum + s.size, 0);
+        console.log(`    Size:     ${chalk_1.default.cyan(formatSize(totalSize))}`);
+        console.log(`    Latest:   ${chalk_1.default.cyan(timeAgo(snapshots[0].time))} (${snapshots[0].time.toLocaleString()})`);
+        console.log(`    Oldest:   ${chalk_1.default.cyan(timeAgo(snapshots[snapshots.length - 1].time))} (${snapshots[snapshots.length - 1].time.toLocaleString()})`);
+        console.log(chalk_1.default.gray('\n  Recent Snapshots'));
+        snapshots.slice(0, 5).forEach((s, i) => {
+            const name = path.basename(s.file);
+            const marker = i === 0 ? chalk_1.default.green(' (latest)') : '';
+            console.log(`    ${chalk_1.default.gray(`${i + 1}.`)} ${name} - ${formatSize(s.size)} - ${timeAgo(s.time)}${marker}`);
+        });
+        if (snapshots.length > 5) {
+            console.log(chalk_1.default.gray(`    ... and ${snapshots.length - 5} more`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow('\n    No snapshots yet. Run `oopsdb watch` or `oopsdb snapshot` to start.'));
+    }
+    console.log();
+}

package/dist/commands/watch.d.ts

@@ -0,0 +1,3 @@
+export declare function watchCommand(options: {
+    interval: string;
+}): Promise<void>;

package/dist/commands/watch.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchCommand = watchCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const config_1 = require("../utils/config");
+const dumper_1 = require("../utils/dumper");
+const preflight_1 = require("../utils/preflight");
+async function watchCommand(options) {
+    const config = (0, config_1.loadConfig)();
+    if (!config) {
+        console.log(chalk_1.default.red('\n  No config found. Run `oopsdb init` first.\n'));
+        process.exit(1);
+    }
+    // Pre-flight: check that dump tool is available
+    console.log(chalk_1.default.gray('\n  Checking for required tools...\n'));
+    const toolsOk = await (0, preflight_1.preflightCheck)(config.db.type, 'dump');
+    if (!toolsOk) {
+        console.log(chalk_1.default.red('\n  Missing required database tools. Install them and try again.\n'));
+        process.exit(1);
+    }
+    const intervalMinutes = parseInt(options.interval, 10);
+    if (isNaN(intervalMinutes) || intervalMinutes < 1) {
+        console.log(chalk_1.default.red('\n  Interval must be at least 1 minute.\n'));
+        process.exit(1);
+    }
+    const intervalMs = intervalMinutes * 60 * 1000;
+    console.log(chalk_1.default.bold('\n  OopsDB Watch Mode\n'));
+    console.log(chalk_1.default.gray(`  Database: ${config.db.type} - ${config.db.database}`));
+    console.log(chalk_1.default.gray(`  Interval: every ${intervalMinutes} minute(s)`));
+    console.log(chalk_1.default.gray('  Press Ctrl+C to stop.\n'));
+    // Take an immediate snapshot on start
+    await takeSnapshotWithLog(config.db);
+    // Set up the interval
+    const timer = setInterval(async () => {
+        await takeSnapshotWithLog(config.db);
+    }, intervalMs);
+    // Clean exit on Ctrl+C
+    process.on('SIGINT', () => {
+        clearInterval(timer);
+        const snapshots = (0, dumper_1.listSnapshots)();
+        console.log(chalk_1.default.bold(`\n\n  Watch stopped. ${snapshots.length} total snapshot(s) saved.\n`));
+        process.exit(0);
+    });
+}
+async function takeSnapshotWithLog(dbConfig) {
+    const spinner = (0, ora_1.default)(`[${new Date().toLocaleTimeString()}] Taking snapshot...`).start();
+    try {
+        const file = await (0, dumper_1.createSnapshot)(dbConfig);
+        const sizeKB = Math.round(require('fs').statSync(file).size / 1024);
+        spinner.succeed(`[${new Date().toLocaleTimeString()}] Snapshot saved (${sizeKB} KB)`);
+    }
+    catch (err) {
+        spinner.fail(`[${new Date().toLocaleTimeString()}] Snapshot failed: ${err.message}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const watch_1 = require("./commands/watch");
+const restore_1 = require("./commands/restore");
+const status_1 = require("./commands/status");
+const snapshot_1 = require("./commands/snapshot");
+const secure_1 = require("./commands/secure");
+const clean_1 = require("./commands/clean");
+const activate_1 = require("./commands/activate");
+// Read version from package.json at runtime
+const pkg = require('../package.json');
+const program = new commander_1.Command();
+program
+    .name('oopsdb')
+    .description('Don\'t let AI nuke your database. Auto-backup and 1-click restore.')
+    .version(pkg.version);
+program
+    .command('init')
+    .description('Set up database connection for backups')
+    .action(init_1.initCommand);
+program
+    .command('watch')
+    .description('Start watching and backing up your database at intervals')
+    .option('-i, --interval <minutes>', 'Backup interval in minutes', '5')
+    .action(watch_1.watchCommand);
+program
+    .command('snapshot')
+    .description('Take a one-time snapshot right now')
+    .action(snapshot_1.snapshotCommand);
+program
+    .command('restore')
+    .description('Restore your database from a backup')
+    .action(restore_1.restoreCommand);
+program
+    .command('status')
+    .description('Show backup status and recent snapshots')
+    .action(status_1.statusCommand);
+program
+    .command('secure')
+    .description('Immutable cloud backups — tamper-proof, AI-proof')
+    .option('--push', 'Push latest snapshot to immutable cloud storage')
+    .option('--status', 'Show Secure activation status')
+    .action(secure_1.secureCommand);
+program
+    .command('activate <license-key>')
+    .description('Activate a Pro or Secure license key')
+    .action(activate_1.activateCommand);
+program
+    .command('deactivate')
+    .description('Deactivate your license on this machine')
+    .action(activate_1.deactivateCommand);
+program
+    .command('license')
+    .description('Show current license status and plan')
+    .action(activate_1.licenseStatusCommand);
+program
+    .command('clean')
+    .description('Remove all OopsDB data (.oopsdb/) from current project')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(clean_1.cleanCommand);
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+    console.log('\n  \x1b[35mNew:\x1b[0m \x1b[1moopsdb secure\x1b[0m — Immutable cloud backups that even a rogue AI can\'t delete.');
+    console.log('  \x1b[90mLearn more:\x1b[0m \x1b[36mhttps://oopsdb.com/secure\x1b[0m\n');
+}

package/dist/utils/config.d.ts

@@ -0,0 +1,23 @@
+export interface DbConfig {
+    type: 'postgres' | 'mysql' | 'sqlite';
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    database: string;
+    connectionString?: string;
+    /** When true, uses Supabase-specific pg_dump flags (--no-owner, --no-privileges, --no-subscriptions) */
+    supabase?: boolean;
+    /** SSL mode for Postgres connections (e.g., 'require', 'verify-full') */
+    sslmode?: string;
+}
+export interface OopsConfig {
+    db: DbConfig;
+    createdAt: string;
+}
+export declare function ensureConfigDir(): void;
+export declare function saveConfig(config: OopsConfig): void;
+export declare function loadConfig(): OopsConfig | null;
+export declare function getBackupsDir(): string;
+export declare function getConfigDir(): string;
+export declare function getEncryptionKey(): Buffer;

package/dist/utils/config.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureConfigDir = ensureConfigDir;
+exports.saveConfig = saveConfig;
+exports.loadConfig = loadConfig;
+exports.getBackupsDir = getBackupsDir;
+exports.getConfigDir = getConfigDir;
+exports.getEncryptionKey = getEncryptionKey;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const CONFIG_DIR = path.join(process.cwd(), '.oopsdb');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const BACKUPS_DIR = path.join(CONFIG_DIR, 'backups');
+// Simple encryption using a machine-local key derived from hostname + username
+const ENCRYPTION_KEY = crypto
+    .createHash('sha256')
+    .update(`oopsdb-${process.env.USER || 'default'}-${require('os').hostname()}`)
+    .digest();
+function encrypt(text) {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv('aes-256-cbc', ENCRYPTION_KEY, iv);
+    let encrypted = cipher.update(text, 'utf8', 'hex');
+    encrypted += cipher.final('hex');
+    return iv.toString('hex') + ':' + encrypted;
+}
+function decrypt(text) {
+    const [ivHex, encrypted] = text.split(':');
+    const iv = Buffer.from(ivHex, 'hex');
+    const decipher = crypto.createDecipheriv('aes-256-cbc', ENCRYPTION_KEY, iv);
+    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+    decrypted += decipher.final('utf8');
+    return decrypted;
+}
+function ensureConfigDir() {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        if (!fs.existsSync(BACKUPS_DIR)) {
+            fs.mkdirSync(BACKUPS_DIR, { recursive: true });
+        }
+    }
+    catch (err) {
+        if (err.code === 'EACCES') {
+            throw new Error(`Permission denied creating ${CONFIG_DIR}. Check directory permissions.`);
+        }
+        if (err.code === 'ENOSPC') {
+            throw new Error('Disk full. Free up space and try again.');
+        }
+        throw err;
+    }
+}
+function saveConfig(config) {
+    ensureConfigDir();
+    const encrypted = encrypt(JSON.stringify(config));
+    fs.writeFileSync(CONFIG_FILE, encrypted, 'utf8');
+}
+function loadConfig() {
+    if (!fs.existsSync(CONFIG_FILE)) {
+        return null;
+    }
+    try {
+        const encrypted = fs.readFileSync(CONFIG_FILE, 'utf8');
+        const decrypted = decrypt(encrypted);
+        return JSON.parse(decrypted);
+    }
+    catch {
+        return null;
+    }
+}
+function getBackupsDir() {
+    ensureConfigDir();
+    return BACKUPS_DIR;
+}
+function getConfigDir() {
+    return CONFIG_DIR;
+}
+function getEncryptionKey() {
+    return ENCRYPTION_KEY;
+}

package/dist/utils/dumper.d.ts

@@ -0,0 +1,23 @@
+import { DbConfig } from './config';
+/**
+ * Creates an encrypted, streamed snapshot of the database.
+ *
+ * For Postgres/MySQL: spawns pg_dump/mysqldump and pipes stdout → cipher → file.
+ * For SQLite: uses the native .backup command (always writes to a file), then
+ * streams that temp file through the cipher into the final encrypted output.
+ *
+ * Memory footprint stays near-zero regardless of database size.
+ */
+export declare function createSnapshot(config: DbConfig): Promise<string>;
+/**
+ * Restores a database from an encrypted snapshot file by streaming:
+ * file → decipher → psql/mysql stdin.
+ *
+ * For SQLite: deciphers to a temp file, then copies over the original.
+ */
+export declare function restoreSnapshot(config: DbConfig, snapshotPath: string): Promise<void>;
+export declare function listSnapshots(): {
+    file: string;
+    time: Date;
+    size: number;
+}[];