@glash/cli 0.1.1

package/README.md

@@ -0,0 +1,52 @@
+# @glashdb/cli
+
+The official command-line interface for [glashDB](https://glashdb.com).
+
+```
+npm install -g @glashdb/cli
+glash login
+glash deploy
+```
+
+## Commands
+
+| Command | Purpose |
+| --- | --- |
+| `glash login` | Sign in (stores a token at `~/.glash/credentials.json`) |
+| `glash logout` | Clear local credentials |
+| `glash whoami` | Show the signed-in user |
+| `glash projects` | List your projects |
+| `glash projects:new <name>` | Create a project and link it to the current directory |
+| `glash projects:rm <slug>` | Delete a project |
+| `glash link <slug>` | Link the current directory to an existing project |
+| `glash open` | Open the linked project's primary domain |
+| `glash deploy [--prod] [--detach]` | Deploy the linked project; streams the pipeline until live |
+| `glash deployments` | List recent deployments |
+| `glash status <id>` | Show a deployment's pipeline + events |
+| `glash logs <id>` | Alias of `status` |
+| `glash rollback <id>` | Roll the linked project back to a previous deployment |
+| `glash retry <id> [--fix <id>]` | Retry a failed deployment |
+| `glash env` | List env vars for the linked project |
+| `glash env:add KEY=value` | Set a single env var |
+| `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 pull --from vercel --project <id>` | Import a Vercel project (source + env) |
+
+Pass `--project <slug>` to any command to operate on a project other than
+the one linked in the current directory.
+
+## Environment
+
+| Variable | Default | Notes |
+| --- | --- | --- |
+| `GLASH_API_URL` | `https://api.glashdb.com/api` | Override the API base (self-hosted, staging) |
+| `GLASH_TOKEN` | — | Use this token instead of `~/.glash/credentials.json` (useful in CI) |
+
+## Requirements
+
+Node.js 20+. Zero runtime dependencies.
+
+## License
+
+Apache-2.0

package/bin/glash.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { argv, exit } from 'node:process';
+import { parseArgs } from '../lib/args.mjs';
+import { info, fail, color } from '../lib/ui.mjs';
+
+const VERSION = '0.1.1';
+
+const sub = argv[2];
+const rest = argv.slice(3);
+const parsed = parseArgs(rest);
+
+const commands = {
+  login:           () => import('../commands/login.mjs').then((m) => m.login(parsed)),
+  logout:          () => import('../commands/logout.mjs').then((m) => m.logout(parsed)),
+  whoami:          () => import('../commands/whoami.mjs').then((m) => m.whoami(parsed)),
+
+  projects:        () => import('../commands/projects.mjs').then((m) => m.listProjects(parsed)),
+  'projects:new':  () => import('../commands/projects.mjs').then((m) => m.createProject(parsed)),
+  'projects:rm':   () => import('../commands/projects.mjs').then((m) => m.removeProject(parsed)),
+  link:            () => import('../commands/projects.mjs').then((m) => m.linkProject(parsed)),
+
+  deploy:          () => import('../commands/deploy.mjs').then((m) => m.deploy(parsed)),
+  deployments:     () => import('../commands/deployments.mjs').then((m) => m.listDeployments(parsed)),
+  status:          () => import('../commands/deployments.mjs').then((m) => m.status(parsed)),
+  logs:            () => import('../commands/deployments.mjs').then((m) => m.logs(parsed)),
+  rollback:        () => import('../commands/deployments.mjs').then((m) => m.rollback(parsed)),
+  retry:           () => import('../commands/deployments.mjs').then((m) => m.retry(parsed)),
+
+  env:             () => import('../commands/env.mjs').then((m) => m.envList(parsed)),
+  'env:add':       () => import('../commands/env.mjs').then((m) => m.envAdd(parsed)),
+  'env:rm':        () => import('../commands/env.mjs').then((m) => m.envRm(parsed)),
+  'env:pull':      () => import('../commands/env.mjs').then((m) => m.envPull(parsed)),
+  'env:push':      () => import('../commands/env.mjs').then((m) => m.envPush(parsed)),
+
+  pull:            () => import('../commands/pull.mjs').then((m) => m.pull(parsed)),
+  open:            () => import('../commands/open.mjs').then((m) => m.open(parsed)),
+};
+
+function usage() {
+  info(`${color.bold('glash')} ${color.dim(`v${VERSION}`)} — glashDB command line
+
+${color.bold('USAGE')}
+  glash <command> [args] [flags]
+
+${color.bold('AUTH')}
+  login                       Sign in to glashDB
+  logout                      Clear local credentials
+  whoami                      Show signed-in user
+
+${color.bold('PROJECTS')}
+  projects                    List your projects
+  projects:new <name>         Create a project (auto-links to cwd)
+  projects:rm <slug>          Delete a project (--yes to skip confirm)
+  link <slug>                 Link the current directory to a project
+  open                        Open the project's primary domain in a browser
+
+${color.bold('DEPLOY')}
+  deploy [--prod] [--detach]  Deploy the linked project
+  deployments                 List recent deployments
+  status <id>                 Show deployment pipeline + events
+  logs <id>                   Stream deployment events (alias of status)
+  rollback <id>               Roll back the linked project to a deployment
+  retry <id> [--fix <id>]     Retry a failed deployment
+
+${color.bold('ENV VARS')}
+  env                         List env vars for the linked project
+  env:add KEY=value           Set a single env var
+  env:rm KEY                  Remove an env var
+  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')}
+  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)
+  --help, -h                  Show this help
+  --version, -v               Show CLI version
+
+${color.bold('ENVIRONMENT')}
+  GLASH_API_URL               Override API base (default: https://api.glashdb.com/api)
+  GLASH_TOKEN                 Use this token instead of ~/.glash/credentials.json
+`);
+}
+
+async function main() {
+  if (parsed.flags.help || parsed.flags.h) { usage(); return; }
+  if (!sub || sub === 'help' || sub === '--help' || sub === '-h') { usage(); return; }
+  if (sub === '--version' || sub === '-v' || sub === 'version') { info(VERSION); return; }
+  const handler = commands[sub];
+  if (!handler) {
+    fail(`Unknown command "${sub}". Run \`glash help\` for available commands.`);
+  }
+  try {
+    await handler();
+  } catch (e) {
+    fail(e?.message || String(e));
+  }
+}
+
+main().catch((e) => { fail(e?.message || String(e)); exit(1); });

package/commands/deploy.mjs

@@ -0,0 +1,119 @@
+import { apiGet, apiPost } from '../lib/api.mjs';
+import { readProjectLink } from '../lib/config.mjs';
+import { ok, fail, info, warn, color } from '../lib/ui.mjs';
+import { execSync } from 'node:child_process';
+import { zipDirectory } from '../lib/zip.mjs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { readFile, rm } from 'node:fs/promises';
+
+function currentCommit() {
+  try {
+    return execSync('git rev-parse HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  } catch { return undefined; }
+}
+
+function currentBranch() {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+  } catch { return undefined; }
+}
+
+async function resolveProjectId(flags) {
+  if (flags.project) {
+    if (/^[0-9a-f-]{36}$/.test(flags.project)) return flags.project;
+    const list = await apiGet('/projects');
+    const found = list.find((p) => p.slug === flags.project || p.id === flags.project);
+    if (!found) throw new Error(`No project matches "${flags.project}". Run \`glash projects\`.`);
+    return found.id;
+  }
+  const link = await readProjectLink();
+  if (!link?.projectId) {
+    throw new Error('No linked project. Run `glash link <slug>` or pass --project <slug>.');
+  }
+  return link.projectId;
+}
+
+export async function deploy({ flags }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+
+  const commitHash = flags.commit || currentCommit();
+  const gitBranch = flags.branch || currentBranch();
+  const target = flags.prod || flags.production ? 'production' : (flags.target || 'production');
+
+  let dep;
+  
+  if (!commitHash || flags.local) {
+    info(color.dim(`→ packaging local files for project ${projectId} (${target})`));
+    const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
+    try {
+      await zipDirectory(process.cwd(), zipPath);
+      const zipBuffer = await readFile(zipPath);
+      const formData = new FormData();
+      formData.append('projectId', projectId);
+      // We wrap the buffer in a Blob so fetch treats it as a file
+      formData.append('file', new Blob([zipBuffer]), 'project.zip');
+      
+      dep = await apiPost('/deployments/upload', formData);
+      await rm(zipPath, { force: true }).catch(() => {});
+    } catch (e) {
+      await rm(zipPath, { force: true }).catch(() => {});
+      return fail(`Packaging failed: ${e.message}`);
+    }
+  } else {
+    info(color.dim(`→ deploying project ${projectId}${commitHash ? ` @ ${commitHash.slice(0, 7)}` : ''} (${target})`));
+    try {
+      dep = await apiPost('/deployments', { projectId, commitHash, gitBranch, target });
+    } catch (e) {
+      return fail(e.message);
+    }
+  }
+  
+  ok(`Deployment ${color.bold(dep.id)} queued`);
+
+  if (flags.detach || flags.D) {
+    info(`Track it with: ${color.cyan(`glash status ${dep.id}`)}`);
+    return;
+  }
+
+  // Poll the pipeline until it terminates.
+  const seen = new Set();
+  let lastStatus = '';
+  const start = 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; }
+
+    for (const ev of pipe.events ?? []) {
+      const key = `${ev.id ?? ev.createdAt}:${ev.step}:${ev.status}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const tag = stepBadge(ev.status);
+      info(`  ${tag} ${color.dim(ev.step.padEnd(8))} ${ev.message ?? ''}`);
+    }
+
+    const status = pipe.deployment?.deployStatus ?? pipe.deployment?.buildStatus ?? '';
+    if (status && status !== lastStatus) lastStatus = status;
+    if (['ready', 'live', 'success'].includes(status)) {
+      const url = pipe.deployment?.url || pipe.domain?.domain;
+      ok(`Live${url ? ` → ${color.cyan(`https://${url.replace(/^https?:\/\//, '')}`)}` : ''}`);
+      return;
+    }
+    if (['error', 'failed'].includes(status)) {
+      return fail(`Deployment failed (${status}). Run \`glash logs ${dep.id}\` for details.`);
+    }
+    await sleep(2500);
+  }
+  warn('Timed out waiting for deployment. Check `glash status <id>`.');
+}
+
+function stepBadge(status) {
+  if (status === 'success' || status === 'issued' || status === 'active' || status === 'ready') return color.green('✓');
+  if (status === 'error' || status === 'failed') return color.red('✗');
+  if (status === 'warning') return color.yellow('!');
+  return color.cyan('•');
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/commands/deployments.mjs

@@ -0,0 +1,85 @@
+import { apiGet, apiPost } from '../lib/api.mjs';
+import { readProjectLink } from '../lib/config.mjs';
+import { table, ok, fail, info, color } from '../lib/ui.mjs';
+
+async function resolveProjectId(flags) {
+  if (flags.project) {
+    if (/^[0-9a-f-]{36}$/.test(flags.project)) return flags.project;
+    const list = await apiGet('/projects');
+    const found = list.find((p) => p.slug === flags.project);
+    if (!found) throw new Error(`No project "${flags.project}"`);
+    return found.id;
+  }
+  const link = await readProjectLink();
+  if (!link?.projectId) throw new Error('No linked project. Pass --project <slug> or run `glash link`.');
+  return link.projectId;
+}
+
+export async function listDeployments({ flags }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const rows = await apiGet('/deployments', { query: { projectId } });
+  table(rows, [
+    { label: 'ID',     get: (r) => r.id.slice(0, 8) },
+    { label: 'STATUS', get: (r) => r.deployStatus ?? r.buildStatus ?? '-' },
+    { label: 'COMMIT', get: (r) => (r.commitHash ?? '').slice(0, 7) },
+    { label: 'BRANCH', get: (r) => r.gitBranch ?? '-' },
+    { label: 'AGE',    get: (r) => age(r.createdAt) },
+  ]);
+}
+
+export async function status({ positional, flags }) {
+  const id = positional[0] || flags.id;
+  if (!id) return fail('Usage: glash status <deployment-id>');
+  try {
+    const pipe = await apiGet(`/deployments/${id}/pipeline`);
+    info(color.bold(`Deployment ${id}`));
+    info(color.dim(`status: ${pipe.deployment?.deployStatus ?? pipe.deployment?.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 ?? ''}`);
+    }
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+export async function logs({ positional, flags }) {
+  // Logs are exposed via the pipeline endpoint for now (each event = a log line).
+  // When a dedicated /logs endpoint ships, swap in here.
+  return status({ positional, flags });
+}
+
+export async function rollback({ flags, positional }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const deploymentId = positional[0] || flags.to;
+  if (!deploymentId) return fail('Usage: glash rollback <deployment-id>');
+  try {
+    await apiPost('/deployments/rollback', { projectId, deploymentId });
+    ok(`Rolled back to ${deploymentId}`);
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+export async function retry({ flags, positional }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const deploymentId = positional[0];
+  if (!deploymentId) return fail('Usage: glash retry <deployment-id>');
+  try {
+    const r = await apiPost('/deployments/retry', { projectId, deploymentId, autoFixId: flags.fix });
+    ok(`Retry queued (${r.id ?? 'ok'})`);
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+function age(iso) {
+  if (!iso) return '-';
+  const d = (Date.now() - new Date(iso).getTime()) / 1000;
+  if (d < 60) return `${Math.floor(d)}s`;
+  if (d < 3600) return `${Math.floor(d / 60)}m`;
+  if (d < 86400) return `${Math.floor(d / 3600)}h`;
+  return `${Math.floor(d / 86400)}d`;
+}

package/commands/env.mjs

@@ -0,0 +1,110 @@
+import { apiGet, apiPost, apiDel } from '../lib/api.mjs';
+import { readProjectLink } from '../lib/config.mjs';
+import { table, ok, fail, info, color } from '../lib/ui.mjs';
+import { readFile, writeFile } from 'node:fs/promises';
+
+async function resolveProjectId(flags) {
+  if (flags.project) {
+    if (/^[0-9a-f-]{36}$/.test(flags.project)) return flags.project;
+    const list = await apiGet('/projects');
+    const found = list.find((p) => p.slug === flags.project);
+    if (!found) throw new Error(`No project "${flags.project}"`);
+    return found.id;
+  }
+  const link = await readProjectLink();
+  if (!link?.projectId) throw new Error('No linked project. Pass --project <slug> or run `glash link`.');
+  return link.projectId;
+}
+
+function parseDotenv(text) {
+  const out = [];
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (!line || line.startsWith('#')) continue;
+    const eq = line.indexOf('=');
+    if (eq === -1) 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: line.slice(0, eq).trim(), value });
+  }
+  return out;
+}
+
+export async function envList({ flags }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const rows = await apiGet(`/projects/${projectId}/env-vars`, { query: { environment: flags.environment } });
+  table(rows, [
+    { label: 'KEY',   get: (r) => r.key },
+    { label: 'VALUE', get: (r) => maskValue(r) },
+    { label: 'ENV',   get: (r) => r.environment ?? 'production' },
+  ]);
+}
+
+function maskValue(r) {
+  if (r.e2ee) return color.dim('(encrypted)');
+  const v = r.value ?? '';
+  if (v.length <= 4) return '*'.repeat(v.length);
+  return v.slice(0, 2) + '*'.repeat(Math.max(0, v.length - 4)) + v.slice(-2);
+}
+
+export async function envAdd({ flags, positional }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const arg = positional[0];
+  if (!arg || !arg.includes('=')) return fail('Usage: glash env:add KEY=value [--environment production]');
+  const key = arg.slice(0, arg.indexOf('='));
+  const value = arg.slice(arg.indexOf('=') + 1);
+  try {
+    await apiPost(`/projects/${projectId}/env-vars`, {
+      key, value,
+      environment: flags.environment ?? 'production',
+    });
+    ok(`Set ${key}`);
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+export async function envRm({ flags, positional }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const key = positional[0];
+  if (!key) return fail('Usage: glash env:rm <KEY>');
+  const all = await apiGet(`/projects/${projectId}/env-vars`);
+  const target = all.find((r) => r.key === key && (!flags.environment || r.environment === flags.environment));
+  if (!target) return fail(`No env var "${key}" found`);
+  await apiDel(`/projects/${projectId}/env-vars/${target.id}`);
+  ok(`Removed ${key}`);
+}
+
+export async function envPull({ flags }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const out = flags.out || '.env.local';
+  const rows = await apiGet(`/projects/${projectId}/env-vars`, { query: { environment: flags.environment ?? 'production' } });
+  const lines = rows
+    .filter((r) => !r.e2ee)
+    .map((r) => `${r.key}=${JSON.stringify(r.value ?? '')}`);
+  await writeFile(out, lines.join('\n') + '\n');
+  ok(`Wrote ${lines.length} vars to ${out}`);
+}
+
+export async function envPush({ flags, positional }) {
+  let projectId;
+  try { projectId = await resolveProjectId(flags); } catch (e) { return fail(e.message); }
+  const file = positional[0] || flags.file || '.env.local';
+  const text = await readFile(file, 'utf8').catch(() => { fail(`Cannot read ${file}`); });
+  const vars = parseDotenv(text).map((v) => ({
+    ...v, environment: flags.environment ?? 'production',
+  }));
+  if (!vars.length) return fail(`No vars parsed from ${file}`);
+  try {
+    await apiPost(`/projects/${projectId}/env-vars/bulk`, { vars });
+    ok(`Pushed ${vars.length} vars from ${file}`);
+  } catch (e) {
+    fail(e.message);
+  }
+}

package/commands/login.mjs

@@ -0,0 +1,17 @@
+import { apiPost } from '../lib/api.mjs';
+import { writeCreds } from '../lib/config.mjs';
+import { prompt, ok, fail } from '../lib/ui.mjs';
+
+export async function login({ flags }) {
+  const email = flags.email || (await prompt('Email: '));
+  const password = flags.password || (await prompt('Password: ', { mask: true }));
+  if (!email || !password) return fail('email and password required');
+
+  try {
+    const r = await apiPost('/auth/login', { email, password });
+    await writeCreds({ token: r.accessToken, email: r.user?.email });
+    ok(`Signed in as ${r.user?.email ?? email}`);
+  } catch (e) {
+    fail(e.message);
+  }
+}

package/commands/logout.mjs

@@ -0,0 +1,7 @@
+import { clearCreds } from '../lib/config.mjs';
+import { ok } from '../lib/ui.mjs';
+
+export async function logout() {
+  await clearCreds();
+  ok('Signed out');
+}

package/commands/open.mjs

@@ -0,0 +1,23 @@
+import { apiGet } from '../lib/api.mjs';
+import { readProjectLink } from '../lib/config.mjs';
+import { fail, info, color } from '../lib/ui.mjs';
+import { spawn } from 'node:child_process';
+import { platform } from 'node:process';
+
+export async function open({ flags }) {
+  const link = await readProjectLink();
+  if (!link?.projectId && !flags.project) return fail('No linked project. Run `glash link` first.');
+  const projectId = link?.projectId;
+  let url;
+  try {
+    const p = await apiGet(`/projects/${projectId}`);
+    const primary = p.domains?.find((d) => d.isPrimary) ?? p.domains?.[0];
+    if (!primary) return fail('Project has no domains yet — deploy first.');
+    url = `https://${primary.domain}`;
+  } catch (e) {
+    return fail(e.message);
+  }
+  info(color.dim(`→ ${url}`));
+  const opener = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+  spawn(opener, [url], { stdio: 'ignore', detached: true }).unref();
+}

package/commands/projects.mjs

@@ -0,0 +1,67 @@
+import { apiGet, apiPost, apiDel } from '../lib/api.mjs';
+import { writeProjectLink } from '../lib/config.mjs';
+import { table, ok, fail, info, color, prompt } from '../lib/ui.mjs';
+import { basename } from 'node:path';
+
+export async function listProjects() {
+  const rows = await apiGet('/projects');
+  table(rows, [
+    { label: 'SLUG',      get: (r) => r.slug },
+    { label: 'NAME',      get: (r) => r.name },
+    { label: 'FRAMEWORK', get: (r) => r.framework ?? '-' },
+    { label: 'STATUS',    get: (r) => r.status ?? '-' },
+    { label: 'ID',        get: (r) => r.id },
+  ]);
+}
+
+export async function createProject({ flags, positional }) {
+  const name = flags.name || positional[0] || (await prompt('Project name: '));
+  const slug = flags.slug || name.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '');
+  const framework = flags.framework;
+  const repositoryUrl = flags.repo || flags.repositoryUrl;
+  try {
+    const p = await apiPost('/projects', { name, slug, framework, repositoryUrl });
+    ok(`Created ${color.bold(p.slug)} (${p.id})`);
+    if (flags.link !== false) {
+      await writeProjectLink({ projectId: p.id, slug: p.slug });
+      info(color.dim('Linked current directory to this project (.glash/project.json).'));
+    }
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+export async function linkProject({ flags, positional }) {
+  let slug = flags.slug || positional[0];
+  if (!slug) {
+    const guess = basename(process.cwd()).toLowerCase().replace(/[^a-z0-9-]+/g, '-');
+    slug = (await prompt(`Project slug [${guess}]: `)) || guess;
+  }
+  try {
+    const all = await apiGet('/projects');
+    const p = all.find((x) => x.slug === slug || x.id === slug);
+    if (!p) return fail(`No project found matching "${slug}". Run \`glash projects\` to list.`);
+    await writeProjectLink({ projectId: p.id, slug: p.slug });
+    ok(`Linked to ${color.bold(p.slug)} (${p.id})`);
+  } catch (e) {
+    fail(e.message);
+  }
+}
+
+export async function removeProject({ flags, positional }) {
+  const slug = flags.slug || positional[0];
+  if (!slug) return fail('Provide a project slug: glash projects:rm <slug>');
+  if (!flags.yes) {
+    const a = await prompt(`Type the slug to confirm deletion of "${slug}": `);
+    if (a !== slug) return fail('Aborted');
+  }
+  try {
+    const all = await apiGet('/projects');
+    const p = all.find((x) => x.slug === slug || x.id === slug);
+    if (!p) return fail(`No project found matching "${slug}"`);
+    await apiDel(`/projects/${p.id}`);
+    ok(`Deleted ${slug}`);
+  } catch (e) {
+    fail(e.message);
+  }
+}

package/commands/pull.mjs

@@ -0,0 +1,13 @@
+// Thin shim — delegates to the existing reference implementation so we
+// don't duplicate the Vercel walk logic.
+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);
+}

package/commands/whoami.mjs

@@ -0,0 +1,15 @@
+import { apiGet } from '../lib/api.mjs';
+import { getToken, API_URL } from '../lib/config.mjs';
+import { info, fail, color } from '../lib/ui.mjs';
+
+export async function whoami() {
+  const token = await getToken();
+  if (!token) return fail('Not signed in. Run `glash login`.');
+  try {
+    const me = await apiGet('/auth/me');
+    info(`${color.bold(me.email)}  ${color.dim(`(${me.role})`)}`);
+    info(color.dim(`API: ${API_URL}`));
+  } catch (e) {
+    fail(`${e.message} — try \`glash login\` again`);
+  }
+}

package/glash-pull.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+/**
+ * glash pull — reference implementation
+ *
+ *   glash pull --from vercel --project <id> [--team <id>] [--token <vercel-token>] [--out .]
+ *
+ * Pulls the latest production deployment from Vercel into the current
+ * working directory:
+ *   • walks /v6/deployments/<uid>/files
+ *   • downloads each file via /v7/deployments/<uid>/files/<file-uid>
+ *   • writes them at the same paths locally
+ *   • dumps env vars to .env.local
+ *
+ * Token sources, in order: --token flag, $VERCEL_TOKEN, ~/.glash/credentials.json (vercelToken).
+ *
+ * No external deps — pure Node 20+. The shipping `@glashdb/cli` wraps this
+ * with a nicer UX (interactive prompts, progress bars, `glash login`-aware).
+ */
+
+import { argv, env, exit, cwd, stdout, stderr } from 'node:process';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+
+const VERCEL = 'https://api.vercel.com';
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const k = a.slice(2);
+      const v = argv[i + 1] && !argv[i + 1].startsWith('--') ? argv[++i] : 'true';
+      out[k] = v;
+    }
+  }
+  return out;
+}
+
+async function readToken(flag) {
+  if (flag) return flag;
+  if (env.VERCEL_TOKEN) return env.VERCEL_TOKEN;
+  try {
+    const raw = await readFile(join(homedir(), '.glash', 'credentials.json'), 'utf8');
+    const j = JSON.parse(raw);
+    if (j.vercelToken) return j.vercelToken;
+  } catch {}
+  stderr.write("error: no Vercel token. Pass --token, set VERCEL_TOKEN, or run `glash login --vercel`.\n");
+  exit(2);
+}
+
+async function vercel(token, path, teamId) {
+  const url = `${VERCEL}${path}${teamId ? (path.includes('?') ? '&' : '?') + 'teamId=' + encodeURIComponent(teamId) : ''}`;
+  const r = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!r.ok) throw new Error(`Vercel ${r.status} ${r.statusText} on ${path}`);
+  return r.json();
+}
+
+async function vercelRaw(token, path, teamId) {
+  const url = `${VERCEL}${path}${teamId ? (path.includes('?') ? '&' : '?') + 'teamId=' + encodeURIComponent(teamId) : ''}`;
+  const r = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+  if (!r.ok) throw new Error(`Vercel ${r.status} on ${path}`);
+  return Buffer.from(await r.arrayBuffer());
+}
+
+async function walk(token, deploymentUid, teamId, tree, prefix, out) {
+  for (const node of tree) {
+    const rel = prefix ? `${prefix}/${node.name}` : node.name;
+    if (node.type === 'directory' && node.children) {
+      await walk(token, deploymentUid, teamId, node.children, rel, out);
+    } else if (node.type === 'file' && node.uid) {
+      out.push({ rel, uid: node.uid });
+    }
+  }
+}
+
+async function main() {
+  const args = parseArgs(argv);
+  if (args.from !== 'vercel') {
+    stderr.write("usage: glash pull --from vercel --project <id> [--team <id>] [--out .]\n");
+    exit(2);
+  }
+  if (!args.project) { stderr.write("error: --project <vercel-project-id> required\n"); exit(2); }
+
+  const token = await readToken(args.token);
+  const team = args.team;
+  const outDir = args.out || cwd();
+
+  stdout.write(`→ pulling vercel project ${args.project}${team ? ` (team ${team})` : ''} into ${outDir}\n`);
+
+  // 1) latest production deployment
+  const list = await vercel(token, `/v6/deployments?projectId=${encodeURIComponent(args.project)}&limit=1&target=production&state=READY`, team);
+  const dep = list.deployments?.[0];
+  if (!dep) { stderr.write("error: no production deployment on Vercel for that project.\n"); exit(1); }
+  stdout.write(`✓ deployment ${dep.uid}\n`);
+
+  // 2) file tree
+  const tree = await vercel(token, `/v6/deployments/${dep.uid}/files`, team);
+  const files = [];
+  await walk(token, dep.uid, team, tree, '', files);
+  stdout.write(`✓ ${files.length} files to download\n`);
+
+  // 3) write each file
+  let n = 0;
+  for (const f of files) {
+    const buf = await vercelRaw(token, `/v7/deployments/${dep.uid}/files/${f.uid}`, team);
+    const dest = join(outDir, f.rel);
+    await mkdir(dirname(dest), { recursive: true });
+    await writeFile(dest, buf);
+    n++;
+    if (n % 10 === 0 || n === files.length) stdout.write(`  ${n}/${files.length}\r`);
+  }
+  stdout.write(`\n✓ wrote ${n} files\n`);
+
+  // 4) env vars → .env.local
+  try {
+    const env = await vercel(token, `/v9/projects/${encodeURIComponent(args.project)}/env?decrypt=true`, team);
+    const lines = (env.envs ?? [])
+      .filter((e) => !e.target || e.target.includes('production'))
+      .map((e) => `${e.key}=${JSON.stringify(e.value ?? '')}`);
+    if (lines.length) {
+      await writeFile(join(outDir, '.env.local'), lines.join('\n') + '\n');
+      stdout.write(`✓ wrote ${lines.length} env vars to .env.local\n`);
+    }
+  } catch (e) {
+    stdout.write(`! skipped env vars: ${e.message}\n`);
+  }
+
+  stdout.write(`done.\n  next:  cd ${outDir} && glash deploy\n`);
+}
+
+main().catch((e) => { stderr.write(`error: ${e.message}\n`); exit(1); });

package/lib/api.mjs

@@ -0,0 +1,51 @@
+import { API_URL, getToken } from './config.mjs';
+
+export class GlashApiError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+}
+
+export async function api(method, path, { body, token, query } = {}) {
+  const headers = { Accept: 'application/json' };
+  const t = token ?? (await getToken());
+  if (t) headers.Authorization = `Bearer ${t}`;
+  if (body !== undefined && !(body instanceof FormData)) {
+    headers['Content-Type'] = 'application/json';
+  }
+
+  let url = `${API_URL}${path}`;
+  if (query) {
+    const qs = new URLSearchParams(
+      Object.entries(query).filter(([, v]) => v !== undefined && v !== null),
+    ).toString();
+    if (qs) url += (url.includes('?') ? '&' : '?') + qs;
+  }
+
+  const res = await fetch(url, {
+    method,
+    headers,
+    body: body instanceof FormData ? body : (body === undefined ? undefined : JSON.stringify(body)),
+  });
+
+  if (!res.ok) {
+    let message = `HTTP ${res.status}`;
+    try {
+      const data = await res.json();
+      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 === 204) return undefined;
+  const text = await res.text();
+  if (!text) return undefined;
+  try { return JSON.parse(text); } catch { return text; }
+}
+
+export const apiGet = (p, opts) => api('GET', p, opts);
+export const apiPost = (p, body, opts) => api('POST', p, { ...opts, body });
+export const apiPatch = (p, body, opts) => api('PATCH', p, { ...opts, body });
+export const apiDel = (p, opts) => api('DELETE', p, opts);

package/lib/args.mjs

@@ -0,0 +1,38 @@
+// Tiny argv parser. Supports --flag value, --flag=value, -f shorthand,
+// boolean flags, and a positional argument list.
+export function parseArgs(argv) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--') {
+      positional.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      if (eq !== -1) {
+        flags[a.slice(2, eq)] = a.slice(eq + 1);
+      } else {
+        const k = a.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith('-')) {
+          flags[k] = next; i++;
+        } else {
+          flags[k] = true;
+        }
+      }
+    } else if (a.startsWith('-') && a.length > 1) {
+      const k = a.slice(1);
+      const next = argv[i + 1];
+      if (next !== undefined && !next.startsWith('-')) {
+        flags[k] = next; i++;
+      } else {
+        flags[k] = true;
+      }
+    } else {
+      positional.push(a);
+    }
+  }
+  return { flags, positional };
+}

package/lib/config.mjs

@@ -0,0 +1,55 @@
+import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { env } from 'node:process';
+
+const HOME_DIR = join(homedir(), '.glash');
+const CREDS_FILE = join(HOME_DIR, 'credentials.json');
+const PROJECT_FILE = join(process.cwd(), '.glash', 'project.json');
+
+export const API_URL = (env.GLASH_API_URL || 'https://api.glashdb.com/api').replace(/\/$/, '');
+
+export async function readCreds() {
+  try {
+    const raw = await readFile(CREDS_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+export async function writeCreds(patch) {
+  const current = await readCreds();
+  const next = { ...current, ...patch };
+  await mkdir(HOME_DIR, { recursive: true, mode: 0o700 });
+  await writeFile(CREDS_FILE, JSON.stringify(next, null, 2), { mode: 0o600 });
+  return next;
+}
+
+export async function clearCreds() {
+  await writeFile(CREDS_FILE, JSON.stringify({}, null, 2), { mode: 0o600 });
+}
+
+export async function getToken() {
+  if (env.GLASH_TOKEN) return env.GLASH_TOKEN;
+  const c = await readCreds();
+  return c.token || null;
+}
+
+export async function readProjectLink() {
+  try {
+    const raw = await readFile(PROJECT_FILE, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function writeProjectLink(data) {
+  await mkdir(join(process.cwd(), '.glash'), { recursive: true });
+  await writeFile(PROJECT_FILE, JSON.stringify(data, null, 2));
+}
+
+export async function projectFileExists() {
+  try { await stat(PROJECT_FILE); return true; } catch { return false; }
+}

package/lib/ui.mjs

@@ -0,0 +1,50 @@
+import { stdout, stderr, stdin, exit } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+
+const isTTY = stdout.isTTY;
+const c = (code) => (s) => isTTY ? `\x1b[${code}m${s}\x1b[0m` : String(s);
+export const color = {
+  dim: c('2'),
+  bold: c('1'),
+  red: c('31'),
+  green: c('32'),
+  yellow: c('33'),
+  blue: c('34'),
+  cyan: c('36'),
+};
+
+export function info(msg) { stdout.write(`${msg}\n`); }
+export function ok(msg) { stdout.write(`${color.green('✓')} ${msg}\n`); }
+export function warn(msg) { stderr.write(`${color.yellow('!')} ${msg}\n`); }
+export function fail(msg, code = 1) { stderr.write(`${color.red('error')}: ${msg}\n`); exit(code); }
+
+export async function prompt(question, { mask = false } = {}) {
+  const rl = createInterface({ input: stdin, output: stdout, terminal: true });
+  if (!mask) {
+    const a = await rl.question(question);
+    rl.close();
+    return a.trim();
+  }
+  // Masked input — write * for each typed char. readline doesn't natively
+  // mask, so we monkey-patch the output stream for this prompt only.
+  const orig = rl._writeToOutput?.bind(rl);
+  rl._writeToOutput = (s) => {
+    if (s === question) return stdout.write(s);
+    stdout.write('*'.repeat(s.replace(/\n/g, '').length));
+  };
+  const a = await rl.question(question);
+  if (orig) rl._writeToOutput = orig;
+  rl.close();
+  stdout.write('\n');
+  return a.trim();
+}
+
+export function table(rows, columns) {
+  if (!rows.length) { info(color.dim('(none)')); return; }
+  const widths = columns.map((c) =>
+    Math.max(c.label.length, ...rows.map((r) => String(c.get(r) ?? '').length)),
+  );
+  const line = (cells) => cells.map((c, i) => String(c).padEnd(widths[i])).join('  ');
+  stdout.write(color.dim(line(columns.map((c) => c.label))) + '\n');
+  for (const r of rows) stdout.write(line(columns.map((c) => c.get(r) ?? '')) + '\n');
+}

package/lib/zip.mjs

@@ -0,0 +1,28 @@
+import archiver from 'archiver';
+import { createWriteStream } from 'node:fs';
+import { join, relative } from 'node:path';
+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 } });
+
+    output.on('close', () => resolve(archive.pointer()));
+    archive.on('error', (err) => reject(err));
+
+    archive.pipe(output);
+
+    // Default ignores
+    const defaultIgnore = ['node_modules', '.git', '.next', 'dist', '.glash', 'package-lock.json', 'yarn.lock'];
+    const allIgnore = [...new Set([...defaultIgnore, ...ignore])];
+
+    archive.glob('**/*', {
+      cwd: sourceDir,
+      ignore: allIgnore,
+      dot: true,
+    });
+
+    archive.finalize();
+  });
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@glash/cli",
+  "version": "0.1.1",
+  "description": "glashDB command-line interface — deploy projects, manage env vars, pull from Vercel.",
+  "license": "Apache-2.0",
+  "homepage": "https://glashdb.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/glashdb/glashdb.git",
+    "directory": "cli"
+  },
+  "bin": {
+    "glash": "bin/glash.mjs"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "commands",
+    "glash-pull.mjs",
+    "README.md"
+  ],
+  "keywords": [
+    "glashdb",
+    "deploy",
+    "cli",
+    "hosting",
+    "database"
+  ],
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "fs-extra": "^11.2.0",
+    "node-fetch": "^3.3.2",
+    "open": "^10.1.0",
+    "ora": "^8.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}