@celsian/vura-cli 0.5.13 → 0.6.0

package/dist/commands/build.js

@@ -62,21 +62,32 @@ kill_timeout = "30s"
 const nativeImport = (specifier) => import(/* @vite-ignore */ specifier);
 const moduleSourceToDataUrl = (source) => `data:text/javascript;base64,${Buffer.from(source).toString('base64')}`;
 /**
- * Emit Dockerfile and fly.toml into dist/ when the project has hot routes.
- * Also writes/merges dist/package.json so that `npm install --omit=dev` in the
- * Docker build pulls the right runtime deps (ws when WS routes are present).
+ * Write dist/package.json.
+ *
+ * `npm install --omit=dev` inside the Docker build resolves against this file,
+ * so it has to list every bare specifier the emitted bundles still import at
+ * runtime. Two do:
+ *
+ *   - `what-framework`, because API and page route modules are bundled with it
+ *     kept external (see bundleRouteModule's `keepWhatFwExternal`). Without the
+ *     dependency the container starts and dies on the first request to any API
+ *     route with `ERR_MODULE_NOT_FOUND: what-framework/server`. It was only ever
+ *     absent from this file, never from the imports.
+ *   - `ws`, when the project has WebSocket routes.
+ *
+ * It is pinned to the version the project actually resolved, so the container
+ * runs the What the app was built and tested against rather than whatever
+ * `latest` is on deploy day.
+ *
+ * This runs for EVERY build. It used to run only for projects with hot routes,
+ * which is unrelated to whether the bundles import anything.
  */
-async function emitHotDeployTemplates(distDir, appName, hasWsRoutes) {
+async function emitDeployPackageJson(distDir, projectRoot, hasWsRoutes) {
     const { writeFile, readFile, mkdir } = await import('node:fs/promises');
     const { existsSync } = await import('node:fs');
     const { join } = await import('node:path');
+    const { createRequire } = await import('node:module');
     await mkdir(distDir, { recursive: true });
-    // Dockerfile
-    await writeFile(join(distDir, 'Dockerfile'), DOCKERFILE_HOT, 'utf8');
-    // fly.toml — replace {{APP_NAME}} placeholder
-    const flyToml = FLY_TOML_TMPL.replace('{{APP_NAME}}', appName);
-    await writeFile(join(distDir, 'fly.toml'), flyToml, 'utf8');
-    // dist/package.json — create or merge
     const pkgPath = join(distDir, 'package.json');
     let existing = {};
     if (existsSync(pkgPath)) {
@@ -87,13 +98,46 @@ async function emitHotDeployTemplates(distDir, appName, hasWsRoutes) {
             console.warn('  Warning: dist/package.json is malformed JSON — regenerating from scratch.');
         }
     }
-    const merged = { ...existing, type: 'module' };
-    if (hasWsRoutes) {
-        const existingDeps = existing.dependencies ?? {};
-        merged.dependencies = { ...existingDeps, ws: '8.18.0' };
+    const deps = { ...(existing.dependencies ?? {}) };
+    const whatVersion = resolveWhatFrameworkVersion(createRequire(join(projectRoot, 'package.json')));
+    if (whatVersion) {
+        deps['what-framework'] = whatVersion;
+    }
+    else {
+        console.warn('  Warning: could not resolve what-framework in this project, so dist/package.json ' +
+            'does not declare it. A container build will fail to resolve `what-framework/server` ' +
+            'from the emitted API route bundles.');
     }
+    if (hasWsRoutes)
+        deps.ws = '8.18.0';
+    const merged = { ...existing, type: 'module' };
+    if (Object.keys(deps).length > 0)
+        merged.dependencies = deps;
     await writeFile(pkgPath, JSON.stringify(merged, null, 2) + '\n', 'utf8');
 }
+/** The exact what-framework version installed in the project, or null. */
+function resolveWhatFrameworkVersion(projectRequire) {
+    try {
+        const manifest = projectRequire('what-framework/package.json');
+        return typeof manifest.version === 'string' ? manifest.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Emit Dockerfile and fly.toml into dist/ when the project has hot routes.
+ */
+async function emitHotDeployTemplates(distDir, appName) {
+    const { writeFile, mkdir } = await import('node:fs/promises');
+    const { join } = await import('node:path');
+    await mkdir(distDir, { recursive: true });
+    // Dockerfile
+    await writeFile(join(distDir, 'Dockerfile'), DOCKERFILE_HOT, 'utf8');
+    // fly.toml — replace {{APP_NAME}} placeholder
+    const flyToml = FLY_TOML_TMPL.replace('{{APP_NAME}}', appName);
+    await writeFile(join(distDir, 'fly.toml'), flyToml, 'utf8');
+}
 export async function buildCommand(_args) {
     const startTime = Date.now();
     const projectRoot = process.cwd();
@@ -113,8 +157,9 @@ export async function buildCommand(_args) {
     // Shared esbuild helpers
     const { build: esbuild } = await import('esbuild');
     const { join, resolve } = await import('node:path');
-    const { mkdir } = await import('node:fs/promises');
+    const { mkdir, readFile, rename } = await import('node:fs/promises');
     const { existsSync } = await import('node:fs');
+    const { createHash } = await import('node:crypto');
     const cliRequire = createRequire(import.meta.url);
     const projectRequire = createRequire(join(root, 'package.json'));
     // Determine JSX import source from the user's project, not from the CLI's own
@@ -285,7 +330,13 @@ export async function buildCommand(_args) {
                 plugins: [esmResolvePlugin],
                 external: [],
             });
-            const scriptPath = `/_then/pages/${outFile.replace(/\\/g, '/')}`;
+            const bundleHash = createHash('sha256')
+                .update(await readFile(outPath))
+                .digest('hex')
+                .slice(0, 12);
+            const hashedOutFile = outFile.replace(/\.js$/, `.${bundleHash}.js`);
+            await rename(outPath, join(clientPagesDir, hashedOutFile));
+            const scriptPath = `/_then/pages/${hashedOutFile.replace(/\\/g, '/')}`;
             clientScripts[page.filePath] = scriptPath;
             console.log(`    ◇ ${page.urlPattern} → dist/static${scriptPath}`);
         }
@@ -353,15 +404,18 @@ export async function buildCommand(_args) {
     }
     // 9. Emit hot deploy templates when the project has hot routes
     const hotRoutes = manifest.api.filter(r => r.kind === 'hot');
+    const hasWsRoutes = hotRoutes.some(r => r.hasWebsocket === true);
+    const distDir = join(root, 'dist');
+    // Always: the emitted bundles import `what-framework` at runtime whether or
+    // not the project has hot routes.
+    await emitDeployPackageJson(distDir, root, hasWsRoutes);
     if (hotRoutes.length > 0) {
         const { basename } = await import('node:path');
         const rawName = basename(root);
         // sanitize to lowercase [a-z0-9-], truncate to Fly's ~30-char DNS label limit,
         // then strip any trailing dashes introduced by truncation
         const appName = rawName.toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 30).replace(/-+$/, '') || 'vura-app';
-        const hasWsRoutes = hotRoutes.some(r => r.hasWebsocket === true);
-        const distDir = join(root, 'dist');
-        await emitHotDeployTemplates(distDir, appName, hasWsRoutes);
+        await emitHotDeployTemplates(distDir, appName);
         console.log(`  Emitted dist/Dockerfile, dist/fly.toml, dist/package.json (app: ${appName}${hasWsRoutes ? ', ws: true' : ''})`);
     }
     const elapsed = Date.now() - startTime;

package/dist/commands/deploy.js

@@ -13,10 +13,43 @@
  *   --api-url <url>       API base URL (else VURA_API_URL, else https://api.vura.io)
  *   --project-id <id>     Project id (else VURA_PROJECT_ID, else .vura/project.json)
  */
-import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { resolveApiUrl, resolveProjectId, resolveToken } from '../vura-client.js';
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function invalidManifest(manifestPath, detail) {
+    return new Error(`Build manifest at ${manifestPath} is invalid (${detail}). ` +
+        'Run `vura build` again before deploying.');
+}
+async function readDeployManifest(manifestPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
+    }
+    catch {
+        throw invalidManifest(manifestPath, 'malformed JSON');
+    }
+    if (!isRecord(parsed))
+        throw invalidManifest(manifestPath, 'expected a JSON object');
+    if (!Array.isArray(parsed.api))
+        throw invalidManifest(manifestPath, 'api must be an array');
+    if (!Array.isArray(parsed.pages))
+        throw invalidManifest(manifestPath, 'pages must be an array');
+    for (const [index, route] of parsed.api.entries()) {
+        if (!isRecord(route) || !['serverless', 'hot', 'task'].includes(String(route.kind))) {
+            throw invalidManifest(manifestPath, `api[${index}] must have a supported kind`);
+        }
+    }
+    for (const [index, page] of parsed.pages.entries()) {
+        if (!isRecord(page) || !['static', 'server', 'client', 'hybrid'].includes(String(page.mode))) {
+            throw invalidManifest(manifestPath, `pages[${index}] must have a supported mode`);
+        }
+    }
+    return parsed;
+}
 function parseFlags(args) {
     const flags = { production: false };
     for (let i = 0; i < args.length; i++) {
@@ -70,16 +103,18 @@ export async function deployCommand(args) {
         return;
     }
     const apiUrl = resolveApiUrl(flags.apiUrl);
-    // Attach the built manifest so the platform can classify routes without
-    // re-scanning the artifact.
+    // 4. Refuse stale/corrupt build output before loading or calling the adapter.
     let manifest;
     try {
-        manifest = JSON.parse(await readFile(manifestPath, 'utf-8'));
+        manifest = await readDeployManifest(manifestPath);
     }
-    catch {
-        manifest = undefined;
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`  ${message}`);
+        process.exitCode = 1;
+        return;
     }
-    // 4. Deploy via the shared adapter flow.
+    // 5. Deploy via the adapter's independently validated shared flow.
     let deployToVura;
     try {
         ({ deployToVura } = await import('@celsian/vura-adapter-vura'));

package/dist/commands/runtime-profile.js

@@ -52,7 +52,9 @@ function computeDetails(route) {
         timeout,
         providerRecommendation: 'serverless-function',
         confidence: 'medium',
-        reasons: ['Stateless endpoints and tasks default to scale-to-zero Function compute at 1gb.'],
+        reasons: [memory && memory !== '1gb'
+                ? `The route explicitly selects ${memory} of scale-to-zero Function memory.`
+                : 'Stateless endpoints and tasks default to scale-to-zero Function compute at 1gb.'],
     };
 }
 function prefersHotTask(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@celsian/vura-cli",
-  "version": "0.5.13",
+  "version": "0.6.0",
   "description": "Vura CLI — build and deploy full-stack apps",
   "type": "module",
   "bin": {
@@ -15,12 +15,12 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@celsian/vura-core": "0.5.13",
+    "@celsian/vura-core": "0.6.0",
     "esbuild": "^0.28.1",
-    "what-framework": "^0.11.1"
+    "what-framework": "^0.13.2"
   },
   "peerDependencies": {
-    "@celsian/vura-adapter-vura": "0.5.13",
+    "@celsian/vura-adapter-vura": "0.6.0",
     "ws": "^8.0.0"
   },
   "peerDependenciesMeta": {
@@ -32,7 +32,7 @@
     }
   },
   "devDependencies": {
-    "@celsian/vura-adapter-vura": "0.5.13",
+    "@celsian/vura-adapter-vura": "0.6.0",
     "@types/ws": "^8.18.1",
     "ws": "^8.21.0"
   },