oopsdb 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OopsDB Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,108 @@
+# OopsDB
+
+**Don't let AI nuke your database.**
+
+Auto-backup and 1-click restore for developers using Claude Code, Cursor, Windsurf, and other AI coding agents.
+
+---
+
+## The Problem
+
+You're vibing. Claude Code is cranking through tasks. Then it decides the fastest way to fix a migration is `DROP TABLE users`. Or it runs `DELETE FROM orders` without a `WHERE` clause. Or it helpfully "cleans up" your SQLite file.
+
+Your data is gone. Your afternoon is gone. Your will to live is negotiable.
+
+## The Fix
+
+```bash
+npm install -g oopsdb
+oopsdb init      # connect your DB (Supabase, Postgres, MySQL, SQLite)
+oopsdb watch     # auto-backup every 5 min
+# ... AI nukes your DB ...
+oopsdb restore   # pick a snapshot, roll back instantly
+```
+
+That's it. Three commands. Your data survives the AI apocalypse.
+
+## What It Does
+
+- **Auto-backups** on a timer (`oopsdb watch`) — set it and forget it
+- **Manual snapshots** (`oopsdb snapshot`) — before risky migrations or YOLO prompts
+- **Interactive restore** (`oopsdb restore`) — pick any snapshot, roll back in seconds
+- **Safety snapshots** — automatically backs up your current state before restoring, so you can't oops your oops
+- **Encrypted at rest** — AES-256-CBC encryption on every backup file
+- **Zero cloud, zero accounts** — everything stays on your machine
+- **Streaming backups** — near-zero memory footprint regardless of DB size
+
+## Supported Databases
+
+| Database | Backup Tool | Restore Tool |
+|----------|------------|--------------|
+| **Supabase** | `pg_dump` (with Supabase flags) | `psql` |
+| PostgreSQL (Neon, local, other hosted) | `pg_dump` | `psql` |
+| MySQL / MariaDB | `mysqldump` | `mysql` |
+| SQLite | `sqlite3` | `sqlite3` |
+
+### Supabase (first-class support)
+
+OopsDB has dedicated Supabase support. Just paste your connection string:
+
+```bash
+oopsdb init
+# → Select "Supabase"
+# → Paste your connection string from Supabase Dashboard → Settings → Database
+# → Done. SSL and Supabase-specific pg_dump flags are handled automatically.
+```
+
+Supabase-specific flags applied automatically: `--no-owner`, `--no-privileges`, `--no-subscriptions`, `sslmode=require`.
+
+## Commands
+
+```
+oopsdb init                Set up your database connection
+oopsdb watch               Auto-backup every 5 minutes
+oopsdb watch -i 1          Auto-backup every 1 minute (paranoid mode)
+oopsdb snapshot            One-time manual backup
+oopsdb restore             Interactive restore from any snapshot
+oopsdb status              View backup history and stats
+oopsdb activate <key>      Activate a Pro license
+oopsdb deactivate          Deactivate your license on this machine
+oopsdb license             Show current license status and plan
+oopsdb secure              Immutable cloud backups (Coming Soon)
+oopsdb clean               Remove all OopsDB data from project
+```
+
+## How It Works
+
+1. `oopsdb init` walks you through connecting your database. Credentials are encrypted and saved locally in `.oopsdb/config.json`.
+2. `oopsdb watch` runs the native dump tool (`pg_dump`, `mysqldump`, or `sqlite3 .backup`) at your chosen interval. Output is streamed through AES-256-CBC encryption directly to disk — memory usage stays flat even for large databases.
+3. `oopsdb restore` shows your snapshots with timestamps and sizes. Pick one, confirm, and your database is rolled back. It takes a safety snapshot first, so you can always undo the undo.
+
+## Requirements
+
+Your system needs the native database CLI tools:
+
+- **PostgreSQL**: `pg_dump` + `psql`
+- **MySQL**: `mysqldump` + `mysql`
+- **SQLite**: `sqlite3`
+
+OopsDB checks for these on `init` and gives install instructions if they're missing.
+
+## Security
+
+- Credentials encrypted at rest (AES-256-CBC, machine-local key)
+- Backup files encrypted at rest (AES-256-CBC, streaming encryption)
+- Nothing leaves your machine — no cloud, no telemetry, no accounts
+- Add `.oopsdb/` to `.gitignore` (already in ours)
+
+## Coming Soon: `oopsdb secure`
+
+Immutable cloud backups that even a rogue AI can't delete.
+
+Local backups are great until the AI decides to `rm -rf .oopsdb/`. `oopsdb secure` pushes encrypted snapshots to tamper-proof cloud storage with write-once retention policies. Even if your entire machine gets wiped, your backups survive.
+
+Sign up for early access at [oopsdb.com/secure](https://oopsdb.com/secure).
+
+## License
+
+MIT

package/dist/commands/activate.d.ts

@@ -0,0 +1,3 @@
+export declare function activateCommand(licenseKey: string): Promise<void>;
+export declare function deactivateCommand(): Promise<void>;
+export declare function licenseStatusCommand(): Promise<void>;

package/dist/commands/activate.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activateCommand = activateCommand;
+exports.deactivateCommand = deactivateCommand;
+exports.licenseStatusCommand = licenseStatusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const license_1 = require("../utils/license");
+async function activateCommand(licenseKey) {
+    console.log(chalk_1.default.bold('\n  OopsDB — License Activation\n'));
+    if (!licenseKey || licenseKey.trim().length === 0) {
+        console.log(chalk_1.default.red('  Please provide your license key.'));
+        console.log(chalk_1.default.gray('\n  Usage: ') + chalk_1.default.cyan('oopsdb activate <license-key>'));
+        console.log(chalk_1.default.gray('  Get your key at ') + chalk_1.default.cyan('https://oopsdb.com\n'));
+        return;
+    }
+    const spinner = (0, ora_1.default)('Activating license...').start();
+    try {
+        const license = await (0, license_1.activateLicense)(licenseKey.trim());
+        spinner.succeed('License activated!');
+        console.log(chalk_1.default.green('\n  You\'re on the ' + chalk_1.default.bold(license.tier.toUpperCase()) + ' plan.'));
+        if (license.customerEmail) {
+            console.log(chalk_1.default.gray('  Email: ') + chalk_1.default.cyan(license.customerEmail));
+        }
+        console.log(chalk_1.default.gray('  Variant: ') + chalk_1.default.cyan(license.variantName || license.tier));
+        if (license.tier === 'pro') {
+            console.log(chalk_1.default.gray('\n  You now have access to:'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('PostgreSQL backups'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('MySQL / MariaDB backups'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('Supabase backups'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('Unlimited snapshots'));
+        }
+        else if (license.tier === 'secure') {
+            console.log(chalk_1.default.gray('\n  You now have access to:'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('Everything in Pro'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('Immutable cloud backups'));
+            console.log(chalk_1.default.cyan('    ✓ ') + chalk_1.default.white('Write-once retention'));
+        }
+        console.log(chalk_1.default.gray('\n  Next: ') + chalk_1.default.cyan('oopsdb init') + chalk_1.default.gray(' to set up your database\n'));
+    }
+    catch (err) {
+        spinner.fail('Activation failed');
+        console.log(chalk_1.default.red(`\n  ${err.message}`));
+        console.log(chalk_1.default.gray('\n  Make sure your license key is correct.'));
+        console.log(chalk_1.default.gray('  Get help at ') + chalk_1.default.cyan('https://oopsdb.com\n'));
+    }
+}
+async function deactivateCommand() {
+    console.log(chalk_1.default.bold('\n  OopsDB — License Deactivation\n'));
+    const license = (0, license_1.loadLicense)();
+    if (!license) {
+        console.log(chalk_1.default.yellow('  No active license found.\n'));
+        return;
+    }
+    const spinner = (0, ora_1.default)('Deactivating license...').start();
+    try {
+        await (0, license_1.deactivateLicense)();
+        spinner.succeed('License deactivated');
+        console.log(chalk_1.default.gray('\n  You\'re back on the Free plan (SQLite only).'));
+        console.log(chalk_1.default.gray('  You can re-activate anytime with: ') + chalk_1.default.cyan('oopsdb activate <key>\n'));
+    }
+    catch (err) {
+        spinner.fail('Deactivation failed');
+        console.log(chalk_1.default.red(`\n  ${err.message}\n`));
+    }
+}
+async function licenseStatusCommand() {
+    const license = (0, license_1.loadLicense)();
+    console.log(chalk_1.default.bold('\n  OopsDB — License Status\n'));
+    if (!license) {
+        console.log(chalk_1.default.gray('  Plan:   ') + chalk_1.default.white('Free'));
+        console.log(chalk_1.default.gray('  Access: ') + chalk_1.default.white('SQLite only'));
+        console.log(chalk_1.default.gray('\n  Upgrade: ') + chalk_1.default.cyan('https://oopsdb.com') + chalk_1.default.gray(' → then run ') + chalk_1.default.cyan('oopsdb activate <key>\n'));
+        return;
+    }
+    console.log(chalk_1.default.gray('  Plan:      ') + chalk_1.default.green(license.tier.toUpperCase()));
+    console.log(chalk_1.default.gray('  Key:       ') + chalk_1.default.cyan(license.licenseKey.slice(0, 8) + '...' + license.licenseKey.slice(-4)));
+    console.log(chalk_1.default.gray('  Activated: ') + chalk_1.default.cyan(new Date(license.activatedAt).toLocaleDateString()));
+    if (license.customerEmail) {
+        console.log(chalk_1.default.gray('  Email:     ') + chalk_1.default.cyan(license.customerEmail));
+    }
+    if (license.variantName) {
+        console.log(chalk_1.default.gray('  Variant:   ') + chalk_1.default.cyan(license.variantName));
+    }
+    console.log();
+}

package/dist/commands/clean.d.ts

@@ -0,0 +1,3 @@
+export declare function cleanCommand(options: {
+    yes?: boolean;
+}): Promise<void>;

package/dist/commands/clean.js

@@ -0,0 +1,93 @@
+"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.cleanCommand = cleanCommand;
+const inquirer = __importStar(require("inquirer"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const config_1 = require("../utils/config");
+const dumper_1 = require("../utils/dumper");
+async function cleanCommand(options) {
+    const configDir = (0, config_1.getConfigDir)();
+    if (!fs.existsSync(configDir)) {
+        console.log(chalk_1.default.yellow('\n  Nothing to clean — no .oopsdb/ directory found.\n'));
+        return;
+    }
+    const snapshots = (0, dumper_1.listSnapshots)();
+    const dirSize = getDirSize(configDir);
+    console.log(chalk_1.default.bold('\n  OopsDB Clean\n'));
+    console.log(chalk_1.default.gray(`  Directory:  ${configDir}`));
+    console.log(chalk_1.default.gray(`  Snapshots:  ${snapshots.length}`));
+    console.log(chalk_1.default.gray(`  Total size: ${formatSize(dirSize)}\n`));
+    if (!options.yes) {
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: chalk_1.default.yellow('This will permanently delete all backups and config. Continue?'),
+                default: false,
+            },
+        ]);
+        if (!confirm) {
+            console.log(chalk_1.default.gray('\n  Clean cancelled.\n'));
+            return;
+        }
+    }
+    fs.rmSync(configDir, { recursive: true, force: true });
+    console.log(chalk_1.default.green(`\n  Removed ${configDir} (${snapshots.length} snapshot(s), ${formatSize(dirSize)})\n`));
+}
+function getDirSize(dir) {
+    let total = 0;
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const full = `${dir}/${entry.name}`;
+        if (entry.isDirectory()) {
+            total += getDirSize(full);
+        }
+        else {
+            total += fs.statSync(full).size;
+        }
+    }
+    return total;
+}
+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`;
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,317 @@
+"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.initCommand = initCommand;
+const inquirer = __importStar(require("inquirer"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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 license_1 = require("../utils/license");
+async function initCommand() {
+    console.log(chalk_1.default.bold('\n  OopsDB Setup\n'));
+    console.log(chalk_1.default.gray('  Protect your database from AI-powered disasters.\n'));
+    const existing = (0, config_1.loadConfig)();
+    if (existing) {
+        const { overwrite } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: 'OopsDB is already configured in this directory. Overwrite?',
+                default: false,
+            },
+        ]);
+        if (!overwrite) {
+            console.log(chalk_1.default.yellow('\n  Setup cancelled.\n'));
+            return;
+        }
+    }
+    const { dbType } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'dbType',
+            message: 'What database are you using?',
+            choices: [
+                { name: 'Supabase', value: 'supabase' },
+                { name: 'PostgreSQL (Neon, local, other hosted)', value: 'postgres' },
+                { name: 'MySQL / MariaDB', value: 'mysql' },
+                { name: 'SQLite (local file)', value: 'sqlite' },
+            ],
+        },
+    ]);
+    // Check license for non-SQLite databases
+    if ((0, license_1.requiresLicense)(dbType)) {
+        const tier = (0, license_1.getCurrentTier)();
+        if (tier === 'free') {
+            console.log(chalk_1.default.yellow('\n  ⚠  ' + dbType.charAt(0).toUpperCase() + dbType.slice(1) + ' requires a Pro or Secure license.\n'));
+            console.log(chalk_1.default.white('  Free plan supports SQLite only.'));
+            console.log(chalk_1.default.gray('\n  To upgrade:'));
+            console.log(chalk_1.default.cyan('    1. ') + chalk_1.default.white('Get a license at ') + chalk_1.default.cyan('https://oopsdb.com'));
+            console.log(chalk_1.default.cyan('    2. ') + chalk_1.default.white('Run: ') + chalk_1.default.cyan('oopsdb activate <your-license-key>'));
+            console.log(chalk_1.default.cyan('    3. ') + chalk_1.default.white('Run: ') + chalk_1.default.cyan('oopsdb init') + chalk_1.default.gray(' again\n'));
+            return;
+        }
+    }
+    // Supabase and plain Postgres both use pg_dump/psql
+    const toolType = dbType === 'supabase' ? 'postgres' : dbType;
+    // Pre-flight: check that the required DB tools are installed
+    console.log(chalk_1.default.gray('\n  Checking for required tools...\n'));
+    const toolsOk = await (0, preflight_1.preflightCheck)(toolType, 'both');
+    if (!toolsOk) {
+        console.log(chalk_1.default.red('\n  Missing required database tools. Install them and re-run `oopsdb init`.\n'));
+        process.exit(1);
+    }
+    console.log();
+    let dbConfig;
+    if (dbType === 'supabase') {
+        dbConfig = await setupSupabase();
+    }
+    else if (dbType === 'sqlite') {
+        const { database } = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'database',
+                message: 'Path to your SQLite database file:',
+                validate: (input) => {
+                    if (input.length === 0)
+                        return 'Please enter a path';
+                    const resolved = path.resolve(input);
+                    if (!fs.existsSync(resolved))
+                        return `File not found: ${resolved}`;
+                    return true;
+                },
+            },
+        ]);
+        dbConfig = { type: 'sqlite', database: path.resolve(database) };
+    }
+    else {
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'host',
+                message: 'Database host:',
+                default: 'localhost',
+            },
+            {
+                type: 'input',
+                name: 'port',
+                message: 'Database port:',
+                default: dbType === 'postgres' ? '5432' : '3306',
+                validate: (input) => {
+                    const port = parseInt(input, 10);
+                    if (isNaN(port) || port < 1 || port > 65535)
+                        return 'Port must be a number between 1 and 65535';
+                    return true;
+                },
+            },
+            {
+                type: 'input',
+                name: 'user',
+                message: 'Database user:',
+                default: dbType === 'postgres' ? 'postgres' : 'root',
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Database password:',
+            },
+            {
+                type: 'input',
+                name: 'database',
+                message: 'Database name:',
+                validate: (input) => (input.length > 0 ? true : 'Please enter a database name'),
+            },
+        ]);
+        dbConfig = {
+            type: dbType,
+            host: answers.host,
+            port: parseInt(answers.port, 10),
+            user: answers.user,
+            password: answers.password,
+            database: answers.database,
+        };
+    }
+    const config = {
+        db: dbConfig,
+        createdAt: new Date().toISOString(),
+    };
+    (0, config_1.saveConfig)(config);
+    console.log(chalk_1.default.green('\n  Config saved to .oopsdb/config.json (encrypted)\n'));
+    const { takeSnapshot } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'takeSnapshot',
+            message: 'Take an initial snapshot now?',
+            default: true,
+        },
+    ]);
+    if (takeSnapshot) {
+        const spinner = (0, ora_1.default)('Taking initial snapshot...').start();
+        try {
+            const file = await (0, dumper_1.createSnapshot)(dbConfig);
+            spinner.succeed(`Snapshot saved: ${file}`);
+        }
+        catch (err) {
+            spinner.fail(`Snapshot failed: ${err.message}`);
+            console.log(chalk_1.default.yellow('\n  Tip: Make sure your database tools (pg_dump, mysqldump, sqlite3) are installed.\n'));
+        }
+    }
+    console.log(chalk_1.default.bold('\n  You\'re all set! Next steps:\n'));
+    console.log(chalk_1.default.cyan('    oopsdb watch       ') + chalk_1.default.gray('Start auto-backing up'));
+    console.log(chalk_1.default.cyan('    oopsdb snapshot    ') + chalk_1.default.gray('Take a manual snapshot'));
+    console.log(chalk_1.default.cyan('    oopsdb restore     ') + chalk_1.default.gray('Roll back to a backup'));
+    console.log(chalk_1.default.cyan('    oopsdb status      ') + chalk_1.default.gray('See your backups'));
+    console.log();
+    console.log(chalk_1.default.gray('  ─────────────────────────────────────────────────'));
+    console.log(chalk_1.default.magenta('  New: ') + chalk_1.default.white('oopsdb secure'));
+    console.log(chalk_1.default.gray('  Immutable cloud backups that even a rogue AI can\'t delete.'));
+    console.log(chalk_1.default.gray('  Learn more: ') + chalk_1.default.cyan('oopsdb secure') + chalk_1.default.gray(' or ') + chalk_1.default.cyan('https://oopsdb.com/secure'));
+    console.log();
+}
+/**
+ * Parse a Supabase/Postgres connection string into DbConfig components.
+ * Supports: postgresql://user:password@host:port/database?sslmode=require
+ */
+function parseConnectionString(connStr) {
+    const url = new URL(connStr);
+    return {
+        type: 'postgres',
+        supabase: true,
+        host: url.hostname,
+        port: parseInt(url.port, 10) || 5432,
+        user: decodeURIComponent(url.username),
+        password: decodeURIComponent(url.password),
+        database: url.pathname.slice(1) || 'postgres',
+        connectionString: connStr,
+        sslmode: url.searchParams.get('sslmode') || 'require',
+    };
+}
+async function setupSupabase() {
+    console.log(chalk_1.default.cyan('  Supabase Setup'));
+    console.log(chalk_1.default.gray('  Find your connection string in Supabase Dashboard → Settings → Database\n'));
+    const { method } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'method',
+            message: 'How do you want to connect?',
+            choices: [
+                { name: 'Paste connection string (recommended)', value: 'connstring' },
+                { name: 'Enter details manually', value: 'manual' },
+            ],
+        },
+    ]);
+    if (method === 'connstring') {
+        const { connString } = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'connString',
+                message: 'Paste your Supabase connection string:',
+                validate: (input) => {
+                    if (!input.startsWith('postgresql://') && !input.startsWith('postgres://')) {
+                        return 'Connection string must start with postgresql:// or postgres://';
+                    }
+                    try {
+                        new URL(input);
+                        return true;
+                    }
+                    catch {
+                        return 'Invalid connection string format';
+                    }
+                },
+            },
+        ]);
+        const config = parseConnectionString(connString);
+        console.log(chalk_1.default.gray(`\n  Parsed: ${config.host}:${config.port}/${config.database} (user: ${config.user})`));
+        console.log(chalk_1.default.gray(`  SSL: ${config.sslmode}`));
+        console.log(chalk_1.default.green('  Supabase-specific flags: --no-owner --no-privileges --no-subscriptions\n'));
+        return config;
+    }
+    // Manual entry
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'host',
+            message: 'Supabase database host:',
+            default: 'db.YOUR_PROJECT_REF.supabase.co',
+            validate: (input) => input.length > 0 ? true : 'Please enter a host',
+        },
+        {
+            type: 'input',
+            name: 'port',
+            message: 'Port:',
+            default: '5432',
+            validate: (input) => {
+                const port = parseInt(input, 10);
+                if (isNaN(port) || port < 1 || port > 65535)
+                    return 'Port must be 1-65535';
+                return true;
+            },
+        },
+        {
+            type: 'input',
+            name: 'user',
+            message: 'Database user:',
+            default: 'postgres',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Database password:',
+        },
+        {
+            type: 'input',
+            name: 'database',
+            message: 'Database name:',
+            default: 'postgres',
+        },
+    ]);
+    console.log(chalk_1.default.green('\n  Supabase-specific flags will be applied automatically.\n'));
+    return {
+        type: 'postgres',
+        supabase: true,
+        host: answers.host,
+        port: parseInt(answers.port, 10),
+        user: answers.user,
+        password: answers.password,
+        database: answers.database,
+        sslmode: 'require',
+    };
+}

package/dist/commands/restore.d.ts

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