@glash/cli 0.2.28 → 0.2.30

package/README.md

@@ -60,6 +60,50 @@ source ~/.zshrc
 npm install -g glashdb
 ```
 
+## Deployable frameworks
+
+`glash deploy` works with more than Next.js. For Node projects, glashDB can infer a build from `package.json` and your lockfile. For anything else, include a `Dockerfile` and glashDB will build and run the container.
+
+Common Node and frontend targets:
+
+| Framework or runtime | Notes |
+| --- | --- |
+| Next.js | Built and started with the Next runtime when no custom start script is present |
+| React | Works with Vite, Create React App, Gatsby, Remix, and custom React servers |
+| Vue | Works with Vue apps and Nuxt projects |
+| Svelte | Works with Svelte and SvelteKit projects |
+| Astro | Works for static or server-rendered Astro projects when the start command is configured |
+| Static sites | Plain HTML/CSS/JS, generated static output, and Hugo-style sites |
+| Node servers | Express, Fastify, NestJS, Hono, and other servers that expose a start script |
+
+Containerized targets:
+
+| Framework or runtime | Requirement |
+| --- | --- |
+| Django, FastAPI, Flask | Add a `Dockerfile` that starts the Python app |
+| Laravel, Rails | Add a `Dockerfile` with the app server and required runtime setup |
+| Go, Rust, Java, Spring | Add a `Dockerfile` that builds and runs the service |
+| Any custom runtime | Add a valid `Dockerfile` and expose the listening port |
+
+Deployment checklist:
+
+- Add a `build` script if your app needs a production build.
+- Add a `start` script for Node apps, or provide `server.js` / `index.js`.
+- Add a `Dockerfile` for non-Node apps or custom runtime needs.
+- Set required secrets with `glash env:add` or the dashboard before deploying.
+- Make sure the app listens on the expected runtime port.
+- For large `public/` folders, deploy with `--asset-mode offload` to upload public assets to glashDB object storage/CDN and keep the source bundle small.
+
+Large public folders:
+
+```bash
+# Always offload public/ before building
+glash deploy --asset-mode offload
+
+# Offload only when public/ exceeds the threshold
+glash deploy --asset-mode auto --asset-threshold 100mb
+```
+
 ## Commands
 
 | Command | Purpose |
@@ -75,6 +119,7 @@ npm install -g glashdb
 | `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 deploy --asset-mode offload` | Upload `public/` assets to object storage/CDN before zipping source |
 | `glash deployments` | List recent deployments |
 | `glash status <id>` | Show a deployment's pipeline + events |
 | `glash logs <id>` | Alias of `status` |
@@ -130,6 +175,7 @@ The commands require PostgreSQL client tools locally: `pg_dump` for dumps,
 | --- | --- | --- |
 | `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) |
+| `GLASH_ASSET_OFFLOAD_THRESHOLD` | `100mb` | Default threshold for `glash deploy --asset-mode auto` |
 
 ## Requirements
 

package/bin/glash.mjs

@@ -98,6 +98,8 @@ ${color.bold('FLAGS')}
   --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
+  --asset-mode <mode>         Public asset handling: inline, auto, offload
+  --asset-threshold <size>    Auto-offload threshold (default: 100mb)
   --help, -h                  Show this help
   --version, -v               Show CLI version
 

package/commands/deploy.mjs

@@ -1,11 +1,13 @@
 import { apiGet, apiPost } from '../lib/api.mjs';
 import { readProjectLink, writeProjectLink } from '../lib/config.mjs';
 import { ok, fail, info, warn, color, prompt } from '../lib/ui.mjs';
+import fg from 'fast-glob';
 import { execSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { zipDirectory } from '../lib/zip.mjs';
-import { join, basename } from 'node:path';
+import { join, basename, extname } from 'node:path';
 import { tmpdir } from 'node:os';
-import { openAsBlob } from 'node:fs';
+import { createReadStream, openAsBlob } from 'node:fs';
 import { access, readFile, rm, stat } from 'node:fs/promises';
 import { stdout } from 'node:process';
 
@@ -132,9 +134,11 @@ export async function deploy({ flags }) {
   const commitHash = flags.commit || (remoteDeploy ? undefined : currentCommit());
   const gitBranch = flags.branch || currentBranch();
   const target = flags.prod || flags.production ? 'production' : (flags.target || 'production');
+  const requestedAssetMode = assetMode(flags);
 
   let dep;
   let envSummary = { count: 0, skipped: Boolean(flags['no-env']) };
+  let assetSummary = { mode: requestedAssetMode, status: requestedAssetMode === 'inline' ? 'inline' : 'pending', offloaded: false, count: 0, bytes: 0, skipped: 0 };
   let currentPhase = 'doing';
   const start = Date.now();
   const indicator = createDeployIndicator();
@@ -148,6 +152,7 @@ export async function deploy({ flags }) {
     filesIncluded: 0,
     deploymentSizeBytes: 0,
     envSummary,
+    assetSummary,
     liveUrl: '',
     error: '',
     start,
@@ -166,12 +171,32 @@ export async function deploy({ flags }) {
       return fail(`Env sync failed: ${e.message}`);
     }
   }
+
+  if (!remoteDeploy && assetSummary.mode !== 'inline') {
+    indicator.setPhase('assets');
+    try {
+      assetSummary = await offloadPublicAssetsBeforeDeploy(projectId, flags);
+      report.assetSummary = assetSummary;
+    } catch (e) {
+      const failedAssetSummary = e.assetSummary ?? { ...assetSummary, status: 'failed', error: e.message };
+      assetSummary = failedAssetSummary;
+      report.assetSummary = failedAssetSummary;
+      indicator.fail('failed');
+      printDeployReport({ ...report, assetSummary: failedAssetSummary, status: 'failed', error: `Public asset offload failed: ${e.message}` });
+      return fail(`Public asset offload failed: ${e.message}`);
+    }
+  } else if (assetSummary.mode !== 'inline') {
+    indicator.fail('failed');
+    const message = '--asset-mode is only available for local source uploads, not remote git deploys.';
+    printDeployReport({ ...report, status: 'failed', error: message });
+    return fail(message);
+  }
   
   if (!remoteDeploy) {
     indicator.setPhase('packaging');
     const zipPath = join(tmpdir(), `glash-deploy-${Date.now()}.zip`);
     try {
-      const bundle = await zipDirectory(process.cwd(), zipPath);
+      const bundle = await zipDirectory(process.cwd(), zipPath, { ignore: assetSummary.offloaded ? ['public/**'] : [] });
       const zipStat = await stat(zipPath);
       report.filesIncluded = bundle.fileCount ?? 0;
       report.deploymentSizeBytes = zipStat.size || bundle.bytes || 0;
@@ -312,6 +337,196 @@ async function syncEnvBeforeDeploy(projectId, target, flags) {
   return { count: vars.length, files };
 }
 
+async function offloadPublicAssetsBeforeDeploy(projectId, flags) {
+  const mode = assetMode(flags);
+  const empty = { mode, status: mode === 'inline' ? 'inline' : 'pending', offloaded: false, count: 0, bytes: 0, skipped: 0 };
+  if (mode === 'inline') return empty;
+
+  const files = await publicAssetFiles(process.cwd());
+  if (!files.length) return { ...empty, status: 'no-public-assets' };
+
+  const totalBytes = files.reduce((sum, file) => sum + file.sizeBytes, 0);
+  const threshold = assetOffloadThresholdBytes(flags);
+  if (mode === 'auto' && totalBytes < threshold) {
+    return { ...empty, status: 'below-threshold', count: files.length, bytes: totalBytes, thresholdBytes: threshold };
+  }
+
+  const assets = [];
+  for (const file of files) {
+    assets.push({
+      path: file.path,
+      sizeBytes: file.sizeBytes,
+      sha256: await hashFile(file.absolutePath),
+      contentType: contentTypeFor(file.path),
+    });
+  }
+
+  let uploaded = 0;
+  let skipped = 0;
+  for (const batch of chunk(assets, 100)) {
+    let prepared;
+    try {
+      prepared = await apiPost(`/projects/${projectId}/public-assets/prepare`, { assets: batch });
+    } catch (e) {
+      throw assetOffloadFailure(e, { mode, status: 'prepare-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes });
+    }
+    for (const asset of prepared.assets ?? []) {
+      if (asset.skipped) {
+        skipped += 1;
+        continue;
+      }
+      if (!asset.uploadUrl) throw new Error(`No upload URL returned for ${asset.path}`);
+      const local = assets.find((item) => item.path === asset.path);
+      if (!local) throw new Error(`Prepared unknown asset ${asset.path}`);
+      const blob = await openAsBlob(join(process.cwd(), 'public', asset.path), { type: local.contentType });
+      const res = await fetch(asset.uploadUrl, {
+        method: asset.method || 'PUT',
+        headers: { 'Content-Type': local.contentType },
+        body: blob,
+      });
+      if (!res.ok) {
+        const detail = await res.text().catch(() => '');
+        throw assetOffloadFailure(
+          new Error(`Upload ${asset.path} failed with HTTP ${res.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`),
+          { mode, status: 'upload-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes },
+        );
+      }
+      uploaded += 1;
+    }
+    try {
+      await apiPost(`/projects/${projectId}/public-assets/complete`, { assets: batch });
+    } catch (e) {
+      throw assetOffloadFailure(e, { mode, status: 'complete-failed', offloaded: false, count: assets.length, uploaded, skipped, bytes: totalBytes });
+    }
+  }
+
+  return {
+    mode,
+    status: 'offloaded',
+    offloaded: true,
+    count: assets.length,
+    uploaded,
+    skipped,
+    bytes: totalBytes,
+  };
+}
+
+function assetOffloadFailure(error, assetSummary) {
+  const message = friendlyAssetOffloadError(error);
+  const wrapped = new Error(message);
+  wrapped.cause = error;
+  wrapped.status = error?.status;
+  wrapped.assetSummary = { ...assetSummary, error: message };
+  return wrapped;
+}
+
+function friendlyAssetOffloadError(error) {
+  const message = error?.message || String(error);
+  if (error?.status === 404 && /public-assets\/prepare|public-assets/i.test(message)) {
+    return 'This GlashDB API does not support public asset offload yet. Deploy the backend public-assets route and router update, then retry.';
+  }
+  if (error?.status === 503 && /Public asset storage is not configured|storage is not configured/i.test(message)) {
+    return 'Public asset storage is not configured on this GlashDB API. Set the R2 asset storage secrets, redeploy the backend, then retry.';
+  }
+  return message;
+}
+
+function assetMode(flags) {
+  const raw = String(flags['asset-mode'] ?? flags.assets ?? flags['public-assets'] ?? 'inline').toLowerCase();
+  if (['inline', 'offload', 'auto'].includes(raw)) return raw;
+  throw new Error(`Unsupported --asset-mode "${raw}". Use inline, auto, or offload.`);
+}
+
+async function publicAssetFiles(cwd) {
+  const entries = await fg('public/**/*', {
+    cwd,
+    onlyFiles: true,
+    dot: true,
+    followSymbolicLinks: false,
+  });
+  const out = [];
+  for (const entry of entries) {
+    const absolutePath = join(cwd, entry);
+    const s = await stat(absolutePath);
+    out.push({
+      path: entry.replace(/^public\//, ''),
+      absolutePath,
+      sizeBytes: s.size,
+    });
+  }
+  return out;
+}
+
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash('sha256');
+    const stream = createReadStream(file);
+    stream.on('data', (chunk) => hash.update(chunk));
+    stream.on('error', reject);
+    stream.on('end', () => resolve(hash.digest('hex')));
+  });
+}
+
+function contentTypeFor(path) {
+  const ext = extname(path).toLowerCase();
+  const types = {
+    '.avif': 'image/avif',
+    '.css': 'text/css; charset=utf-8',
+    '.gif': 'image/gif',
+    '.html': 'text/html; charset=utf-8',
+    '.ico': 'image/x-icon',
+    '.jpeg': 'image/jpeg',
+    '.jpg': 'image/jpeg',
+    '.js': 'text/javascript; charset=utf-8',
+    '.json': 'application/json',
+    '.m4v': 'video/x-m4v',
+    '.map': 'application/json',
+    '.mp3': 'audio/mpeg',
+    '.mp4': 'video/mp4',
+    '.ogg': 'audio/ogg',
+    '.otf': 'font/otf',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.svg': 'image/svg+xml',
+    '.ttf': 'font/ttf',
+    '.txt': 'text/plain; charset=utf-8',
+    '.wav': 'audio/wav',
+    '.webm': 'video/webm',
+    '.webp': 'image/webp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.xml': 'application/xml',
+  };
+  return types[ext] || 'application/octet-stream';
+}
+
+function assetOffloadThresholdBytes(flags) {
+  return parseByteSize(flags['asset-threshold'] ?? process.env.GLASH_ASSET_OFFLOAD_THRESHOLD ?? '100mb');
+}
+
+function parseByteSize(value) {
+  if (typeof value === 'number') return value;
+  const raw = String(value || '').trim().toLowerCase();
+  const match = raw.match(/^(\d+(?:\.\d+)?)\s*(b|kb|kib|mb|mib|gb|gib)?$/);
+  if (!match) throw new Error(`Invalid asset threshold "${value}"`);
+  const amount = Number(match[1]);
+  const unit = match[2] || 'b';
+  const multiplier = unit === 'gb' || unit === 'gib'
+    ? 1024 ** 3
+    : unit === 'mb' || unit === 'mib'
+      ? 1024 ** 2
+      : unit === 'kb' || unit === 'kib'
+        ? 1024
+        : 1;
+  return Math.round(amount * multiplier);
+}
+
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
+
 async function resolveEnvFiles(target, flags) {
   if (flags['env-file']) {
     const files = String(flags['env-file']).split(',').map((f) => f.trim()).filter(Boolean);
@@ -457,10 +672,12 @@ function printDeployReport(report) {
   const liveUrl = report.liveUrl ? terminalLink(report.liveUrl) : '-';
   const rows = [
     ['Status', formatReportStatus(report.status)],
+    ['Project ID', report.projectId || '-'],
     ['Deployment ID', report.deploymentId || '-'],
     ['Target', report.target || 'production'],
     ['Source', report.source || '-'],
     ['Packages uploaded', formatPackagesUploaded(report)],
+    ['Public assets', formatAssetSummary(report.assetSummary)],
     ['Deployment size', formatDeploymentSize(report)],
     ['Total time spent', formatMinutes(elapsedMs)],
     ['Live URL', liveUrl],
@@ -493,6 +710,32 @@ function formatPackagesUploaded(report) {
   return `${count.toLocaleString()} ${label}${files}`;
 }
 
+function formatAssetSummary(assetSummary) {
+  if (!assetSummary || assetSummary.mode === 'inline') return 'inline (bundled with source)';
+  if (assetSummary.status === 'pending') return `${assetSummary.mode} requested`;
+  if (assetSummary.status === 'no-public-assets') return `${assetSummary.mode}, no public assets found`;
+  if (assetSummary.status === 'below-threshold') {
+    return `auto kept inline (${formatBytes(assetSummary.bytes)} below ${formatBytes(assetSummary.thresholdBytes)})`;
+  }
+  if (assetSummary.status === 'prepare-failed') {
+    return `prepare failed (${(assetSummary.count ?? 0).toLocaleString()} assets, ${formatBytes(assetSummary.bytes)})`;
+  }
+  if (assetSummary.status === 'upload-failed') {
+    return `upload failed (${(assetSummary.uploaded ?? 0).toLocaleString()}/${(assetSummary.count ?? 0).toLocaleString()} uploaded, ${formatBytes(assetSummary.bytes)})`;
+  }
+  if (assetSummary.status === 'complete-failed') {
+    return `activation failed (${(assetSummary.uploaded ?? 0).toLocaleString()} uploaded, ${formatBytes(assetSummary.bytes)})`;
+  }
+  if (assetSummary.status === 'failed') return `failed${assetSummary.error ? ` (${assetSummary.error})` : ''}`;
+  if (!assetSummary.offloaded) {
+    const size = assetSummary.bytes ? ` (${formatBytes(assetSummary.bytes)})` : '';
+    return `${assetSummary.mode}, no offload${size}`;
+  }
+  const uploaded = assetSummary.uploaded ?? Math.max(0, (assetSummary.count ?? 0) - (assetSummary.skipped ?? 0));
+  const skipped = assetSummary.skipped ? `, ${assetSummary.skipped.toLocaleString()} reused` : '';
+  return `${assetSummary.count.toLocaleString()} assets offloaded (${formatBytes(assetSummary.bytes)}; ${uploaded.toLocaleString()} uploaded${skipped})`;
+}
+
 function formatDeploymentSize(report) {
   if (report.deploymentSizeBytes) return formatBytes(report.deploymentSizeBytes);
   return report.source === 'remote git deploy' ? 'not measured for remote deploy' : '-';
@@ -603,6 +846,7 @@ function progressFromPhase(phase) {
   const progressByPhase = {
     doing: 2,
     syncing: 8,
+    assets: 15,
     packaging: 22,
     glashing: 35,
     hatching: 45,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glash/cli",
-  "version": "0.2.28",
+  "version": "0.2.30",
   "description": "glashDB command-line interface — deploy projects, pull source + env, manage env vars.",
   "license": "Apache-2.0",
   "homepage": "https://glashdb.com",