@glash/cli 0.2.7 → 0.2.13

package/bin/glash.mjs

@@ -2,8 +2,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.7';
+import { VERSION } from '../lib/version.mjs';
 
 const sub = argv[2];
 const rest = argv.slice(3);

package/commands/database.mjs

@@ -25,7 +25,64 @@ export async function database(parsed) {
   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]');
+  if (action === 'migrate') return databaseMigrate(next);
+  return fail('Usage: glash database <dump|upload|migrate> [flags]');
+}
+
+/**
+ * End-to-end Supabase → glashDB migration.
+ *
+ *   glash database migrate \
+ *     --from "$SUPABASE_DB_URL"   # source connection (defaults to discovered DATABASE_URL/SUPABASE_DB_URL)
+ *     --project my-app            # destination glashDB project (defaults to linked project)
+ *     --include-auth-users        # also copy auth.users → glashauth (bcrypt hashes preserved)
+ *     --yes                       # skip confirmation prompts
+ *
+ * Steps: dump (custom format) → confirm → restore --clean --if-exists → optional auth.users copy.
+ */
+export async function databaseMigrate({ flags, positional }) {
+  const sourceUrl = flags.from || flags.url || positional[0] || await discoverSourceUrl();
+  if (!sourceUrl) return fail('No source URL. Pass --from "$SUPABASE_DB_URL" or set DATABASE_URL/SUPABASE_DB_URL.');
+
+  const project = await resolveProject(flags.project);
+  const yes = Boolean(flags.yes || flags.y);
+  if (!yes) {
+    const answer = await prompt(`Migrate into glashDB project "${project.slug || project.id}"? Type "migrate" to continue: `);
+    if (answer !== 'migrate') return fail('Aborted');
+  }
+
+  // 1. dump
+  await databaseDump({ flags: { ...flags, url: sourceUrl, format: 'custom' }, positional: [] });
+  // 2. upload (the latest dump is already pointed at by .glash/database-dumps/latest.json)
+  await databaseUpload({ flags: { ...flags, project: project.slug || project.id, yes: true }, positional: [] });
+  // 3. optional auth users
+  if (flags['include-auth-users'] || flags.includeAuthUsers) {
+    await copyAuthUsers(sourceUrl, project.id);
+  }
+  ok(`Migration complete → ${project.slug || project.id}`);
+}
+
+async function copyAuthUsers(sourceUrl, projectId) {
+  info(color.dim('→ copying auth.users → glashauth (bcrypt hashes preserved)'));
+  const source = parsePostgresUrl(sourceUrl, 'source');
+  // Stream rows out via psql --csv, then POST to the backend importer.
+  const psql = 'psql';
+  const sql = `COPY (SELECT id, email, encrypted_password, raw_user_meta_data->>'full_name' AS full_name, created_at FROM auth.users WHERE email IS NOT NULL) TO STDOUT WITH CSV HEADER`;
+  const child = spawn(psql, ['-h', source.host, '-p', String(source.port), '-U', source.user, '-d', source.database, '-c', sql], {
+    env: processEnvForDb(source),
+  });
+  const chunks = [];
+  child.stdout.on('data', (d) => chunks.push(d));
+  const errs = [];
+  child.stderr.on('data', (d) => errs.push(d));
+  await new Promise((res, rej) => {
+    child.on('error', rej);
+    child.on('close', (code) => code === 0 ? res() : rej(new Error(`psql exit ${code}: ${Buffer.concat(errs).toString().slice(0, 400)}`)));
+  });
+  const csv = Buffer.concat(chunks).toString('utf8');
+  const { apiPost } = await import('../lib/api.mjs');
+  const result = await apiPost(`/database/migrate/${projectId}/import-auth-users`, { csv });
+  ok(`Imported ${result.imported ?? 0} auth users (${result.skipped ?? 0} skipped).`);
 }
 
 export async function databaseDump({ flags, positional }) {

package/commands/deploy.mjs

@@ -177,10 +177,27 @@ export async function deploy({ flags }) {
   const seen = new Set();
   let lastStatus = '';
   const start = Date.now();
+  let pollDelayMs = 5000;
+  let lastProgressAt = Date.now();
   while (Date.now() - start < 15 * 60 * 1000) {
     let pipe;
-    try { pipe = await apiGet(`/deployments/${dep.id}/pipeline`); }
-    catch (e) { warn(`poll error: ${e.message}`); await sleep(3000); continue; }
+    try {
+      pipe = await apiGet(`/deployments/${dep.id}/pipeline`);
+    } catch (e) {
+      if (e.status === 429) {
+        const wait = Math.min(Math.max(e.retryAfterMs ?? pollDelayMs * 2, 10000), 60000);
+        pollDelayMs = wait;
+        await sleep(wait);
+        continue;
+      }
+      if (Date.now() - lastProgressAt > 60_000) {
+        info(color.dim(`  • deploy   Still working; waiting for the next deployment update…`));
+        lastProgressAt = Date.now();
+      }
+      pollDelayMs = Math.min(Math.max(pollDelayMs * 1.5, 5000), 30000);
+      await sleep(pollDelayMs);
+      continue;
+    }
 
     for (const ev of pipe.events ?? []) {
       const key = `${ev.id ?? ev.createdAt}:${ev.step}:${ev.status}`;
@@ -188,6 +205,7 @@ export async function deploy({ flags }) {
       seen.add(key);
       const tag = stepBadge(ev.status);
       info(`  ${tag} ${color.dim(ev.step.padEnd(8))} ${ev.message ?? ''}`);
+      lastProgressAt = Date.now();
     }
 
     const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
@@ -200,7 +218,8 @@ export async function deploy({ flags }) {
     if (['error', 'failed'].includes(status)) {
       return fail(`Deployment failed (${status}). Run \`glash logs ${dep.id}\` for details.`);
     }
-    await sleep(2500);
+    pollDelayMs = nextPollDelay(pipe);
+    await sleep(pollDelayMs);
   }
   warn('Timed out waiting for deployment. Check `glash status <id>`.');
 }
@@ -272,4 +291,13 @@ function stepBadge(status) {
   return color.cyan('•');
 }
 
+function nextPollDelay(pipe) {
+  const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
+  const last = [...(pipe.events ?? [])].reverse().find(Boolean);
+  if (status === 'queued' || last?.status === 'queued') return 8000;
+  if (status === 'building' || last?.step === 'build') return 10000;
+  if (status === 'rolling-out') return 5000;
+  return 5000;
+}
+
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/commands/login.mjs

@@ -9,6 +9,9 @@ export async function login({ flags }) {
 
   try {
     const r = await apiPost('/auth/login', { email, password });
+    if (!r?.accessToken || !r?.user?.email) {
+      throw new Error('Login response was missing a session token. Please try again.');
+    }
     await writeCreds({ token: r.accessToken, email: r.user?.email });
     ok(`Signed in as ${r.user?.email ?? email}`);
   } catch (e) {

package/commands/logout.mjs

@@ -1,7 +1,19 @@
-import { clearCreds } from '../lib/config.mjs';
-import { ok } from '../lib/ui.mjs';
+import { apiPost } from '../lib/api.mjs';
+import { clearCreds, getToken } from '../lib/config.mjs';
+import { ok, info, color } from '../lib/ui.mjs';
 
 export async function logout() {
+  // Best-effort server-side revocation. If the token is already invalid or the
+  // server is unreachable, we still clear the local file so the user is signed
+  // out from this machine.
+  const token = await getToken();
+  if (token) {
+    try {
+      await apiPost('/auth/logout', {}, { token });
+    } catch (e) {
+      info(color.dim(`(server-side revoke failed: ${e?.message || e} — clearing local creds anyway)`));
+    }
+  }
   await clearCreds();
   ok('Signed out');
 }

package/lib/api.mjs

@@ -1,14 +1,30 @@
 import { API_URL, getToken } from './config.mjs';
+import { VERSION } from './version.mjs';
 
 export class GlashApiError extends Error {
-  constructor(status, message) {
+  constructor(status, message, meta = {}) {
     super(message);
     this.status = status;
+    this.retryAfterMs = meta.retryAfterMs;
   }
 }
 
+function retryAfterMs(headers) {
+  const raw = headers?.get?.('retry-after');
+  if (!raw) return undefined;
+  const seconds = Number(raw);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
+  const date = Date.parse(raw);
+  if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  return undefined;
+}
+
 export async function api(method, path, { body, token, query } = {}) {
-  const headers = { Accept: 'application/json' };
+  const headers = {
+    Accept: 'application/json',
+    'User-Agent': `glash-cli/${VERSION}`,
+    'X-Glash-Client': 'cli',
+  };
   const t = token ?? (await getToken());
   if (t) headers.Authorization = `Bearer ${t}`;
   if (body !== undefined && !(body instanceof FormData)) {
@@ -42,7 +58,10 @@ export async function api(method, path, { body, token, query } = {}) {
       if (typeof data?.message === 'string') message = data.message;
       else if (Array.isArray(data?.message)) message = data.message.join(', ');
     } catch {}
-    throw new GlashApiError(res.status, message);
+    if (res.status === 401 && !path.includes('/auth/login') && !path.includes('/auth/cli/login')) {
+      message = `${message}. Run \`glash login\` again, then retry the command.`;
+    }
+    throw new GlashApiError(res.status, message, { retryAfterMs: retryAfterMs(res.headers) });
   }
 
   if (res.status === 204) return undefined;

package/lib/version.mjs

@@ -0,0 +1 @@
+export const VERSION = '0.2.13';

package/lib/zip.mjs

@@ -1,73 +1,139 @@
-import archiver from 'archiver';
+import fg from 'fast-glob';
+import yazl from 'yazl';
 import { createWriteStream } from 'node:fs';
 import { join, relative } from 'node:path';
 import fs from 'fs-extra';
 
 export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
+  // Default ignores
+  const defaultIgnore = [
+    'node_modules/**',
+    '**/node_modules/**',
+    '.git/**',
+    '**/.git/**',
+    '.next/**',
+    '**/.next/**',
+    '.next*/**',
+    '**/.next*/**',
+    '.nuxt/**',
+    '**/.nuxt/**',
+    '.nuxt*/**',
+    '**/.nuxt*/**',
+    '.output/**',
+    '**/.output/**',
+    '.svelte-kit/**',
+    '**/.svelte-kit/**',
+    '.wrangler/**',
+    '**/.wrangler/**',
+    '.netlify/**',
+    '**/.netlify/**',
+    'dist/**',
+    '**/dist/**',
+    'build/**',
+    '**/build/**',
+    'out/**',
+    '**/out/**',
+    'coverage/**',
+    '**/coverage/**',
+    '.turbo/**',
+    '**/.turbo/**',
+    '.cache/**',
+    '**/.cache/**',
+    '.parcel-cache/**',
+    '**/.parcel-cache/**',
+    '.vite/**',
+    '**/.vite/**',
+    '.glash/**',
+    '**/.glash/**',
+    '*.log',
+    '**/*.log',
+    'npm-debug.log*',
+    '**/npm-debug.log*',
+    'yarn-debug.log*',
+    '**/yarn-debug.log*',
+    'yarn-error.log*',
+    '**/yarn-error.log*',
+    '.env',
+    '**/.env',
+    '.env.local',
+    '**/.env.local',
+    '.env.production',
+    '**/.env.production',
+    '.env.development',
+    '**/.env.development',
+  ];
+  const allIgnore = [...new Set([...defaultIgnore, ...loadIgnorePatterns(sourceDir), ...ignore])];
+  const files = await fg('**/*', {
+    cwd: sourceDir,
+    ignore: allIgnore,
+    dot: true,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+  });
+
   return new Promise((resolve, reject) => {
+    const zip = new yazl.ZipFile();
     const output = createWriteStream(outPath);
-    const archive = archiver('zip', { zlib: { level: 9 } });
-
-    output.on('close', () => resolve(archive.pointer()));
-    archive.on('error', (err) => reject(err));
-
-    archive.pipe(output);
+    let bytes = 0;
 
-    // Default ignores
-    const defaultIgnore = [
-      'node_modules/**',
-      '.git/**',
-      '.next/**',
-      '.next*/**',
-      '.nuxt/**',
-      '.nuxt*/**',
-      '.output/**',
-      '.svelte-kit/**',
-      '.wrangler/**',
-      '.netlify/**',
-      'dist/**',
-      'build/**',
-      'out/**',
-      'coverage/**',
-      '.turbo/**',
-      '.cache/**',
-      '.parcel-cache/**',
-      '.vite/**',
-      '.glash/**',
-      '*.log',
-      'npm-debug.log*',
-      'yarn-debug.log*',
-      'yarn-error.log*',
-      '.env',
-      '.env.local',
-      '.env.production',
-      '.env.development',
-    ];
-    const allIgnore = [...new Set([...defaultIgnore, ...loadGitignorePatterns(sourceDir), ...ignore])];
+    output.on('close', () => resolve(bytes));
+    output.on('error', reject);
+    zip.outputStream.on('data', (chunk) => { bytes += chunk.length; });
+    zip.outputStream.on('error', reject);
+    zip.outputStream.pipe(output);
 
-    archive.glob('**/*', {
-      cwd: sourceDir,
-      ignore: allIgnore,
-      dot: true,
-    });
-
-    archive.finalize();
+    for (const file of files) {
+      zip.addFile(join(sourceDir, file), file);
+    }
+    zip.end();
   });
 }
 
-function loadGitignorePatterns(sourceDir) {
-  const path = join(sourceDir, '.gitignore');
-  if (!fs.existsSync(path)) return [];
+function parseIgnorePattern(line) {
+  const raw = line.trim();
+  if (!raw || raw.startsWith('#') || raw.startsWith('!')) return [];
+
+  const hasLeadingSlash = raw.startsWith('/');
+  
+  // Normalize by stripping leading and trailing slashes
+  let normalized = raw.replace(/^\/+/, '').replace(/\/+$/, '');
+  if (!normalized) return [];
+
+  const hasMiddleSlash = normalized.includes('/');
+  const isRootRelative = hasLeadingSlash || hasMiddleSlash;
 
   const patterns = [];
-  const text = fs.readFileSync(path, 'utf8');
-  for (const raw of text.split(/\r?\n/)) {
-    const line = raw.trim();
-    if (!line || line.startsWith('#') || line.startsWith('!')) continue;
-    const normalized = line.replace(/^\/+/, '').replace(/\/+$/, '');
-    if (!normalized) continue;
-    patterns.push(normalized);
-    if (!/[*!?[\]{}()]/.test(normalized)) patterns.push(`${normalized}/**`);
+  
+  // Add base patterns
+  patterns.push(normalized);
+  if (!normalized.endsWith('/**') && !normalized.endsWith('/*')) {
+    patterns.push(`${normalized}/**`);
   }
+
+  // If it's not root-relative, match at any level
+  if (!isRootRelative) {
+    patterns.push(`**/${normalized}`);
+    if (!normalized.endsWith('/**') && !normalized.endsWith('/*')) {
+      patterns.push(`**/${normalized}/**`);
+    }
+  }
+
   return patterns;
 }
+
+function loadIgnorePatterns(sourceDir) {
+  const files = ['.gitignore', '.glashignore'];
+  const allPatterns = [];
+
+  for (const filename of files) {
+    const path = join(sourceDir, filename);
+    if (!fs.existsSync(path)) continue;
+
+    const text = fs.readFileSync(path, 'utf8');
+    for (const raw of text.split(/\r?\n/)) {
+      const parsed = parseIgnorePattern(raw);
+      allPatterns.push(...parsed);
+    }
+  }
+  return allPatterns;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.7",
+  "version": "0.2.13",
   "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",
@@ -30,14 +30,14 @@
     "database"
   ],
   "dependencies": {
-    "archiver": "^7.0.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
+    "fast-glob": "^3.3.3",
     "fs-extra": "^11.2.0",
-    "node-fetch": "^3.3.2",
     "open": "^10.1.0",
-    "ora": "^8.0.1"
+    "ora": "^8.0.1",
+    "yazl": "^3.3.1"
   },
   "publishConfig": {
     "access": "public"