layero 0.8.0 → 0.8.1

package/README.md

@@ -176,10 +176,16 @@ Event types emitted on stdout:
 {"event":"deploy_started","deploy_id":"…"}
 {"event":"build_log","line":"…","stream":"…"}
 {"event":"stage","name":"…"}
-{"event":"ready","url":"…","deploy_id":"…"}
+{"event":"ready","url":"…","preview_url":"…","dashboard_url":"…","edge_ready":false,"edge_eta_seconds":N,"deploy_id":"…"}
+{"event":"promoted","url":"…","deploy_id":"…"}
 {"event":"error","code":"…","next_action":"…","message":"…"}
 ```
 
+On `ready`, `url` is the **live public site** (the apex — CLI uploads
+auto-promote to it), `preview_url` is reachable immediately while the apex CDN
+edge warms (`edge_ready=false`), and `dashboard_url` is the management page (not
+the site). Not logged in? `deploy` starts the device-flow itself (`auth_required`).
+
 Errors carry a stable `code` (e.g. `not_logged_in`, `invalid_type`,
 `project_not_found`, `cli_deploys_disabled`) and a `next_action` hint so
 your agent can react without parsing prose.

package/dist/commands/deploy.js

@@ -424,10 +424,20 @@ export async function deployCmd(opts) {
         const dashboardUrl = projectUrl(cliCfg.apiUrl, project.id);
         const apexUrl = `https://${project.apex_hostname}`;
         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);
+        // Public site URL — honour the preview-first contract the dashboard uses
+        // (probe states B/C): until the CDN apex is verified live (`cdn_ready`),
+        // the reachable address is the off-CDN preview domain. A fresh apex
+        // 404/000s for ~10-15min while CDN propagates, and for runtime apps the
+        // preview domain is the *permanent* address (the CDN apex can't serve
+        // POST/WebSocket). So only surface the canonical apex once it's warm;
+        // before that, hand back the preview. `edge_ready` / `edge_eta_seconds`
+        // below tell the caller the apex is on its way.
+        const cdnWarm = probe?.cdn_ready === true;
+        const liveUrl = cdnWarm
+            ? probe?.canonical_url ?? apexUrl
+            : probe?.preview_url ??
+                probe?.canonical_url ??
+                (promoted || !opts.branch ? apexUrl : dashboardUrl);
         emit({
             event: "ready",
             url: liveUrl,

package/dist/detect.js

@@ -1,542 +1,178 @@
 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) {
+import * as dc from "layero-detection";
+async function readJson(p) {
     try {
-        const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
-        return JSON.parse(raw);
+        return JSON.parse(await fs.readFile(p, "utf-8"));
     }
-    catch (err) {
-        if (err?.code === "ENOENT")
-            return null;
-        throw err;
+    catch {
+        return null;
     }
 }
-function hasDep(pkg, name) {
-    return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
+async function readText(p) {
+    try {
+        return await fs.readFile(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
 }
-async function fileExists(cwd, ...candidates) {
-    for (const c of candidates) {
-        try {
-            await fs.access(path.join(cwd, c));
+const HTML_SKIP_DIRS = new Set(["node_modules", ".git", ".cache", "dist", "build", "out", "public"]);
+async function dirHasHtml(base, depth = 0) {
+    if (depth > 6)
+        return false;
+    let entries;
+    try {
+        entries = await fs.readdir(base, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const e of entries) {
+        if (e.isFile() && (e.name.endsWith(".html") || e.name.endsWith(".htm")))
             return true;
-        }
-        catch {
-            // try next
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && !HTML_SKIP_DIRS.has(e.name)) {
+            if (await dirHasHtml(path.join(base, e.name), depth + 1))
+                return true;
         }
     }
     return false;
 }
-// Python runtime: `app.py`/`main.py` entry + a runtime lib in requirements.txt.
-// Lockstep with detect_runtime() (backend) / runtime_detect.py (builder):
-// 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) {
-    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;
+/** Build a detect_core Snapshot from the local filesystem (the CLI's disk
+ * fidelity — the analogue of detect_core.py's snapshot_from_dir). */
+async function snapshotFromDir(cwd) {
+    const files = new Set();
+    const dirs = new Set();
     try {
-        reqs = (await fs.readFile(path.join(cwd, "requirements.txt"), "utf-8")).toLowerCase();
+        for (const e of await fs.readdir(cwd, { withFileTypes: true })) {
+            (e.isDirectory() ? dirs : files).add(e.name);
+        }
     }
     catch {
-        return null;
+        /* empty / unreadable cwd */
     }
-    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
-// `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;
-// Strip JS line and block comments before regex matching. Without this,
-// a comment like `// see output: 'export'` falsely matches as
-// static-export — observed 2026-05-26 on the SSR smoke canary fixture.
-// Naive (does not understand strings that contain comment-like tokens),
-// but real next.config files don't have that shape.
-const JS_COMMENT_RE = /\/\/[^\n]*|\/\*[\s\S]*?\*\//gm;
-const stripJsComments = (text) => text.replace(JS_COMMENT_RE, "");
-async function readNextConfigText(cwd) {
-    for (const name of ["next.config.mjs", "next.config.ts", "next.config.js", "next.config.cjs"]) {
+    for (const nested of [
+        ".vitepress/config.ts", ".vitepress/config.js", ".vitepress/config.mts", ".vitepress/config.mjs",
+        "docs/.vitepress/config.ts", "docs/.vitepress/config.js", "docs/.vitepress/config.mts", "docs/.vitepress/config.mjs",
+    ]) {
         try {
-            return await fs.readFile(path.join(cwd, name), "utf-8");
-        }
-        catch (err) {
-            if (err?.code === "ENOENT")
-                continue;
-            return null;
+            await fs.access(path.join(cwd, nested));
+            files.add(nested);
         }
-    }
-    return null;
+        catch {
+            /* absent */
+        }
+    }
+    const packageJson = (await readJson(path.join(cwd, "package.json")));
+    const requirementsTxt = await readText(path.join(cwd, "requirements.txt"));
+    const layeroJson = await readJson(path.join(cwd, "layero.json"));
+    const configTexts = {};
+    const candidates = new Set(dc.CONFIG_TEXT_FILES);
+    for (const bn of dc.CONFIG_TEXT_BASENAMES)
+        for (const ext of dc.CONFIG_EXTENSIONS)
+            candidates.add(bn + ext);
+    // nuxt.config / svelte.config drive the SSR warning below.
+    for (const n of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js", "svelte.config.js", "svelte.config.ts"])
+        candidates.add(n);
+    for (const name of candidates) {
+        const t = await readText(path.join(cwd, name));
+        if (t !== null)
+            configTexts[name] = t.slice(0, 64 * 1024);
+    }
+    return dc.snapshotFromInputs({
+        packageJson,
+        requirementsTxt,
+        files,
+        dirs,
+        configTexts,
+        layeroJson: layeroJson && typeof layeroJson === "object" ? layeroJson : null,
+        hasHtml: await dirHasHtml(cwd),
+    });
 }
-// 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(stripJsComments(text));
+const NUXT_STATIC_SSR_RE = /\bssr\s*:\s*false\b/m;
+const NUXT_STATIC_PRESET_RE = /preset\s*:\s*['"]static['"]/m;
+const JS_COMMENT_RE = /\/\/[^\n]*|\/\*[\s\S]*?\*\//gm;
+function hasDep(pkg, name) {
+    return Boolean(pkg && ((pkg.dependencies ?? {})[name] ?? (pkg.devDependencies ?? {})[name]));
 }
-async function hasAnyHtml(cwd) {
-    // Shallow check — only top-level. Recursive walk is too expensive here
-    // and the static fallback is already permissive enough.
-    try {
-        const entries = await fs.readdir(cwd);
-        return entries.some((e) => e.endsWith(".html") || e.endsWith(".htm"));
+/** Mirror of the builder's static-host pre-flight warning for the two
+ * frameworks that build a server by default (Nuxt, SvelteKit). */
+function ssrWarning(snap, framework) {
+    const pkg = snap.packageJson;
+    if (framework === "nuxt") {
+        const scripts = pkg?.scripts ?? {};
+        const hasGenerate = Object.values(scripts).some((v) => typeof v === "string" && v.includes("nuxt generate"));
+        let declaresStatic = false;
+        for (const n of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js"]) {
+            const txt = snap.configTexts[n];
+            if (txt !== undefined) {
+                const stripped = txt.replace(JS_COMMENT_RE, "");
+                declaresStatic = NUXT_STATIC_SSR_RE.test(stripped) || NUXT_STATIC_PRESET_RE.test(stripped);
+                break;
+            }
+        }
+        if (!hasGenerate && !declaresStatic) {
+            return ("Nuxt без `nuxt generate` или `ssr: false` собирается как SSR-сервер; " +
+                "Layero хостит только статику Nuxt. Добавьте `\"generate\": \"nuxt generate\"` " +
+                "в scripts или поставьте `ssr: false` в nuxt.config.");
+        }
     }
-    catch {
-        return false;
+    if (framework === "sveltekit") {
+        const hasStatic = hasDep(pkg, "@sveltejs/adapter-static");
+        if (hasStatic)
+            return undefined;
+        const allDeps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+        const serverAdapter = Object.keys(allDeps).find((d) => d.startsWith("@sveltejs/adapter-") && d !== "@sveltejs/adapter-static");
+        if (serverAdapter) {
+            return `SvelteKit использует ${serverAdapter} (серверный адаптер). Layero хостит только статику — поставьте @sveltejs/adapter-static.`;
+        }
+        return "SvelteKit без явного адаптера — поставьте @sveltejs/adapter-static для статического хостинга.";
     }
-}
-// Build command preference:
-//   1. If `scripts.build` exists in package.json, use `npm run build` —
-//      it respects whatever the user set up (custom flags, monorepo
-//      filters, etc.). `npm run` works regardless of package manager
-//      installed on the build VM, because the builder runs `npm` itself.
-//   2. Otherwise, use the framework's CLI directly via `npx`.
-function buildCmd(pkg, fallback) {
-    if (pkg?.scripts?.build)
-        return "npm run build";
-    return fallback;
+    return undefined;
 }
 /**
- * Detect framework / build command / output directory from the project
- * shape. Mirrors the builder's detector ([core/builder/src/frameworks])
- * so the values we ship to `completeSetup` match what the builder will
- * actually do at build time.
- *
- * Order matters: more specific signals first (Next, Nuxt, SvelteKit,
- * Gatsby, Astro, Docusaurus) before catch-alls (Vite, CRA, static).
+ * Detect framework / build command / output directory from the project shape.
+ * Identity now comes from the unified detect_core (the same spec the builder
+ * and backend wizard use); this function only adapts the resulting BuildPlan
+ * into the CLI's `Detected` shape and its conventions (SSR Next reports `.next`,
+ * runtime apps report a `static` placeholder + runtime_kind).
  */
 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", "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;
+    const snap = await snapshotFromDir(cwd);
+    const plan = dc.detect(snap);
+    if (plan.runtimeKind !== null) {
+        if (plan.projectType === "ssr_next") {
+            // SSR Next builds in the runtime-builder; surface the framework + the
+            // `.next` dir the CLI has always reported (vestigial but expected).
+            const [unit] = dc.detectFramework(snap, "nextjs");
             return {
                 framework_hint: "nextjs",
-                build_cmd: buildCmd(pkg, "npx next build"),
-                output_dir: isSsr ? ".next" : "out",
-                confident: true,
-                ...(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;
-            const cmd = generateScript
-                ? "npm run generate"
-                : buildScript
-                    ? "npm run build"
-                    : "npx nuxt generate";
-            // Nuxt defaults to SSR. Layero hosts only static for Nuxt today,
-            // so a project without an explicit static signal (`nuxt generate`
-            // script, or `ssr: false` / `nitro.preset='static'` in config)
-            // will build but the resulting `.output/server/` is useless to us.
-            // Mirrors builder's `frameworks/nuxt.py` SSR hint.
-            const nuxtStatic = !!generateScript || (await nuxtConfigDeclaresStatic(cwd));
-            return {
-                framework_hint: "nuxt",
-                build_cmd: cmd,
-                output_dir: ".output/public",
-                confident: true,
-                ...(nuxtStatic ? {} : {
-                    ssr_warning: "Nuxt без `nuxt generate` или `ssr: false` собирается как SSR-сервер; " +
-                        "Layero хостит только статику Nuxt. Добавьте `\"generate\": \"nuxt generate\"` " +
-                        "в scripts или поставьте `ssr: false` в nuxt.config.",
-                }),
-            };
-        }
-        // Remix / React Router v7 before SvelteKit/Vite — RR7 ships Vite
-        // internally, so the Vite-dep check would otherwise win. Mirrors the
-        // builder's RemixFramework + backend `remix` table entry (output
-        // build/client). Was missing from the CLI entirely — same dual-detector
-        // gap class as Angular: a Remix repo deployed via the CLI fell through
-        // to the static fallback and shipped raw sources.
-        if (hasDep(pkg, "@remix-run/dev") ||
-            hasDep(pkg, "@remix-run/react") ||
-            hasDep(pkg, "@remix-run/node") ||
-            hasDep(pkg, "@react-router/dev") ||
-            hasDep(pkg, "@react-router/node") ||
-            (await fileExists(cwd, "react-router.config.ts", "react-router.config.js"))) {
-            return {
-                framework_hint: "remix",
-                build_cmd: buildCmd(pkg, "npx react-router build"),
-                output_dir: "build/client",
+                build_cmd: unit.buildCmd ?? "npx next build",
+                output_dir: ".next",
                 confident: true,
+                runtime_kind: "ssr_next",
             };
         }
-        if (hasDep(pkg, "@sveltejs/kit") || (await fileExists(cwd, "svelte.config.js"))) {
-            // SvelteKit needs an adapter. adapter-static = SPA path; anything
-            // else (adapter-node, adapter-auto, …) is server-side. Mirrors
-            // builder's `frameworks/svelte.py:validate_static`.
-            const hasStaticAdapter = hasDep(pkg, "@sveltejs/adapter-static");
-            const serverAdapter = !hasStaticAdapter
-                ? Object.keys({ ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) })
-                    .find((d) => d.startsWith("@sveltejs/adapter-") && d !== "@sveltejs/adapter-static")
-                : undefined;
-            let ssrWarning;
-            if (serverAdapter) {
-                ssrWarning =
-                    `SvelteKit использует ${serverAdapter} (серверный адаптер). ` +
-                        "Layero хостит только статику — поставьте `@sveltejs/adapter-static`.";
-            }
-            else if (!hasStaticAdapter) {
-                ssrWarning =
-                    "SvelteKit без явного адаптера — поставьте `@sveltejs/adapter-static` " +
-                        "для статического хостинга на Layero.";
-            }
-            return {
-                framework_hint: "sveltekit",
-                build_cmd: buildCmd(pkg, "npx vite build"),
-                output_dir: "build",
-                confident: true,
-                ...(ssrWarning ? { ssr_warning: ssrWarning } : {}),
-            };
-        }
-        if (hasDep(pkg, "gatsby") || (await fileExists(cwd, "gatsby-config.js", "gatsby-config.ts"))) {
-            return {
-                framework_hint: "gatsby",
-                build_cmd: buildCmd(pkg, "npx gatsby build"),
-                output_dir: "public",
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "astro") || (await fileExists(cwd, "astro.config.mjs", "astro.config.ts", "astro.config.js"))) {
-            return {
-                framework_hint: "astro",
-                build_cmd: buildCmd(pkg, "npx astro build"),
-                output_dir: "dist",
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "@docusaurus/core") || (await fileExists(cwd, "docusaurus.config.js", "docusaurus.config.ts", "docusaurus.config.mjs"))) {
-            return {
-                framework_hint: "docusaurus",
-                build_cmd: buildCmd(pkg, "npx docusaurus build"),
-                output_dir: "build",
-                confident: true,
-            };
-        }
-        // Storybook before Vite/CRA: Storybook 7+ uses Vite or webpack
-        // internally, so `vite` / `react-scripts` is in deps. Without
-        // listing it first the SPA Vite path would output_dir=dist, which
-        // doesn't exist after `build-storybook`.
-        const storybookDeps = [
-            "@storybook/cli",
-            "@storybook/react",
-            "@storybook/react-vite",
-            "@storybook/react-webpack5",
-            "@storybook/vue",
-            "@storybook/vue3",
-            "@storybook/vue3-vite",
-            "@storybook/svelte",
-            "@storybook/svelte-vite",
-            "@storybook/web-components",
-            "@storybook/web-components-vite",
-            "@storybook/preact",
-            "@storybook/angular",
-            "@storybook/nextjs",
-            "@storybook/html",
-            "@storybook/html-vite",
-            "storybook",
-        ];
-        const hasStorybookDep = storybookDeps.some((d) => hasDep(pkg, d));
-        const hasStorybookScript = pkg.scripts?.["build-storybook"] !== undefined
-            || Object.values(pkg.scripts ?? {}).some((s) => typeof s === "string" && s.includes("storybook build"));
-        const hasStorybookDir = await fileExists(cwd, ".storybook/main.js", ".storybook/main.ts", ".storybook/main.cjs", ".storybook/main.mjs");
-        if (hasStorybookDep || hasStorybookScript || hasStorybookDir) {
-            const cmd = pkg.scripts?.["build-storybook"]
-                ? "npm run build-storybook"
-                : (pkg.scripts?.build && pkg.scripts.build.includes("storybook"))
-                    ? "npm run build"
-                    : "npx storybook build";
-            return {
-                framework_hint: "storybook",
-                build_cmd: cmd,
-                output_dir: "storybook-static",
-                confident: true,
-            };
-        }
-        // VitePress before generic Vite: VitePress repos often pull `vite`
-        // transitively, and the SPA Vite path would set output_dir=dist —
-        // wrong for VitePress, which writes to `.vitepress/dist/` (or
-        // `docs/.vitepress/dist/` when the config lives under docs/).
-        if (hasDep(pkg, "vitepress") || (await hasVitepressConfig(cwd))) {
-            const docsLayout = await hasVitepressConfig(cwd, "docs/.vitepress");
-            const outputDir = docsLayout ? "docs/.vitepress/dist" : ".vitepress/dist";
-            const cmd = pkg.scripts?.["docs:build"]
-                ? "npm run docs:build"
-                : buildCmd(pkg, "npx vitepress build");
-            return {
-                framework_hint: "vitepress",
-                build_cmd: cmd,
-                output_dir: outputDir,
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "vite") || (await fileExists(cwd, "vite.config.ts", "vite.config.js", "vite.config.mjs"))) {
-            return {
-                framework_hint: "vite",
-                build_cmd: buildCmd(pkg, "npx vite build"),
-                output_dir: "dist",
-                confident: true,
-            };
-        }
-        // Angular after Vite — mirrors builder ALL order. Angular ships its
-        // own CLI (`ng build`) and writes to `dist/{project}/` (Angular <17)
-        // or `dist/{project}/browser/` (17+ `application` builder), NOT bare
-        // `dist`. Until this branch existed the CLI fell through to the
-        // static fallback (`output_dir='.'`), so the first deploy of an
-        // Angular repo shipped the raw sources — the dist/<project> S3 404
-        // incident. `angularOutputDir` parses angular.json to pin the path
-        // (lockstep with `frameworks/angular.py:extract_output_dir`).
-        if (hasDep(pkg, "@angular/core") || (await fileExists(cwd, "angular.json"))) {
-            return {
-                framework_hint: "angular",
-                build_cmd: buildCmd(pkg, "npx ng build"),
-                output_dir: await angularOutputDir(cwd),
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "react-scripts")) {
-            return {
-                framework_hint: "cra",
-                build_cmd: buildCmd(pkg, "npx react-scripts build"),
-                output_dir: "build",
-                confident: true,
-            };
-        }
-        // Eleventy late in the package.json branch — `@11ty/eleventy` is
-        // unique enough not to collide with other frameworks, but Vite /
-        // CRA / etc. should win if both are present (a project that pulls
-        // both is probably using Vite as the runtime and 11ty just for one
-        // build step).
-        if (hasDep(pkg, "@11ty/eleventy") ||
-            hasDep(pkg, "eleventy") ||
-            (await fileExists(cwd, ".eleventy.js", "eleventy.config.js", "eleventy.config.mjs", "eleventy.config.cjs"))) {
-            return {
-                framework_hint: "eleventy",
-                build_cmd: buildCmd(pkg, "npx @11ty/eleventy"),
-                output_dir: "_site",
-                confident: true,
-            };
-        }
-        // package.json present but no framework matched → a custom Node build,
-        // NOT a static site. Mirrors the backend's detect(): `pkg is None →
-        // _STATIC`, otherwise `_GENERIC` (npm run build → dist). Falling through
-        // to the static fallback here shipped the unbuilt sources — exactly the
-        // `diplomtest` case (Express app + custom build script detected as static
-        // by the CLI but `generic` by the backend).
-        return {
-            framework_hint: "generic",
-            build_cmd: buildCmd(pkg, "npm run build"),
-            output_dir: "dist",
-            confident: false,
-        };
-    }
-    // Python runtimes (Streamlit / Gradio / Flask): an `app.py` entry plus a
-    // runtime lib in requirements.txt. Mirrors detect_runtime() / runtime_detect.py.
-    // No package.json, so without this they fall to the static fallback and ship
-    // `app.py` as a static file (never runs) — the `streamlit-hello` case.
-    const pyRuntime = await detectPythonRuntime(cwd);
-    if (pyRuntime) {
+        // node_web / python_web / streamlit / gradio → static placeholder; the
+        // container serves the app, the SPA pipeline is a no-op.
         return {
             framework_hint: "static",
             build_cmd: "true",
             output_dir: ".",
             confident: true,
-            runtime_kind: pyRuntime,
-        };
-    }
-    // Non-Node SSGs (Hugo today). Recognise repos without package.json
-    // before we fall back to "static" with a no-op build command — Hugo
-    // needs `hugo --gc --minify` and writes to `public/`, the static
-    // fallback would just upload the raw .md sources.
-    if ((await fileExists(cwd, "hugo.toml", "hugo.yaml", "hugo.json")) ||
-        ((await fileExists(cwd, "config.toml", "config.yaml", "config.json")) &&
-            (await hasHugoConfigMarker(cwd)))) {
-        return {
-            framework_hint: "hugo",
-            build_cmd: "hugo --gc --minify",
-            output_dir: "public",
-            confident: true,
+            runtime_kind: plan.projectType,
         };
     }
-    // No (or unrecognised) package.json. If there's HTML on disk we treat
-    // the current directory as a static site. Otherwise we still fall back
-    // to static — it's the most permissive option and the builder will
-    // ship whatever is on disk verbatim.
-    const _staticHtml = await hasAnyHtml(cwd);
+    const framework = plan.framework;
+    const build_cmd = plan.buildCmd ?? (framework === "static" ? "true" : "npm run build");
+    const warning = ssrWarning(snap, framework);
     return {
-        framework_hint: "static",
-        build_cmd: "true",
-        output_dir: ".",
-        confident: _staticHtml,
+        framework_hint: framework,
+        build_cmd,
+        output_dir: plan.outputDir ?? ".",
+        confident: plan.confident,
+        ...(warning ? { ssr_warning: warning } : {}),
     };
 }
-const HUGO_CONFIG_TOKENS = [
-    "baseURL",
-    "baseurl",
-    "languageCode",
-    "languagecode",
-    "[params]",
-    "[markup]",
-    "[menu",
-    "[taxonomies]",
-    "hugoVersion",
-    "minVersion",
-    "theme",
-];
-// Match `ssr: false` or `nitro: { preset: 'static' }` in nuxt.config —
-// either marker keeps the project on the SPA pipeline. Mirrors the same
-// "string-search before AST" approach used for Next.js.
-const NUXT_STATIC_SSR_RE = /\bssr\s*:\s*false\b/m;
-const NUXT_STATIC_PRESET_RE = /preset\s*:\s*['"]static['"]/m;
-async function nuxtConfigDeclaresStatic(cwd) {
-    for (const name of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js"]) {
-        try {
-            const txt = stripJsComments(await fs.readFile(path.join(cwd, name), "utf-8"));
-            if (NUXT_STATIC_SSR_RE.test(txt) || NUXT_STATIC_PRESET_RE.test(txt))
-                return true;
-            return false; // config found, no static marker → SSR
-        }
-        catch (err) {
-            if (err?.code === "ENOENT")
-                continue;
-            return false;
-        }
-    }
-    return false; // no config at all → defaults to SSR
-}
-async function hasVitepressConfig(cwd, prefix = ".vitepress") {
-    for (const name of ["config.ts", "config.js", "config.mts", "config.mjs"]) {
-        try {
-            await fs.access(path.join(cwd, prefix, name));
-            return true;
-        }
-        catch {
-            // try next
-        }
-    }
-    return false;
-}
-async function hasHugoConfigMarker(cwd) {
-    for (const fn of ["config.toml", "config.yaml", "config.json"]) {
-        try {
-            const head = await fs.readFile(path.join(cwd, fn), "utf-8");
-            if (HUGO_CONFIG_TOKENS.some((t) => head.includes(t)))
-                return true;
-        }
-        catch {
-            // try next
-        }
-    }
-    return false;
-}
-// Resolve Angular's real build output directory from angular.json.
-// Lockstep with `core/builder/src/frameworks/angular.py:extract_output_dir`
-// — same dual-detector-drift class as Next.js static-export, so the two
-// implementations must agree (parity fixtures in
-// core/tests/fixtures/framework-detect/angular-*).
-//
-// Resolution:
-//   1. defaultProject if set & present, else first project in `projects`
-//   2. project.architect.build.options.outputPath, else the CLI default
-//      `dist/{projectName}`
-//   3. strip leading `./`
-//   4. append `/browser` for the Angular 17+ `application` builder
-//      (builder id ends with `:application`) — it writes the served
-//      assets one level deeper. We also probe disk in case the repo was
-//      built locally before `layero deploy`.
-// Returns the framework default `dist` on any parse error — matches
-// AngularFramework.default_output_dir, and the builder re-derives the
-// exact path at upload time anyway.
-async function angularOutputDir(cwd) {
-    const FALLBACK = "dist";
-    let cfg;
-    try {
-        cfg = JSON.parse(await fs.readFile(path.join(cwd, "angular.json"), "utf-8"));
-    }
-    catch {
-        return FALLBACK;
-    }
-    const projects = cfg?.projects;
-    if (!projects || typeof projects !== "object")
-        return FALLBACK;
-    const firstName = Object.keys(projects)[0];
-    if (!firstName)
-        return FALLBACK;
-    const defaultName = cfg.defaultProject;
-    const projectName = defaultName && projects[defaultName] ? defaultName : firstName;
-    const buildCfg = projects[projectName]?.architect?.build;
-    if (!buildCfg || typeof buildCfg !== "object")
-        return FALLBACK;
-    const opts = (buildCfg.options ?? {});
-    const rawOut = typeof opts === "object" && opts ? opts.outputPath : undefined;
-    let out = typeof rawOut === "string" && rawOut.trim() ? rawOut.trim() : `dist/${projectName}`;
-    if (out.startsWith("./"))
-        out = out.slice(2);
-    const builderId = typeof buildCfg.builder === "string" ? buildCfg.builder : "";
-    const isApplicationBuilder = builderId.endsWith(":application");
-    let browserExists = false;
-    try {
-        browserExists = (await fs.stat(path.join(cwd, out, "browser"))).isDirectory();
-    }
-    catch {
-        // not built locally — rely on the builder-id signal below
-    }
-    return browserExists || isApplicationBuilder ? `${out}/browser` : out;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "layero",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Layero CLI — publish a local site with one command. No git, no GitHub, agent-friendly (Cursor, Claude Code).",
   "license": "MIT",
   "type": "module",
@@ -49,6 +49,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "ignore": "^5.3.2",
+    "layero-detection": "^0.1.0",
     "open": "^10.1.0",
     "tar": "^7.4.3"
   },