@glash/cli 0.2.5 → 0.2.7

package/README.md

@@ -1,9 +1,9 @@
-# @glashdb/cli
+# @glash/cli
 
 The official command-line interface for [glashDB](https://glashdb.com).
 
 ```
-npm install -g @glashdb/cli
+npm install -g @glash/cli
 glash login
 glash deploy
 ```
@@ -33,11 +33,45 @@ glash deploy
 | `glash env:rm KEY` | Remove an env var |
 | `glash env:pull [--out .env.local]` | Pull env vars to a local file |
 | `glash env:push [<file>]` | Bulk upload from a `.env` file |
+| `glash database dump [--url "$DATABASE_URL"]` | Dump a Postgres-compatible source database to `.glash/database-dumps/` |
+| `glash database upload [--file dump.dump]` | Restore a local dump into the linked glashDB database |
 | `glash update` | Update `@glash/cli` to the latest version |
 
 Pass `--project <slug>` to any command to operate on a project other than
 the one linked in the current directory.
 
+## Database dump and upload
+
+`glash database dump` looks for a Postgres-compatible source URL in this order:
+
+1. `--url` / `--from`
+2. the current shell environment
+3. `.env`, `.env.local`, `.env.production`, `.env.development`
+
+Supported env names include `DATABASE_URL`, `POSTGRES_URL`,
+`POSTGRES_URL_NON_POOLING`, `DIRECT_URL`, and `SUPABASE_DB_URL`.
+
+Examples:
+
+```bash
+glash database dump
+glash database dump --url "$DATABASE_URL" --out ./backup.dump
+glash database dump --format plain --out ./backup.sql
+```
+
+`glash database upload` restores the latest dump into the linked glashDB
+project. It fetches the project's revealed direct database URL from the glashDB
+API and runs `pg_restore` for custom dumps or `psql` for `.sql` dumps.
+
+```bash
+glash link my-project
+glash database upload --yes
+glash database upload --file ./backup.sql --format plain --project my-project
+```
+
+The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
+`pg_restore` for custom-format restores, and `psql` for plain SQL restores.
+
 ## Environment
 
 | Variable | Default | Notes |

package/bin/glash.mjs

@@ -3,7 +3,7 @@ import { argv, exit } from 'node:process';
 import { parseArgs } from '../lib/args.mjs';
 import { info, fail, color } from '../lib/ui.mjs';
 
-const VERSION = '0.2.5';
+const VERSION = '0.2.7';
 
 const sub = argv[2];
 const rest = argv.slice(3);
@@ -40,6 +40,10 @@ const commands = {
   'env:pull':      () => import('../commands/env.mjs').then((m) => m.envPull(parsed)),
   'env:push':      () => import('../commands/env.mjs').then((m) => m.envPush(parsed)),
 
+  database:        () => import('../commands/database.mjs').then((m) => m.database(parsed)),
+  'database:dump': () => import('../commands/database.mjs').then((m) => m.databaseDump(parsed)),
+  'database:upload': () => import('../commands/database.mjs').then((m) => m.databaseUpload(parsed)),
+
   pull:            () => import('../commands/pull.mjs').then((m) => m.pull(parsed)),
   open:            () => import('../commands/open.mjs').then((m) => m.open(parsed)),
   update:          () => import('../commands/update.mjs').then((m) => m.update(parsed)),
@@ -80,6 +84,10 @@ ${color.bold('ENV VARS')}
   env:pull [--out .env.local] Write env vars to a local .env file
   env:push [<file>]           Bulk upload from a .env file
 
+${color.bold('DATABASE')}
+  database dump               Dump a Postgres-compatible DATABASE_URL locally
+  database upload             Restore the latest/local dump into linked glashDB database
+
 ${color.bold('PULL')}
   pull [<slug>] [--out dir] [--no-env]  Pull source + .env from a glashDB project
 

package/commands/database.mjs

@@ -0,0 +1,240 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, join, resolve } from 'node:path';
+import { cwd, env } from 'node:process';
+import { parse as parseDotenv } from 'dotenv';
+import { apiGet } from '../lib/api.mjs';
+import { readProjectLink } from '../lib/config.mjs';
+import { fail, info, ok, color, prompt } from '../lib/ui.mjs';
+
+const DUMP_DIR = join(cwd(), '.glash', 'database-dumps');
+const LATEST_FILE = join(DUMP_DIR, 'latest.json');
+const ENV_FILES = ['.env', '.env.local', '.env.production', '.env.development'];
+const SOURCE_ENV_KEYS = [
+  'DATABASE_URL',
+  'POSTGRES_URL',
+  'POSTGRES_PRISMA_URL',
+  'POSTGRES_URL_NON_POOLING',
+  'DIRECT_URL',
+  'SUPABASE_DB_URL',
+];
+
+export async function database(parsed) {
+  const action = parsed.positional[0];
+  const next = { ...parsed, positional: parsed.positional.slice(1) };
+  if (action === 'dump') return databaseDump(next);
+  if (action === 'upload') return databaseUpload(next);
+  return fail('Usage: glash database <dump|upload> [flags]');
+}
+
+export async function databaseDump({ flags, positional }) {
+  const sourceUrl = flags.url || flags.from || positional[0] || await discoverSourceUrl();
+  if (!sourceUrl) {
+    return fail([
+      'No source database URL found.',
+      'Pass one with `glash database dump --url "$DATABASE_URL"` or add DATABASE_URL to .env.',
+    ].join('\n'));
+  }
+
+  const format = normalizeFormat(flags.format || 'custom');
+  const source = parsePostgresUrl(sourceUrl, 'source');
+  const out = resolve(flags.out || flags.file || defaultDumpPath(source.database, format));
+  await mkdir(dirname(out), { recursive: true });
+
+  const pgDump = flags['pg-dump'] || flags.pgDump || 'pg_dump';
+  const args = [
+    '-h', source.host,
+    '-p', String(source.port),
+    '-U', source.user,
+    '-d', source.database,
+    '--no-owner',
+    '--no-acl',
+    '-F', format === 'plain' ? 'p' : 'c',
+    '-f', out,
+  ];
+  if (flags.schema) args.push('-n', String(flags.schema));
+  if (flags.table) {
+    const tables = Array.isArray(flags.table) ? flags.table : String(flags.table).split(',');
+    for (const table of tables.map((t) => t.trim()).filter(Boolean)) args.push('-t', table);
+  }
+
+  info(color.dim(`→ dumping ${source.host}/${source.database} to ${out}`));
+  await runCommand(pgDump, args, { ...processEnvForDb(source), PGCONNECT_TIMEOUT: '15' });
+
+  const manifest = {
+    file: out,
+    format,
+    createdAt: new Date().toISOString(),
+    source: { host: source.host, port: source.port, database: source.database, user: source.user },
+  };
+  await writeFile(`${out}.json`, JSON.stringify(manifest, null, 2));
+  await writeFile(LATEST_FILE, JSON.stringify(manifest, null, 2));
+  ok(`Database dump saved: ${out}`);
+  info(color.dim(`  manifest: ${out}.json`));
+}
+
+export async function databaseUpload({ flags, positional }) {
+  const project = await resolveProject(flags.project);
+  const dump = await resolveDumpFile(flags.file || positional[0]);
+  if (!dump.file || !existsSync(dump.file)) return fail(`Dump file not found: ${dump.file}`);
+
+  const targetUrl = flags.url || flags.to || await getTargetDatabaseUrl(project.id);
+  const target = parsePostgresUrl(targetUrl, 'target');
+  const format = normalizeFormat(flags.format || dump.format || inferFormat(dump.file));
+  const yes = Boolean(flags.yes || flags.y);
+  const clean = flags.clean !== false && flags['no-clean'] !== true;
+
+  info(color.dim(`→ uploading ${dump.file} into ${project.slug || project.id} (${target.host}/${target.database})`));
+  if (!yes) {
+    const answer = await prompt(`Restore into glashDB project "${project.slug || project.id}"? Type "upload" to continue: `);
+    if (answer !== 'upload') return fail('Aborted');
+  }
+
+  if (format === 'plain') {
+    const psql = flags.psql || 'psql';
+    const args = [
+      '-h', target.host,
+      '-p', String(target.port),
+      '-U', target.user,
+      '-d', target.database,
+      '-v', 'ON_ERROR_STOP=1',
+      '-f', dump.file,
+    ];
+    await runCommand(psql, args, processEnvForDb(target));
+  } else {
+    const pgRestore = flags['pg-restore'] || flags.pgRestore || 'pg_restore';
+    const args = [
+      '-h', target.host,
+      '-p', String(target.port),
+      '-U', target.user,
+      '-d', target.database,
+      '--no-owner',
+      '--no-acl',
+      '--verbose',
+    ];
+    if (clean) args.push('--clean', '--if-exists');
+    if (flags.schema) args.push('-n', String(flags.schema));
+    args.push(dump.file);
+    await runCommand(pgRestore, args, processEnvForDb(target));
+  }
+
+  ok(`Uploaded database dump to ${project.slug || project.id}`);
+}
+
+async function discoverSourceUrl() {
+  for (const key of SOURCE_ENV_KEYS) {
+    if (env[key]) return env[key];
+  }
+  for (const file of ENV_FILES) {
+    const path = join(cwd(), file);
+    if (!existsSync(path)) continue;
+    try {
+      const parsed = parseDotenv(await readFile(path, 'utf8'));
+      for (const key of SOURCE_ENV_KEYS) {
+        if (parsed[key]) return parsed[key];
+      }
+    } catch {}
+  }
+  return null;
+}
+
+async function resolveProject(projectArg) {
+  if (projectArg) {
+    const all = await apiGet('/projects');
+    const match = all.find((p) => p.id === projectArg || p.slug === projectArg);
+    if (!match) fail(`No project found matching "${projectArg}". Run \`glash projects\` to list.`);
+    return match;
+  }
+  const link = await readProjectLink();
+  if (!link?.projectId) {
+    fail('No linked project. Run `glash link <slug>` or pass `--project <slug|id>`.');
+  }
+  return { id: link.projectId, slug: link.slug };
+}
+
+async function getTargetDatabaseUrl(projectId) {
+  const conn = await apiGet(`/database/connection/${projectId}?reveal=1`);
+  if (!conn?.direct || /••/.test(conn.direct)) {
+    fail('Could not reveal the glashDB direct database URL for this project.');
+  }
+  return conn.direct;
+}
+
+async function resolveDumpFile(explicit) {
+  if (explicit) {
+    return { file: resolve(explicit), format: inferFormat(explicit) };
+  }
+  try {
+    const latest = JSON.parse(await readFile(LATEST_FILE, 'utf8'));
+    return { file: latest.file, format: latest.format };
+  } catch {
+    return fail('No dump file provided and no latest dump exists. Run `glash database dump` first or pass `--file <path>`.');
+  }
+}
+
+function parsePostgresUrl(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    fail(`Invalid ${label} database URL.`);
+  }
+  if (!['postgres:', 'postgresql:'].includes(url.protocol)) {
+    fail(`${label} database URL must start with postgres:// or postgresql://`);
+  }
+  return {
+    host: url.hostname,
+    port: Number(url.port || 5432),
+    database: decodeURIComponent(url.pathname.replace(/^\//, '') || 'postgres'),
+    user: decodeURIComponent(url.username || ''),
+    password: decodeURIComponent(url.password || ''),
+    sslmode: url.searchParams.get('sslmode') || undefined,
+  };
+}
+
+function processEnvForDb(db) {
+  return {
+    ...env,
+    PGPASSWORD: db.password,
+    PGSSLMODE: db.sslmode || env.PGSSLMODE || 'require',
+  };
+}
+
+function normalizeFormat(format) {
+  const f = String(format).toLowerCase();
+  if (['plain', 'sql', 'p'].includes(f)) return 'plain';
+  if (['custom', 'dump', 'dmp', 'c', 'auto'].includes(f)) return 'custom';
+  fail(`Unsupported dump format "${format}". Use custom or plain.`);
+}
+
+function inferFormat(file) {
+  const ext = extname(file).toLowerCase();
+  return ext === '.sql' ? 'plain' : 'custom';
+}
+
+function defaultDumpPath(database, format) {
+  const safeDb = String(database || 'database').replace(/[^a-z0-9_.-]+/gi, '-');
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  return join(DUMP_DIR, `${safeDb}-${stamp}.${format === 'plain' ? 'sql' : 'dump'}`);
+}
+
+function runCommand(command, args, commandEnv) {
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(command, args, {
+      env: commandEnv,
+      stdio: 'inherit',
+    });
+    child.on('error', (e) => {
+      if (e.code === 'ENOENT') {
+        reject(new Error(`${command} was not found. Install PostgreSQL client tools, then retry.`));
+      } else {
+        reject(e);
+      }
+    });
+    child.on('close', (code) => {
+      if (code === 0) resolvePromise();
+      else reject(new Error(`${basename(command)} exited with code ${code}`));
+    });
+  });
+}

package/commands/deployments.mjs

@@ -38,6 +38,14 @@ export async function status({ positional, flags }) {
     for (const ev of pipe.events ?? []) {
       info(`  ${color.dim((ev.createdAt ?? '').slice(11, 19))} ${ev.step.padEnd(8)} ${ev.status.padEnd(10)} ${ev.message ?? ''}`);
     }
+    if (pipe.build_stderr && ['error', 'failed'].includes(pipe.deployStatus ?? pipe.buildStatus ?? '')) {
+      const tail = String(pipe.build_stderr).split('\n').slice(-80).join('\n').trim();
+      if (tail) {
+        info('');
+        info(color.bold('Build output tail'));
+        info(color.dim(tail));
+      }
+    }
   } catch (e) {
     fail(e.message);
   }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",
   "repository": {
     "type": "git",
-    "url": "https://github.com/glashdb/glashdb.git",
+    "url": "git+https://github.com/glashdb/glashdb.git",
     "directory": "cli"
   },
   "bin": {