@glash/cli 0.1.2 → 0.2.1

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.1.2';
+const VERSION = '0.2.1';
 
 const sub = argv[2];
 const rest = argv.slice(3);
@@ -55,7 +55,7 @@ ${color.bold('PROJECTS')}
   open                        Open the project's primary domain in a browser
 
 ${color.bold('DEPLOY')}
-  deploy [--prod] [--detach]  Deploy the linked project
+  deploy [--prod] [--detach]  Deploy the linked project, syncing .env files first
   deployments                 List recent deployments
   status <id>                 Show deployment pipeline + events
   logs <id>                   Stream deployment events (alias of status)
@@ -69,12 +69,15 @@ ${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('IMPORT')}
+${color.bold('PULL')}
+  pull [<slug>] [--out dir] [--no-env]  Pull source + .env from a glashDB project
   pull --from vercel --project <id>     Pull source + env from a Vercel project
 
 ${color.bold('FLAGS')}
   --project <slug|id>         Override the linked project for this command
   --environment <name>        Env-var environment (default: production)
+  --env-file <file[,file]>    Env file(s) to sync before deploy
+  --no-env                    Skip automatic env sync during deploy
   --help, -h                  Show this help
   --version, -v               Show CLI version
 

package/commands/deploy.mjs

@@ -5,7 +5,7 @@ import { execSync } from 'node:child_process';
 import { zipDirectory } from '../lib/zip.mjs';
 import { join, basename } from 'node:path';
 import { tmpdir } from 'node:os';
-import { readFile, rm } from 'node:fs/promises';
+import { access, readFile, rm } from 'node:fs/promises';
 
 function currentCommit() {
   try {
@@ -76,9 +76,17 @@ export async function deploy({ flags }) {
   const target = flags.prod || flags.production ? 'production' : (flags.target || 'production');
 
   let dep;
+
+  if (!flags['no-env']) {
+    try {
+      await syncEnvBeforeDeploy(projectId, target, flags);
+    } catch (e) {
+      return fail(`Env sync failed: ${e.message}`);
+    }
+  }
   
-  if (!commitHash || flags.local) {
-    info(color.dim(`→ packaging local files for project ${projectId} (${target})`));
+  if (!flags.git && !flags.repo && !flags.remote) {
+    info(color.dim(`→ uploading local source for project ${projectId} (${target})`));
     const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
     try {
       await zipDirectory(process.cwd(), zipPath);
@@ -88,6 +96,10 @@ export async function deploy({ flags }) {
       // We wrap the buffer in a Blob so fetch treats it as a file
       formData.append('file', new Blob([zipBuffer]), 'project.zip');
       
+      formData.append('commitHash', commitHash || 'local-upload');
+      formData.append('gitBranch', gitBranch || '');
+      formData.append('target', target);
+
       dep = await apiPost('/deployments/upload', formData);
       await rm(zipPath, { force: true }).catch(() => {});
     } catch (e) {
@@ -95,7 +107,7 @@ export async function deploy({ flags }) {
       return fail(`Packaging failed: ${e.message}`);
     }
   } else {
-    info(color.dim(`→ deploying project ${projectId}${commitHash ? ` @ ${commitHash.slice(0, 7)}` : ''} (${target})`));
+    info(color.dim(`→ deploying connected repo for project ${projectId}${commitHash ? ` @ ${commitHash.slice(0, 7)}` : ''} (${target})`));
     try {
       dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
     } catch (e) {
@@ -127,10 +139,10 @@ export async function deploy({ flags }) {
       info(`  ${tag} ${color.dim(ev.step.padEnd(8))} ${ev.message ?? ''}`);
     }
 
-    const status = pipe.deployment?.deployStatus ?? pipe.deployment?.buildStatus ?? '';
+    const status = pipe.deployStatus ?? pipe.buildStatus ?? '';
     if (status && status !== lastStatus) lastStatus = status;
     if (['ready', 'live', 'success'].includes(status)) {
-      const url = pipe.deployment?.url || pipe.domain?.domain;
+      const url = pipe.hostings?.[0]?.domains?.[0]?.domain;
       ok(`Live${url ? ` → ${color.cyan(`https://${url.replace(/^https?:\/\//, '')}`)}` : ''}`);
       return;
     }
@@ -142,6 +154,66 @@ export async function deploy({ flags }) {
   warn('Timed out waiting for deployment. Check `glash status <id>`.');
 }
 
+async function syncEnvBeforeDeploy(projectId, target, flags) {
+  const files = await resolveEnvFiles(target, flags);
+  if (!files.length) return;
+
+  const merged = new Map();
+  for (const file of files) {
+    const text = await readFile(file, 'utf8');
+    for (const entry of parseDotenv(text)) merged.set(entry.key, entry.value);
+  }
+  const vars = [...merged.entries()]
+    .filter(([key]) => !key.startsWith('GLASH_'))
+    .map(([key, value]) => ({ key, value, environment: target }));
+
+  if (!vars.length) return;
+  await apiPost(`/projects/${projectId}/env-vars/bulk`, { vars });
+  info(color.dim(`→ synced ${vars.length} env vars from ${files.join(', ')}`));
+}
+
+async function resolveEnvFiles(target, flags) {
+  if (flags['env-file']) {
+    const files = String(flags['env-file']).split(',').map((f) => f.trim()).filter(Boolean);
+    for (const file of files) await access(file);
+    return files;
+  }
+
+  const candidates = [
+    '.env',
+    '.env.local',
+    `.env.${target}`,
+    `.env.${target}.local`,
+  ];
+  const out = [];
+  for (const file of candidates) {
+    try {
+      await access(file);
+      out.push(file);
+    } catch {}
+  }
+  return out;
+}
+
+function parseDotenv(text) {
+  const out = [];
+  for (const raw of text.split(/\r?\n/)) {
+    let line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    if (line.startsWith('export ')) line = line.slice('export '.length).trim();
+    const eq = line.indexOf('=');
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    out.push({ key, value });
+  }
+  return out;
+}
+
 function stepBadge(status) {
   if (status === 'success' || status === 'issued' || status === 'active' || status === 'ready') return color.green('✓');
   if (status === 'error' || status === 'failed') return color.red('✗');

package/commands/deployments.mjs

@@ -34,7 +34,7 @@ export async function status({ positional, flags }) {
   try {
     const pipe = await apiGet(`/deployments/${id}/pipeline`);
     info(color.bold(`Deployment ${id}`));
-    info(color.dim(`status: ${pipe.deployment?.deployStatus ?? pipe.deployment?.buildStatus ?? '?'}`));
+    info(color.dim(`status: ${pipe.deployStatus ?? pipe.buildStatus ?? '?'}`));
     for (const ev of pipe.events ?? []) {
       info(`  ${color.dim((ev.createdAt ?? '').slice(11, 19))} ${ev.step.padEnd(8)} ${ev.status.padEnd(10)} ${ev.message ?? ''}`);
     }

package/commands/pull.mjs

@@ -1,13 +1,112 @@
-// Thin shim — delegates to the existing reference implementation so we
-// don't duplicate the Vercel walk logic.
+// glash pull
+//
+// Default mode: pulls the linked glashDB project's source + .env to the
+// current directory.
+//
+//   glash pull                    → uses the linked project (.glash/project.json)
+//   glash pull <slug>             → pulls a specific project by slug
+//   glash pull --out ../somewhere → write to a different directory
+//   glash pull --no-env           → skip writing .env
+//
+// Vercel mode (unchanged): glash pull --from vercel --project <id> [--team <id>]
+// delegates to the existing reference implementation in glash-pull.mjs.
+
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-import { argv, exit } from 'node:process';
-
-export async function pull() {
-  const here = dirname(fileURLToPath(import.meta.url));
-  const script = join(here, '..', 'glash-pull.mjs');
-  const r = spawnSync(process.execPath, [script, ...argv.slice(3)], { stdio: 'inherit' });
-  exit(r.status ?? 0);
+import { dirname, join, resolve } from 'node:path';
+import { mkdir, writeFile, stat } from 'node:fs/promises';
+import { createWriteStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { argv, cwd, exit, stdout, stderr } from 'node:process';
+import { API_URL, getToken, readProjectLink } from '../lib/config.mjs';
+import { color, info, fail } from '../lib/ui.mjs';
+
+export async function pull(parsed) {
+  const flags = parsed?.flags ?? {};
+  const positional = parsed?.positional ?? [];
+
+  // Vercel-import compatibility path.
+  if (flags.from === 'vercel') {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const script = join(here, '..', 'glash-pull.mjs');
+    const r = spawnSync(process.execPath, [script, ...argv.slice(3)], { stdio: 'inherit' });
+    exit(r.status ?? 0);
+  }
+
+  const token = await getToken();
+  if (!token) return fail('Not signed in. Run `glash login` first.');
+
+  // Resolve which project to pull
+  let slugOrId = positional[0] ?? flags.project;
+  if (!slugOrId) {
+    const link = await readProjectLink();
+    if (link?.slug) slugOrId = link.slug;
+    else if (link?.projectId) slugOrId = link.projectId;
+  }
+  if (!slugOrId) {
+    return fail('No project specified. Pass `glash pull <slug>` or run `glash link <slug>` first.');
+  }
+
+  const outDir = resolve(flags.out ? String(flags.out) : cwd());
+  await mkdir(outDir, { recursive: true });
+
+  info(color.dim(`→ pulling ${slugOrId} into ${outDir}`));
+
+  // 1) source.tar.gz
+  await downloadAndExtract(token, slugOrId, outDir);
+
+  // 2) .env (unless --no-env)
+  if (!flags['no-env']) {
+    await downloadEnv(token, slugOrId, outDir, !!flags.force);
+  }
+
+  stdout.write(color.dim(`\n  next:  cd ${outDir} && glash deploy\n`));
+}
+
+async function downloadAndExtract(token, slugOrId, outDir) {
+  const url = `${API_URL}/projects/${encodeURIComponent(slugOrId)}/source.tar.gz`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    const body = await res.text().catch(() => '');
+    throw new Error(`source download failed (${res.status}): ${body.slice(0, 200) || res.statusText}`);
+  }
+  if (!res.body) throw new Error('empty response from server');
+
+  // Stream-pipe into `tar -xz -C outDir` via stdin
+  const child = spawnSync('tar', ['-xz', '-C', outDir], { input: Buffer.from(await res.arrayBuffer()) });
+  if (child.status !== 0) {
+    throw new Error(`tar extract failed: ${child.stderr?.toString() || 'unknown'}`);
+  }
+  info(color.dim(`  ✓ source written to ${outDir}`));
+}
+
+async function downloadEnv(token, slugOrId, outDir, force) {
+  const url = `${API_URL}/projects/${encodeURIComponent(slugOrId)}/env-vars/dotenv`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!res.ok) {
+    stderr.write(color.dim(`  ! skipped .env (${res.status})\n`));
+    return;
+  }
+  const body = await res.text();
+  if (!body.trim()) {
+    info(color.dim('  · no env vars set on this project'));
+    return;
+  }
+
+  // Preserve any existing .env unless --force
+  const envPath = join(outDir, '.env');
+  const exists = await stat(envPath).then(() => true).catch(() => false);
+  if (exists && !force) {
+    const backup = `${envPath}.glash-backup-${Date.now()}`;
+    await writeFile(backup, await readFileOrEmpty(envPath));
+    info(color.dim(`  · existing .env backed up → ${backup}`));
+  }
+  await writeFile(envPath, body, { mode: 0o600 });
+  const lines = body.split('\n').filter(Boolean).length;
+  info(color.dim(`  ✓ ${lines} env var${lines === 1 ? '' : 's'} written to .env`));
+}
+
+async function readFileOrEmpty(p) {
+  try { const { readFile } = await import('node:fs/promises'); return await readFile(p); }
+  catch { return ''; }
 }

package/lib/zip.mjs

@@ -14,7 +14,34 @@ export async function zipDirectory(sourceDir, outPath, { ignore = [] } = {}) {
     archive.pipe(output);
 
     // Default ignores
-    const defaultIgnore = ['node_modules', '.git', '.next', 'dist', '.glash', 'package-lock.json', 'yarn.lock'];
+    const defaultIgnore = [
+      'node_modules/**',
+      '.git/**',
+      '.next/**',
+      '.nuxt/**',
+      '.output/**',
+      '.svelte-kit/**',
+      '.vercel/**',
+      '.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, ...ignore])];
 
     archive.glob('**/*', {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@glash/cli",
-  "version": "0.1.2",
-  "description": "glashDB command-line interface — deploy projects, manage env vars, pull from Vercel.",
+  "version": "0.2.1",
+  "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars, import from Vercel.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",
   "repository": {