layero 0.7.5 → 0.8.0

package/dist/agent.js

@@ -143,7 +143,24 @@ function renderHuman(event) {
             process.stdout.write(`${event.line}\n`);
             break;
         case "ready":
-            process.stdout.write(`✓ Live at ${event.url}\n`);
+            if (event.edge_ready === false) {
+                // Built & published, but the CDN edge for the apex is still
+                // propagating (first deploy of a new hostname can take a few
+                // minutes on YC CDN). The preview host is reachable immediately.
+                const eta = typeof event.edge_eta_seconds === "number" && event.edge_eta_seconds > 0
+                    ? ` (edge propagating, ~${event.edge_eta_seconds}s)`
+                    : " (edge propagating)";
+                process.stdout.write(`✓ Built. Live at ${event.url}${eta}\n`);
+                if (event.preview_url) {
+                    process.stdout.write(`  Reachable now: ${event.preview_url}\n`);
+                }
+            }
+            else {
+                process.stdout.write(`✓ Live at ${event.url}\n`);
+            }
+            break;
+        case "promoted":
+            process.stdout.write(`✓ Published apex → ${event.url}\n`);
             break;
         case "error":
             process.stderr.write(`Error: ${event.code}\n`);

package/dist/api.js

@@ -77,6 +77,12 @@ export class ApiClient {
     triggerDeploy(projectId, input) {
         return this.request("POST", `/projects/${projectId}/deploy`, input);
     }
+    // Edge/URL readiness for an environment. Used after a deploy reaches
+    // `ready` to report the real public URL + a reachable preview link
+    // instead of the management dashboard.
+    probeEnvironment(environmentId) {
+        return this.request("GET", `/environments/${environmentId}/probe`);
+    }
     pollLogs(deployId, afterId) {
         return this.request("GET", `/deploys/${deployId}/logs?after_id=${afterId}`);
     }

package/dist/auth.js

@@ -0,0 +1,69 @@
+// Shared device-auth flow.
+//
+// Used by `layero login` (always) and by `layero deploy` when no token is
+// saved yet (B5/I4 — the documented happy path is `deploy` kicking off the
+// device login inline and polling, rather than erroring out to a separate
+// `login` command).
+import chalk from "chalk";
+import open from "open";
+import { saveConfig } from "./config.js";
+import { ApiClient } from "./api.js";
+import { LayeroError, detectMode, emit } from "./agent.js";
+const MAX_WAIT_MS = 15 * 60 * 1000;
+/**
+ * Run the browser device-auth flow against `cfg`, persist the resulting
+ * token, and return the updated config. Emits `auth_required` (so agents can
+ * render the link) and `authorized` in JSON mode; prints a friendly block and
+ * auto-opens the browser in interactive mode.
+ *
+ * Throws LayeroError("auth_expired" | "auth_timeout") if the user doesn't
+ * approve in time.
+ */
+export async function runDeviceLogin(cfg) {
+    const mode = detectMode();
+    const api = new ApiClient(cfg);
+    const device = await api.startDeviceAuth();
+    const { device_code, user_code, verification_url, poll_interval } = device;
+    const pollMs = (poll_interval ?? 2) * 1000;
+    if (mode.json) {
+        emit({ event: "auth_required", url: verification_url, user_code });
+    }
+    else {
+        console.log(chalk.cyan("\nOpen this URL to sign in:"));
+        console.log(chalk.bold(`  ${verification_url}`));
+        console.log(chalk.dim(`\n  Confirmation code: `) + chalk.white.bold(user_code));
+        console.log(chalk.dim(`  (expires in ${device.expires_in}s)\n`));
+        try {
+            await open(verification_url);
+        }
+        catch {
+            // non-fatal — user can paste the URL manually
+        }
+    }
+    const deadline = Date.now() + MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, pollMs));
+        const poll = await api.pollDeviceAuth(device_code);
+        if (poll.status === "approved" && poll.token) {
+            cfg.token = poll.token;
+            const probe = new ApiClient(cfg);
+            const me = await probe.me();
+            cfg.user = { id: me.id, username: me.username, email: me.email };
+            await saveConfig(cfg);
+            if (mode.json) {
+                emit({ event: "authorized", user: me.username ?? me.email ?? me.id });
+            }
+            else {
+                console.log(chalk.green(`Logged in as ${me.username ?? me.email ?? me.id}`));
+                if (!me.username) {
+                    console.log(chalk.yellow("No username set — open https://app.layero.ru/onboarding to pick one."));
+                }
+            }
+            return cfg;
+        }
+        if (poll.status === "expired") {
+            throw new LayeroError("auth_expired", "Login timed out — code expired. Run `layero login` again.", "run_login");
+        }
+    }
+    throw new LayeroError("auth_timeout", "Login timed out. Run `layero login` again.", "run_login");
+}

package/dist/bin/layero.js

@@ -26,7 +26,8 @@ async function main() {
         .name("layero")
         .description("Layero CLI — publish a local directory with one command. No git required.")
         .version(VERSION)
-        .option("--json", "emit machine-readable JSON-lines on stdout (for agents and CI)");
+        .option("--json", "emit machine-readable JSON-lines on stdout (for agents and CI)")
+        .option("--debug", "print a full stack trace when a command errors");
     program
         .command("login")
         .description("Authenticate via browser (GitHub / Yandex). Opens a one-time URL — no localhost server required.")
@@ -44,9 +45,9 @@ async function main() {
         .action(whoamiCmd);
     program
         .command("init")
-        .description("Scaffold .layero/project.json from auto-detected framework, and write a Layero deployment block into AGENTS.md / CLAUDE.md / .cursorrules so future chat sessions know how to deploy.")
+        .description("Scaffold .layero/project.json from the auto-detected framework, and write a Layero deployment block into your agent-instructions file so future chat sessions know how to deploy. Updates whichever of AGENTS.md / CLAUDE.md / .cursorrules already exist; if none do, creates AGENTS.md.")
         .option("-y, --yes", "non-interactive: accept all defaults")
-        .option("--skip-agent-docs", "do not touch AGENTS.md/CLAUDE.md/.cursorrules")
+        .option("--skip-agent-docs", "do not touch AGENTS.md / CLAUDE.md / .cursorrules")
         .action(async (opts) => {
         await initCmd({ yes: opts.yes, skipAgentDocs: opts.skipAgentDocs });
     });
@@ -196,6 +197,12 @@ async function main() {
 }
 main().catch((err) => {
     const mode = detectMode();
+    // `--debug` (real global flag) prints the full stack trace for any error,
+    // structured or not, so the next_action hint that mentions it is honest.
+    const debug = process.argv.includes("--debug") || process.env.LAYERO_DEBUG === "1";
+    if (debug && err instanceof Error && err.stack) {
+        console.error(chalk.dim(err.stack));
+    }
     if (err instanceof LayeroError) {
         emit({
             event: "error",
@@ -212,12 +219,17 @@ main().catch((err) => {
             emit({
                 event: "error",
                 code: "internal",
-                next_action: "re-run with --debug for a stack trace, or report at https://github.com/layero/layero/issues",
+                next_action: debug
+                    ? "report at https://github.com/LayeroInfra/core/issues"
+                    : "re-run with --debug for a stack trace, or report at https://github.com/LayeroInfra/core/issues",
                 message,
             });
         }
         else {
             console.error(chalk.red(message));
+            if (!debug) {
+                console.error(chalk.dim("  (re-run with --debug for a stack trace)"));
+            }
         }
     }
     process.exit(1);

package/dist/commands/deploy.js

@@ -8,6 +8,7 @@ import { loadProjectConfig, persistProjectLinking, projectConfigPath, } from "..
 import { packCwd, packDirectory } from "../pack.js";
 import { streamDeployLogs } from "../logs.js";
 import { detectProject } from "../detect.js";
+import { runDeviceLogin } from "../auth.js";
 import { LayeroError, detectMode, emit } from "../agent.js";
 const VALID_TYPES = new Set([
     "vite",
@@ -44,6 +45,33 @@ function dashboardOrigin(apiUrl) {
 function projectUrl(apiUrl, projectId) {
     return `${dashboardOrigin(apiUrl)}/projects/${projectId}`;
 }
+/**
+ * After a deploy reaches `ready`, ask the backend where it's actually
+ * reachable. The builder marks status=ready *before* calling /activate
+ * (which runs auto-promote + schedules CDN warmup), so a probe fired the
+ * instant we see `ready` can race ahead of the apex pointer being set.
+ *
+ * Poll the probe briefly (bounded) and return as soon as the env is
+ * reachable (`available` — the preview host is up) or we learn the CDN
+ * edge is already warm. Best-effort: any error returns null and the caller
+ * falls back to apex/dashboard URLs.
+ */
+async function resolveReachability(api, environmentId) {
+    const deadline = Date.now() + 15_000;
+    let last = null;
+    while (Date.now() < deadline) {
+        try {
+            last = await api.probeEnvironment(environmentId);
+        }
+        catch {
+            return last; // permission/network — caller falls back
+        }
+        if (last.available || last.cdn_ready)
+            return last;
+        await new Promise((r) => setTimeout(r, 1500));
+    }
+    return last;
+}
 async function prompt(question, fallback) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -87,7 +115,15 @@ async function resolveOrCreateProject(api, cwd, opts, existing) {
         }
         return { project: match, createdNow: false };
     }
-    if (existing) {
+    // Treat the local config as a real link only if it actually carries a
+    // project_id. `layero init` scaffolds .layero/project.json with the
+    // detected framework/build/output but NO project_id (the project isn't
+    // created until the first deploy). Without this guard, deploy would treat
+    // that scaffold as an existing link and call GET /projects/undefined → 422
+    // (B1 — the documented init→deploy path was broken). When there's no id,
+    // fall through to the create path below, which preserves the scaffold's
+    // setup fields via persistProjectLinking().
+    if (existing && existing.project_id) {
         try {
             const project = await api.getProject(existing.project_id);
             return { project, createdNow: false };
@@ -242,9 +278,13 @@ export async function deployCmd(opts) {
     if (opts.type && !VALID_TYPES.has(opts.type.toLowerCase())) {
         throw new LayeroError("invalid_type", `unknown --type "${opts.type}"`, `valid types: ${[...VALID_TYPES].join(", ")}`);
     }
-    const cliCfg = await loadConfig();
+    let cliCfg = await loadConfig();
     if (!cliCfg.token) {
-        throw new LayeroError("not_logged_in", "not authenticated", "run: layero login");
+        // Not authenticated yet. Kick off the browser device-login flow inline
+        // and poll, exactly as the docs describe (B5/I4) — no separate `layero
+        // login` step required. In JSON/agent mode this emits `auth_required`
+        // so the caller can render the link and keep waiting.
+        cliCfg = await runDeviceLogin(cliCfg);
     }
     const api = new ApiClient(cliCfg);
     const cwd = process.cwd();
@@ -375,14 +415,29 @@ export async function deployCmd(opts) {
                     `  retry with: layero promote ${deploy.id.slice(0, 8)}`));
             }
         }
+        // Where is this build actually reachable? Ask the backend rather than
+        // guessing — it knows the live public URL (apex once it's the production
+        // pointer), the off-CDN preview URL that's reachable immediately, and
+        // how far along CDN propagation is. Note: a plain `layero deploy` of a
+        // CLI project auto-promotes to the apex on activate (no `--prod` /
+        // `promote` needed), so the apex IS the destination for the common case.
+        const dashboardUrl = projectUrl(cliCfg.apiUrl, project.id);
         const apexUrl = `https://${project.apex_hostname}`;
-        const previewUrl = projectUrl(cliCfg.apiUrl, project.id);
-        const liveUrl = promoted || (opts.prod && !opts.branch) ? apexUrl : previewUrl;
+        const probe = await resolveReachability(api, deploy.environment_id);
+        // Public site URL: prefer the backend's canonical_url; fall back to the
+        // apex for the no-branch case (CLI auto-promote), else the dashboard.
+        const liveUrl = probe?.canonical_url ??
+            (promoted || !opts.branch ? apexUrl : dashboardUrl);
         emit({
             event: "ready",
             url: liveUrl,
             deploy_id: deploy.id,
-            preview_url: promoted || (opts.prod && !opts.branch) ? undefined : previewUrl,
+            preview_url: probe?.preview_url ?? undefined,
+            dashboard_url: dashboardUrl,
+            edge_ready: probe ? probe.cdn_ready : undefined,
+            edge_eta_seconds: probe && !probe.cdn_ready && probe.cdn_eta_seconds != null
+                ? probe.cdn_eta_seconds
+                : undefined,
         });
     }
     finally {

package/dist/commands/deploys.js

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import { ApiClient, ApiError } from "../api.js";
 import { loadConfig } from "../config.js";
 import { loadProjectConfig } from "../project-config.js";
+import { detectMode } from "../agent.js";
 async function resolveProjectId(api, cwd, override) {
     if (override) {
         // Accept slug or id; resolve via list to keep consistent error UX.
@@ -59,6 +60,25 @@ export async function deploysListCmd(opts) {
     const deploys = await api.listProjectDeploys(projectId, opts.branch);
     const limit = opts.limit ?? 20;
     const rows = deploys.slice(0, limit);
+    // JSON mode (B6): emit one structured object per deploy on stdout instead
+    // of the coloured human one-liner. One JSON object per line keeps it
+    // consistent with the rest of the CLI's JSON-lines protocol.
+    if (detectMode().json) {
+        for (const d of rows) {
+            process.stdout.write(JSON.stringify({
+                event: "deploy",
+                id: d.id,
+                environment_id: d.environment_id,
+                status: d.status,
+                commit_sha: d.commit_sha,
+                commit_message: (d.commit_message ?? "").split("\n")[0] ?? "",
+                source_type: d.source_type ?? "github",
+                created_at: d.created_at ?? null,
+                finished_at: d.finished_at ?? null,
+            }) + "\n");
+        }
+        return;
+    }
     if (rows.length === 0) {
         console.log(chalk.dim("no deploys yet."));
         return;

package/dist/commands/init.js

@@ -20,7 +20,8 @@ is required — Layero packs and uploads the local directory directly.
 
 ### First-time auth (one-click device flow)
 
-The first run emits a JSON line:
+If you're not logged in yet, \`deploy\` (or \`login\`) starts the browser
+device-flow automatically and emits a JSON line:
 
 \`\`\`json
 {"event":"auth_required","url":"https://app.layero.ru/cli?code=ABCD-1234","user_code":"ABCD-1234"}
@@ -43,7 +44,7 @@ stdout), the CLI auto-switches to JSON-lines. Key events to watch:
 | \`detected\` | framework auto-detection result |
 | \`project_created\` / \`project_linked\` | project bound for this directory |
 | \`build_log\` | forward only if it contains errors |
-| \`ready\` | \`url\` field is the live site — show to user, stop |
+| \`ready\` | \`url\` = live public site (show to user, stop). \`preview_url\` = reachable immediately while the apex CDN edge warms; \`edge_ready\`/\`edge_eta_seconds\` say whether the apex is serving yet. \`dashboard_url\` = management page. |
 | \`error\` | follow \`next_action\` field verbatim |
 
 Common error codes and remediation:
@@ -56,11 +57,32 @@ Common error codes and remediation:
 
 ### Re-deploys and production
 
-Each \`npx layero deploy\` produces a new preview URL like
-\`https://<org>-<project>-cli.layero.ru\` — safe to run repeatedly.
+A plain \`npx layero deploy\` of a CLI project **publishes to the apex**
+\`https://<org>-<project>.layero.ru\` — direct uploads auto-promote, so you do
+**not** need \`--prod\` or a separate \`promote\` step. Safe to run repeatedly;
+each run replaces what the apex serves.
 
-Add \`--prod\` only when the user explicitly asks; without it, deploys go to
-an isolated preview branch and never replace the apex domain.
+Every deploy also gets a per-deploy preview at
+\`https://<org>-<project>-<sha>.preview.layero.ru\` (read it from \`ready.preview_url\`).
+The preview is reachable **immediately**; the apex can take a few minutes to
+serve on the **first** deploy of a project while the CDN edge issues its cert
+and propagates (\`ready.edge_ready=false\` with an \`edge_eta_seconds\` estimate).
+Hand the user \`ready.url\` (the apex); if \`edge_ready\` is false, also offer
+\`preview_url\` so they can see it right away.
+
+Use \`--branch <name>\` to deploy to an isolated preview environment that does
+**not** touch the apex. (\`--prod\` exists for git-connected projects; for
+direct CLI uploads it's redundant.)
+
+### Already built? Skip the server build
+
+If the site is already built locally (e.g. a Next.js static export in \`out/\`,
+or a \`dist/\`), ship the artifact directly and skip the server-side
+\`npm install\` + build:
+
+\`\`\`bash
+npx layero@latest deploy --prebuilt out
+\`\`\`
 
 Full reference: https://docs.layero.ru/cli/agents
 ${AGENT_BLOCK_MARKER_END}

package/dist/commands/login.js

@@ -1,55 +1,6 @@
-import chalk from "chalk";
-import open from "open";
-import { loadConfig, saveConfig } from "../config.js";
-import { ApiClient } from "../api.js";
-import { LayeroError, detectMode, emit } from "../agent.js";
-const MAX_WAIT_MS = 15 * 60 * 1000;
+import { loadConfig } from "../config.js";
+import { runDeviceLogin } from "../auth.js";
 export async function loginCmd(_opts) {
     const cfg = await loadConfig();
-    const mode = detectMode();
-    const api = new ApiClient(cfg);
-    const device = await api.startDeviceAuth();
-    const { device_code, user_code, verification_url, poll_interval } = device;
-    const pollMs = (poll_interval ?? 2) * 1000;
-    if (mode.json) {
-        emit({ event: "auth_required", url: verification_url, user_code });
-    }
-    else {
-        console.log(chalk.cyan("\nOpen this URL to sign in:"));
-        console.log(chalk.bold(`  ${verification_url}`));
-        console.log(chalk.dim(`\n  Confirmation code: `) + chalk.white.bold(user_code));
-        console.log(chalk.dim(`  (expires in ${device.expires_in}s)\n`));
-        try {
-            await open(verification_url);
-        }
-        catch {
-            // non-fatal — user can paste the URL manually
-        }
-    }
-    const deadline = Date.now() + MAX_WAIT_MS;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, pollMs));
-        const poll = await api.pollDeviceAuth(device_code);
-        if (poll.status === "approved" && poll.token) {
-            cfg.token = poll.token;
-            const probe = new ApiClient(cfg);
-            const me = await probe.me();
-            cfg.user = { id: me.id, username: me.username, email: me.email };
-            await saveConfig(cfg);
-            if (mode.json) {
-                emit({ event: "authorized", user: me.username ?? me.email ?? me.id });
-            }
-            else {
-                console.log(chalk.green(`Logged in as ${me.username ?? me.email ?? me.id}`));
-                if (!me.username) {
-                    console.log(chalk.yellow("No username set — open https://app.layero.ru/onboarding to pick one."));
-                }
-            }
-            return;
-        }
-        if (poll.status === "expired") {
-            throw new LayeroError("auth_expired", "Login timed out — code expired. Run `layero login` again.", "run_login");
-        }
-    }
-    throw new LayeroError("auth_timeout", "Login timed out. Run `layero login` again.", "run_login");
+    await runDeviceLogin(cfg);
 }

package/dist/commands/promote.js

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import { ApiClient, ApiError } from "../api.js";
 import { loadConfig } from "../config.js";
 import { loadProjectConfig } from "../project-config.js";
+import { detectMode, emit } from "../agent.js";
 async function resolveProjectId(api, cwd, override) {
     if (override) {
         const all = await api.listProjects();
@@ -45,6 +46,7 @@ async function confirm(question) {
  * returns 400 with a readable message if the flag is off; we surface it.
  */
 export async function promoteCmd(deployArg, opts) {
+    const mode = detectMode();
     const cliCfg = await loadConfig();
     if (!cliCfg.token) {
         throw new Error("not logged in. run `layero login` first.");
@@ -77,14 +79,21 @@ export async function promoteCmd(deployArg, opts) {
         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)`));
+    // Human-only plan. In JSON mode we skip the chatter and emit a single
+    // structured `promoted` event below.
+    if (!mode.json) {
+        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) {
+    // Confirm only when there's a human at a TTY. In --json / agent / CI /
+    // non-interactive mode, never block on a prompt (B6) — proceed, matching
+    // `deploy --prod`'s non-interactive behaviour. `--yes` forces it anywhere.
+    if (!opts.yes && mode.interactive) {
         const ok = await confirm("publish this build to production?");
         if (!ok) {
             console.log(chalk.yellow("aborted."));
@@ -94,8 +103,17 @@ export async function promoteCmd(deployArg, opts) {
     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."));
+        if (mode.json) {
+            emit({
+                event: "promoted",
+                url: `https://${updated.apex_hostname}`,
+                deploy_id: target.id,
+            });
+        }
+        else {
+            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) {

package/dist/detect.js

@@ -1,5 +1,22 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
+// package.json deps marking a Node web backend → node_web. Lockstep with
+// builder/src/runtime_detect.py NODE_WEB_SIGNALS / NODE_FRONTEND_DEPS.
+const NODE_WEB_SIGNALS = [
+    "express", "fastify", "koa", "@nestjs/core", "@hapi/hapi", "hapi",
+    "hono", "@adonisjs/core", "restify", "polka", "@feathersjs/feathers",
+    "sails", "h3", "json-server",
+];
+const NODE_FRONTEND_DEPS = [
+    "next", "nuxt", "vite", "react-scripts", "@angular/core", "@sveltejs/kit",
+    "gatsby", "astro", "@docusaurus/core", "@11ty/eleventy", "vitepress",
+];
+// A Node backend: a server framework AND no frontend/SSG framework (which
+// would build to static and belong to the SPA pipeline instead).
+function detectNodeRuntime(pkg) {
+    return (NODE_WEB_SIGNALS.some((d) => hasDep(pkg, d)) &&
+        !NODE_FRONTEND_DEPS.some((d) => hasDep(pkg, d)));
+}
 async function readPkg(cwd) {
     try {
         const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
@@ -26,11 +43,23 @@ async function fileExists(cwd, ...candidates) {
     }
     return false;
 }
-// Python runtime: `app.py` entry + a runtime lib in requirements.txt.
+// Python runtime: `app.py`/`main.py` entry + a runtime lib in requirements.txt.
 // Lockstep with detect_runtime() (backend) / runtime_detect.py (builder):
-// app.py + requirements.txt mentioning streamlit | gradio | flask.
+// Streamlit/Gradio keep their self-contained runtimes; Flask/FastAPI and any
+// WSGI|ASGI server route to the generic python_web runtime.
+// Lockstep with builder/src/runtime_detect.py PY_WEB_SIGNALS + framework_detector.py.
+const PY_WEB_SIGNALS = [
+    "fastapi", "starlette", "litestar", "starlite", "quart", "sanic",
+    "blacksheep", "hypercorn", "daphne", "uvicorn",
+    "flask", "falcon", "bottle", "pyramid", "cherrypy", "werkzeug", "gunicorn",
+    "aiohttp", "tornado", "django",
+];
 async function detectPythonRuntime(cwd) {
-    if (!(await fileExists(cwd, "app.py")))
+    const appPy = await fileExists(cwd, "app.py");
+    const mainPy = await fileExists(cwd, "main.py");
+    // Django's entrypoint is manage.py (no app.py/main.py at the root).
+    const managePy = await fileExists(cwd, "manage.py");
+    if (!appPy && !mainPy && !managePy)
         return null;
     let reqs;
     try {
@@ -39,10 +68,12 @@ async function detectPythonRuntime(cwd) {
     catch {
         return null;
     }
-    for (const lib of ["streamlit", "gradio", "flask"]) {
-        if (reqs.includes(lib))
-            return lib;
-    }
+    if (reqs.includes("streamlit") && appPy)
+        return "streamlit";
+    if (reqs.includes("gradio") && appPy)
+        return "gradio";
+    if (PY_WEB_SIGNALS.some((s) => reqs.includes(s)))
+        return "python_web";
     return null;
 }
 // Mirrors `frameworks/nextjs.py:_NEXT_STATIC_EXPORT_RE` and
@@ -130,6 +161,18 @@ export async function detectProject(cwd) {
                 ...(isSsr ? { runtime_kind: "ssr_next" } : {}),
             };
         }
+        // Node web backend (Express/Fastify/Koa/NestJS/Hapi/Hono/…) → node_web.
+        // Build (TypeScript compile) runs inside the container image, so the SPA
+        // pipeline is a no-op here.
+        if (detectNodeRuntime(pkg)) {
+            return {
+                framework_hint: "static",
+                build_cmd: "true",
+                output_dir: ".",
+                confident: true,
+                runtime_kind: "node_web",
+            };
+        }
         if (hasDep(pkg, "nuxt") || hasDep(pkg, "nuxt3") || (await fileExists(cwd, "nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"))) {
             const generateScript = pkg.scripts?.generate;
             const buildScript = pkg.scripts?.build;

package/dist/logs.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { detectMode, emit } from "./agent.js";
 const POLL_INTERVAL_MS = 1500;
 function colorForStream(stream) {
     switch (stream) {
@@ -11,6 +12,11 @@ function colorForStream(stream) {
     }
 }
 export async function streamDeployLogs(api, deployId) {
+    // In JSON mode stdout must stay a clean JSON-lines stream: build logs go
+    // out as structured `build_log` / `stage` events (N2), never as raw text
+    // interleaved with the lifecycle events. In human mode we keep the
+    // coloured stdout + stage banners on stderr.
+    const json = detectMode().json;
     let afterId = 0;
     let lastStage = null;
     // Loop until terminal — the server's per-stage timeouts bound duration.
@@ -19,12 +25,22 @@ export async function streamDeployLogs(api, deployId) {
         const poll = await api.pollLogs(deployId, afterId);
         if (poll.current_stage && poll.current_stage !== lastStage) {
             lastStage = poll.current_stage;
-            process.stderr.write(chalk.bold.blue(`▶ stage: ${poll.current_stage}\n`));
+            if (json) {
+                emit({ event: "stage", name: poll.current_stage });
+            }
+            else {
+                process.stderr.write(chalk.bold.blue(`▶ stage: ${poll.current_stage}\n`));
+            }
         }
         for (const line of poll.lines) {
             afterId = Math.max(afterId, line.id);
-            const paint = colorForStream(line.stream);
-            process.stdout.write(paint(line.line) + "\n");
+            if (json) {
+                emit({ event: "build_log", line: line.line, stream: line.stream });
+            }
+            else {
+                const paint = colorForStream(line.stream);
+                process.stdout.write(paint(line.line) + "\n");
+            }
         }
         if (poll.terminal) {
             return poll;

package/package.json

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