layero 0.6.2 → 0.7.1

package/dist/agent.js

@@ -124,6 +124,13 @@ function renderHuman(event) {
         case "setup_applied":
             process.stdout.write(`✓ Setup applied\n`);
             break;
+        case "runtime_type_applied":
+            process.stdout.write(`✓ Project type set to ${event.project_type}\n`);
+            break;
+        case "runtime_type_apply_failed":
+            process.stdout.write(`! Failed to set project_type automatically: ${event.error}\n`);
+            process.stdout.write(`  Build may fail at detect; accept the suggestion in the dashboard if so.\n`);
+            break;
         case "deploy_started":
             process.stdout.write(`→ Building...\n`);
             break;

package/dist/api.js

@@ -68,6 +68,9 @@ export class ApiClient {
     completeSetup(projectId, input) {
         return this.request("POST", `/projects/${projectId}/setup`, input);
     }
+    setRuntimeType(projectId, projectType) {
+        return this.request("POST", `/projects/${projectId}/runtime-type`, { project_type: projectType });
+    }
     updateProject(projectId, input) {
         return this.request("PATCH", `/projects/${projectId}`, input);
     }
@@ -84,6 +87,16 @@ export class ApiClient {
     rollbackProject(projectId, input) {
         return this.request("POST", `/projects/${projectId}/rollback`, input);
     }
+    // V071 production-pointer: pin apex to a specific deploy. `source` is
+    // recorded in promote_events and lets us split CLI vs UI adoption later.
+    promoteDeploy(projectId, deployId) {
+        return this.request("POST", `/projects/${projectId}/promote`, { deploy_id: deployId, source: "cli" });
+    }
+    // Clear projects.production_deploy_id — apex resumes following latest
+    // ready deploy of default_branch (or sole-env, see V071 host_resolver).
+    unpinProduction(projectId) {
+        return this.request("POST", `/projects/${projectId}/unpin`);
+    }
     listDeployHooks(projectId) {
         return this.request("GET", `/projects/${projectId}/deploy-hooks`);
     }

package/dist/bin/layero.js

@@ -11,6 +11,7 @@ import { linkCmd } from "../commands/link.js";
 import { tokenSetCmd } from "../commands/token.js";
 import { deployCmd } from "../commands/deploy.js";
 import { deploysListCmd, rollbackCmd } from "../commands/deploys.js";
+import { promoteCmd } from "../commands/promote.js";
 import { hooksCreateCmd, hooksDeleteCmd, hooksListCmd } from "../commands/hooks.js";
 import { loginCmd } from "../commands/login.js";
 import { orgsListCmd } from "../commands/orgs.js";
@@ -124,6 +125,21 @@ async function main() {
             process.exitCode = 1;
         }
     });
+    program
+        .command("promote [deploy]")
+        .description("Pin the project apex to a specific deploy (V071 production-pointer). " +
+        "Without [deploy] picks the latest ready build on --branch (defaults to the 'cli' pseudo-branch).")
+        .option("--project <id_or_slug>", "target project (default: linked .layero/project.json)")
+        .option("--branch <name>", "branch to pick latest ready deploy from (default: cli)")
+        .option("-y, --yes", "skip the confirmation prompt (CI)")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ layero promote                      # pin apex to latest ready deploy on `cli` branch\n" +
+        "  $ layero promote --branch=main        # pin apex to latest ready deploy on main\n" +
+        "  $ layero promote a3f9c2b              # pin apex to a specific commit sha\n" +
+        "  $ layero promote --yes                # CI-friendly, no prompt")
+        .action(async (deploy, opts) => {
+        await promoteCmd(deploy, opts);
+    });
     program
         .command("rollback")
         .description("Re-activate the previous successful deploy on the project's default branch.")
@@ -162,12 +178,14 @@ async function main() {
         .option("--prebuilt [dir]", "ship an already-built artifact directory (default auto-pick: dist/build/public/out/_site/...)")
         .option("--root <dir>", "monorepo: subdirectory inside the repo that the builder treats as the app root (saved on the project; future GitHub-push and hook triggers use the same value)")
         .option("--prod", "deploy to production (replaces apex_hostname's active deploy). Without this flag, deploys go to the project's CLI preview pseudo-branch.")
+        .option("--promote", "pin the project apex to this deploy after a successful build (V071). Works for any branch — e.g. `--promote` without --prod publishes a CLI preview straight to production.")
         .option("--branch <name>", "deploy to a specific branch's environment. Wins over --prod.")
         .option("--org <slug>", "Layero organization slug for first-time project creation. Defaults to personal; required when you're a member of multiple orgs and want a non-personal home.")
         .addHelpText("after", "\nExamples:\n" +
         "  $ layero deploy                      # preview deploy (CLI pseudo-branch), auto-detect framework\n" +
         "  $ layero deploy --prod               # production deploy (interactive confirm)\n" +
         "  $ layero deploy --prod --yes         # production deploy, no prompt (CI)\n" +
+        "  $ layero deploy --promote            # preview deploy + pin apex (one-shot publish)\n" +
         "  $ layero deploy --branch=staging     # preview on a specific branch\n" +
         "  $ layero deploy --type vite          # force a framework preset\n" +
         "  $ layero deploy --json               # machine-readable output for agents")

package/dist/commands/deploy.js

@@ -213,6 +213,7 @@ async function resolveSetupConfig(cwd, opts, existing) {
         build_cmd: detected.build_cmd,
         output_dir: detected.output_dir,
         confident: detected.confident,
+        ...(detected.runtime_kind ? { runtime_kind: detected.runtime_kind } : {}),
     });
     const framework_hint = opts.type ?? existing?.framework_hint ?? detected.framework_hint;
     const build_cmd = existing?.build_cmd ?? detected.build_cmd;
@@ -227,7 +228,13 @@ async function resolveSetupConfig(cwd, opts, existing) {
     else {
         source = "detected";
     }
-    return { framework_hint, build_cmd, output_dir, source };
+    return {
+        framework_hint,
+        build_cmd,
+        output_dir,
+        source,
+        ...(detected.runtime_kind ? { runtime_kind: detected.runtime_kind } : {}),
+    };
 }
 export async function deployCmd(opts) {
     const mode = detectMode();
@@ -306,6 +313,26 @@ export async function deployCmd(opts) {
             root_directory: opts.root ?? null,
         });
         emit({ event: "setup_applied" });
+        // Newly-created projects default to project_type='spa'. If detect
+        // says the repo is SSR (Next.js without `output: 'export'`), flip
+        // the type now — otherwise the first build crashes at the detect
+        // stage with "looks like ssr_next but configured as spa", forcing
+        // the user to open the dashboard and accept the suggestion. Only
+        // applied on first setup; an explicitly-configured spa project
+        // that drops a next.config later keeps user's choice.
+        if (setup.runtime_kind) {
+            try {
+                project = await api.setRuntimeType(project.id, setup.runtime_kind);
+                emit({ event: "runtime_type_applied", project_type: setup.runtime_kind });
+            }
+            catch (err) {
+                // Non-fatal: the build will fall back to the dashboard suggestion
+                // flow exactly as it did before this CLI fix. Tell the user what
+                // happened so they don't burn a deploy on a surprise crash.
+                const msg = err instanceof Error ? err.message : String(err);
+                emit({ event: "runtime_type_apply_failed", error: msg });
+            }
+        }
     }
     else if (opts.root !== undefined) {
         // Active project: --root patches the existing row so the *next*
@@ -330,14 +357,31 @@ export async function deployCmd(opts) {
         if (final.status !== "ready") {
             throw new LayeroError(`deploy_${final.status}`, `deploy failed (${final.status})${final.error_message ? `: ${final.error_message}` : ""}`, `inspect logs at ${projectUrl(cliCfg.apiUrl, project.id)}`);
         }
-        const liveUrl = opts.prod && !opts.branch
-            ? `https://${project.apex_hostname}`
-            : projectUrl(cliCfg.apiUrl, project.id);
+        // --promote: pin apex_hostname to this deploy after a successful
+        // build. Independent of --prod; --promote lets the typical "CLI
+        // preview branch" deploy publish straight to production in one
+        // command. Best-effort: a failure here doesn't fail the deploy
+        // (the artifact is good; promote can be retried via `layero promote`).
+        let promoted = false;
+        if (opts.promote) {
+            try {
+                await api.promoteDeploy(project.id, deploy.id);
+                promoted = true;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.warn(chalk.yellow(`warning: deploy succeeded but promote failed — ${msg}.\n` +
+                    `  retry with: layero promote ${deploy.id.slice(0, 8)}`));
+            }
+        }
+        const apexUrl = `https://${project.apex_hostname}`;
+        const previewUrl = projectUrl(cliCfg.apiUrl, project.id);
+        const liveUrl = promoted || (opts.prod && !opts.branch) ? apexUrl : previewUrl;
         emit({
             event: "ready",
             url: liveUrl,
             deploy_id: deploy.id,
-            preview_url: opts.prod && !opts.branch ? undefined : projectUrl(cliCfg.apiUrl, project.id),
+            preview_url: promoted || (opts.prod && !opts.branch) ? undefined : previewUrl,
         });
     }
     finally {

package/dist/commands/promote.js

@@ -0,0 +1,106 @@
+import readline from "node:readline/promises";
+import chalk from "chalk";
+import { ApiClient, ApiError } from "../api.js";
+import { loadConfig } from "../config.js";
+import { loadProjectConfig } from "../project-config.js";
+async function resolveProjectId(api, cwd, override) {
+    if (override) {
+        const all = await api.listProjects();
+        const match = all.find((p) => p.id === override) ?? all.find((p) => p.slug === override);
+        if (!match)
+            throw new Error(`no project with id/slug "${override}"`);
+        return match.id;
+    }
+    const cfg = await loadProjectConfig(cwd);
+    if (!cfg) {
+        throw new Error("no .layero/project.json found. cd into a linked project or pass --project <slug>.");
+    }
+    return cfg.project_id;
+}
+function shortSha(sha) {
+    return (sha ?? "").slice(0, 7);
+}
+async function confirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await rl.question(`${question} [y/N]: `)).trim().toLowerCase();
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * `layero promote [deploy]` — pin apex to a specific deploy.
+ *
+ * Without an argument: picks the latest ready deploy on --branch (or the
+ * "cli" pseudo-branch when not specified). With an argument: takes either
+ * a deploy id or a commit-sha prefix and promotes that one — same shape
+ * as `layero rollback --deploy`.
+ *
+ * Requires production_pointer_enabled=true on the project. The server
+ * returns 400 with a readable message if the flag is off; we surface it.
+ */
+export async function promoteCmd(deployArg, opts) {
+    const cliCfg = await loadConfig();
+    if (!cliCfg.token) {
+        throw new Error("not logged in. run `layero login` first.");
+    }
+    const api = new ApiClient(cliCfg);
+    const projectId = await resolveProjectId(api, process.cwd(), opts.project);
+    const project = await api.getProject(projectId);
+    let target;
+    if (deployArg) {
+        // Search across all branches — the user may know the sha but not which
+        // branch it came from. Behaviour mirrors `rollback --deploy`.
+        const all = await api.listProjectDeploys(projectId, opts.branch);
+        const m = all.find((d) => d.id === deployArg || d.commit_sha.startsWith(deployArg));
+        if (!m)
+            throw new Error(`no deploy matching "${deployArg}"`);
+        target = m;
+    }
+    else {
+        // No deploy arg → promote latest ready on the branch (defaults to "cli"
+        // pseudo-branch, which is where `layero deploy` without --branch lands).
+        const branch = opts.branch ?? "cli";
+        const all = await api.listProjectDeploys(projectId, branch);
+        const m = all.find((d) => d.status === "ready");
+        if (!m) {
+            throw new Error(`no ready deploy on branch "${branch}".`);
+        }
+        target = m;
+    }
+    if (target.status !== "ready") {
+        throw new Error(`cannot promote deploy ${shortSha(target.commit_sha)}: status is "${target.status}", not ready.`);
+    }
+    const apex = project.apex_hostname;
+    console.log(chalk.cyan("promote plan:"));
+    console.log(`  project: ${project.slug}`);
+    console.log(`  apex:    https://${apex}`);
+    console.log(`  deploy:  ${shortSha(target.commit_sha)}  ${chalk.dim((target.commit_message ?? "").split("\n")[0] ?? "")}`);
+    if (project.production_deploy_id) {
+        console.log(chalk.dim(`  current: ${project.production_deploy_id.slice(0, 8)}  (will be replaceable via re-promote)`));
+    }
+    if (!opts.yes) {
+        const ok = await confirm("publish this build to production?");
+        if (!ok) {
+            console.log(chalk.yellow("aborted."));
+            return;
+        }
+    }
+    try {
+        const updated = await api.promoteDeploy(projectId, target.id);
+        const newPin = updated.production_deploy_id ?? target.id;
+        console.log(chalk.green(`published. https://${updated.apex_hostname} now serves deploy ${newPin.slice(0, 8)}.`));
+        console.log(chalk.dim("  edge cache flushes within a few seconds; visitors see the new build immediately."));
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            throw new Error(`promote failed (${err.status}): ${err.body.slice(0, 200)}`);
+        }
+        throw err;
+    }
+}

package/dist/detect.js

@@ -26,6 +26,34 @@ async function fileExists(cwd, ...candidates) {
     }
     return false;
 }
+// Mirrors `frameworks/nextjs.py:_NEXT_STATIC_EXPORT_RE` and
+// `next_config_static_export()` so CLI and builder can't disagree on
+// what counts as a static-export Next.js project. The class-of-bug we
+// hit on 2026-05-22 (builder detector v72 fix) and 2026-05-26 (CLI side)
+// was exactly this kind of dual detector drift.
+const NEXT_STATIC_EXPORT_RE = /output\s*:\s*['"]export['"]/m;
+async function readNextConfigText(cwd) {
+    for (const name of ["next.config.mjs", "next.config.ts", "next.config.js", "next.config.cjs"]) {
+        try {
+            return await fs.readFile(path.join(cwd, name), "utf-8");
+        }
+        catch (err) {
+            if (err?.code === "ENOENT")
+                continue;
+            return null;
+        }
+    }
+    return null;
+}
+// True  -> config has `output: 'export'` (static-export SPA).
+// False -> config exists but no export marker (SSR Next.js).
+// null  -> no next.config file at all; caller treats as static-default.
+async function nextConfigStaticExport(cwd) {
+    const text = await readNextConfigText(cwd);
+    if (text === null)
+        return null;
+    return NEXT_STATIC_EXPORT_RE.test(text);
+}
 async function hasAnyHtml(cwd) {
     // Shallow check — only top-level. Recursive walk is too expensive here
     // and the static fallback is already permissive enough.
@@ -60,12 +88,20 @@ function buildCmd(pkg, fallback) {
 export async function detectProject(cwd) {
     const pkg = await readPkg(cwd);
     if (pkg) {
-        if (hasDep(pkg, "next") || (await fileExists(cwd, "next.config.js", "next.config.mjs", "next.config.ts"))) {
+        if (hasDep(pkg, "next") || (await fileExists(cwd, "next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"))) {
+            // A Next.js repo is SSR unless next.config explicitly declares
+            // `output: 'export'`. We only flag ssr_next when the config file
+            // exists AND lacks the export marker — same rule the builder uses
+            // in `runtime_detect.py:46`. Without a next.config file at all we
+            // err on the side of static (legacy `next export` workflow).
+            const exportFlag = await nextConfigStaticExport(cwd);
+            const isSsr = exportFlag === false;
             return {
                 framework_hint: "nextjs",
                 build_cmd: buildCmd(pkg, "npx next build"),
-                output_dir: "out",
+                output_dir: isSsr ? ".next" : "out",
                 confident: true,
+                ...(isSsr ? { runtime_kind: "ssr_next" } : {}),
             };
         }
         if (hasDep(pkg, "nuxt") || hasDep(pkg, "nuxt3") || (await fileExists(cwd, "nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "layero",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "description": "Layero CLI — publish a local site with one command. No git, no GitHub, agent-friendly (Cursor, Claude Code).",
   "license": "MIT",
   "type": "module",