@glash/cli 0.2.6 → 0.2.12

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

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

package/lib/zip.mjs

@@ -6,7 +6,9 @@ import fs from 'fs-extra';
 export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
   return new Promise((resolve, reject) => {
     const output = createWriteStream(outPath);
-    const archive = archiver('zip', { zlib: { level: 9 } });
+    const rawLevel = Number(process.env.GLASH_ZIP_LEVEL ?? 1);
+    const level = Number.isInteger(rawLevel) && rawLevel >= 0 && rawLevel <= 9 ? rawLevel : 1;
+    const archive = archiver('zip', { zlib: { level } });
 
     output.on('close', () => resolve(archive.pointer()));
     archive.on('error', (err) => reject(err));
@@ -16,34 +18,61 @@ 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, ...loadGitignorePatterns(sourceDir), ...ignore])];
+    const allIgnore = [...new Set([...defaultIgnore, ...loadIgnorePatterns(sourceDir), ...ignore])];
 
     archive.glob('**/*', {
       cwd: sourceDir,
@@ -55,19 +84,51 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
   });
 }
 
-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,12 +1,12 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.6",
+  "version": "0.2.12",
   "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": {