layero 0.1.6 → 0.1.8

package/dist/api.js

@@ -58,6 +58,12 @@ export class ApiClient {
     initUpload(projectId) {
         return this.request("POST", `/projects/${projectId}/uploads`);
     }
+    finalizeUpload(projectId, input) {
+        return this.request("POST", `/projects/${projectId}/uploads/finalize`, input);
+    }
+    completeSetup(projectId, input) {
+        return this.request("POST", `/projects/${projectId}/setup`, input);
+    }
     triggerDeploy(projectId, input) {
         return this.request("POST", `/projects/${projectId}/deploy`, input);
     }

package/dist/bin/layero.js

@@ -63,7 +63,12 @@ async function main() {
         .option("--name <name>", "project name (only used on first deploy)")
         .option("--project <id_or_slug>", "deploy into an existing project, ignoring local config")
         .option("-y, --yes", "non-interactive: accept defaults, fail if anything is missing")
-        .addHelpText("after", "\nExamples:\n  $ layero deploy\n  $ layero deploy --type vite\n  $ layero deploy --project my-site --yes")
+        .option("--config", "use framework/build settings + env vars from .layero/project.json (skips the browser setup wizard)")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ layero deploy                      # uploads source, opens setup wizard in the browser\n" +
+        "  $ layero deploy --config             # uses .layero/project.json end-to-end (CI-friendly)\n" +
+        "  $ layero deploy --type vite\n" +
+        "  $ layero deploy --project my-site --yes")
         .action(async (opts) => {
         await deployCmd(opts);
     });

package/dist/commands/deploy.js

@@ -4,7 +4,7 @@ import readline from "node:readline/promises";
 import chalk from "chalk";
 import { ApiClient, ApiError, uploadArchive } from "../api.js";
 import { loadConfig } from "../config.js";
-import { loadProjectConfig, projectConfigPath, saveProjectConfig, } from "../project-config.js";
+import { loadProjectConfig, persistProjectLinking, projectConfigPath, } from "../project-config.js";
 import { packCwd } from "../pack.js";
 import { streamDeployLogs } from "../logs.js";
 const VALID_TYPES = new Set([
@@ -18,23 +18,27 @@ const VALID_TYPES = new Set([
     "nuxt",
     "gatsby",
     "static",
+    "generic",
 ]);
-function dashboardUrl(apiUrl, projectId) {
-    // api.layero.ru → app.layero.ru. Falls back to app.layero.ru for any
-    // unrecognized api base (incl. localhost) — the user can override via
-    // LAYERO_DASHBOARD_URL if they're pointed at a non-standard env.
+function dashboardOrigin(apiUrl) {
     const override = process.env.LAYERO_DASHBOARD_URL;
     if (override)
-        return `${override.replace(/\/+$/, "")}/projects/${projectId}`;
+        return override.replace(/\/+$/, "");
     try {
         const u = new URL(apiUrl);
         u.hostname = u.hostname.replace(/^api\./, "app.");
-        return `${u.origin}/projects/${projectId}`;
+        return u.origin;
     }
     catch {
-        return `https://app.layero.ru/projects/${projectId}`;
+        return "https://app.layero.ru";
     }
 }
+function setupUrl(apiUrl, projectId) {
+    return `${dashboardOrigin(apiUrl)}/projects/${projectId}/setup`;
+}
+function projectUrl(apiUrl, projectId) {
+    return `${dashboardOrigin(apiUrl)}/projects/${projectId}`;
+}
 async function prompt(question, fallback) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -48,7 +52,7 @@ async function prompt(question, fallback) {
         rl.close();
     }
 }
-async function resolveProject(api, cwd, opts) {
+async function resolveOrCreateProject(api, cwd, opts, existing) {
     if (opts.project) {
         const all = await api.listProjects();
         const match = all.find((p) => p.id === opts.project) ??
@@ -58,7 +62,6 @@ async function resolveProject(api, cwd, opts) {
         }
         return { project: match, createdNow: false };
     }
-    const existing = await loadProjectConfig(cwd);
     if (existing) {
         try {
             const project = await api.getProject(existing.project_id);
@@ -73,61 +76,152 @@ async function resolveProject(api, cwd, opts) {
             throw err;
         }
     }
-    // No project_id locally — create one.
     const me = await api.me();
     if (!me.handle) {
         throw new Error("no handle set on your account. open https://app.layero.ru/onboarding " +
             "and pick one, then re-run.");
     }
     const fallbackName = path.basename(cwd);
-    const name = opts.name ?? (opts.yes ? fallbackName : await prompt("project name", fallbackName));
+    const name = opts.name ?? (opts.yes || opts.config ? fallbackName : await prompt("project name", fallbackName));
     const project = await api.createCliProject({
         name,
         framework_hint: opts.type,
     });
-    await saveProjectConfig(cwd, {
-        project_id: project.id,
-        slug: project.slug,
-        owner_slug: project.owner.slug,
-        apex_hostname: project.apex_hostname,
-        framework_hint: opts.type ?? null,
-    });
     return { project, createdNow: true };
 }
+async function packAndUpload(api, cwd, project) {
+    console.log(chalk.cyan("packing source..."));
+    const pack = await packCwd(cwd, project.slug);
+    console.log(chalk.dim(`  ${pack.fileCount} files, ${(pack.size / (1024 * 1024)).toFixed(2)} MB, sha256=${pack.sha256.slice(0, 12)}`));
+    console.log(chalk.cyan("requesting upload URL..."));
+    const init = await api.initUpload(project.id);
+    console.log(chalk.cyan("uploading archive..."));
+    await uploadArchive(init, pack.archivePath);
+    return {
+        archive_key: init.source_archive_key,
+        commit_sha: pack.sha256,
+        archivePath: pack.archivePath,
+    };
+}
+function ensureConfigComplete(cfg) {
+    if (!cfg) {
+        throw new Error("no .layero/project.json found. run `layero deploy` once without --config " +
+            "to create the project, fill in framework_hint/build_cmd/output_dir there, " +
+            "then re-run with --config.");
+    }
+    const missing = [];
+    if (!cfg.framework_hint)
+        missing.push("framework_hint");
+    if (!cfg.build_cmd)
+        missing.push("build_cmd");
+    if (!cfg.output_dir)
+        missing.push("output_dir");
+    if (missing.length > 0) {
+        throw new Error(`.layero/project.json is missing required fields for --config: ${missing.join(", ")}`);
+    }
+}
 export async function deployCmd(opts) {
     if (opts.type && !VALID_TYPES.has(opts.type.toLowerCase())) {
         throw new Error(`unknown --type "${opts.type}". valid: ${[...VALID_TYPES].join(", ")}`);
     }
-    const cfg = await loadConfig();
-    if (!cfg.token) {
+    const cliCfg = await loadConfig();
+    if (!cliCfg.token) {
         throw new Error("not logged in. run `layero login` first.");
     }
-    const api = new ApiClient(cfg);
+    const api = new ApiClient(cliCfg);
     const cwd = process.cwd();
-    const { project, createdNow } = await resolveProject(api, cwd, opts);
+    const existing = await loadProjectConfig(cwd);
+    const { project: created, createdNow } = await resolveOrCreateProject(api, cwd, opts, existing);
+    let project = created;
     if (project.source_type !== "cli") {
         throw new Error(`project "${project.slug}" is a GitHub-source project; ` +
             "use the dashboard's Deploy button or push to the linked repo.");
     }
-    // Project page on the dashboard. CDN propagation lags by ~30-60s after a
-    // fresh deploy, so a link to the project page is more useful as the
-    // immediate "where to look next" target than the live site URL.
-    const projectUrl = dashboardUrl(cfg.apiUrl, project.id);
+    // Persist linking metadata only — never touch hand-edited config fields
+    // or unknown keys the user may have added (a --config file is the user's
+    // source of truth, not ours). `persistProjectLinking` reads the file as
+    // raw JSON, overlays just project_id/slug/owner_slug/apex_hostname, and
+    // writes it back.
+    const persistedCfg = await persistProjectLinking(cwd, {
+        project_id: project.id,
+        slug: project.slug,
+        owner_slug: project.owner.slug,
+        apex_hostname: project.apex_hostname,
+    }, opts.type ?? null);
     if (createdNow) {
-        console.log(chalk.green(`created project ${project.slug} → ${projectUrl}`));
+        console.log(chalk.green(`created project ${project.slug}`));
     }
-    console.log(chalk.cyan("packing source..."));
-    const pack = await packCwd(cwd, project.slug);
-    console.log(chalk.dim(`  ${pack.fileCount} files, ${(pack.size / (1024 * 1024)).toFixed(2)} MB, sha256=${pack.sha256.slice(0, 12)}`));
+    // ─────────────────────────────────────────────────────────────────────
+    // Path A: --config — fully scripted, runs the setup endpoint with
+    //                     fields from .layero/project.json, then deploys.
+    // ─────────────────────────────────────────────────────────────────────
+    if (opts.config) {
+        ensureConfigComplete(persistedCfg);
+        if (project.status === "pending_setup") {
+            console.log(chalk.cyan("applying config..."));
+            project = await api.completeSetup(project.id, {
+                framework_hint: persistedCfg.framework_hint,
+                build_cmd: persistedCfg.build_cmd,
+                output_dir: persistedCfg.output_dir,
+                analytics_enabled: persistedCfg.analytics_enabled ?? false,
+                env_vars: persistedCfg.env_vars ?? {},
+            });
+        }
+        let upload = null;
+        try {
+            upload = await packAndUpload(api, cwd, project);
+            console.log(chalk.cyan("triggering deploy..."));
+            const deploy = await api.triggerDeploy(project.id, {
+                source_archive_key: upload.archive_key,
+                commit_sha: upload.commit_sha,
+                commit_message: "CLI deploy",
+                framework_hint: persistedCfg.framework_hint ?? undefined,
+            });
+            console.log(chalk.dim(`  deploy_id=${deploy.id}`));
+            const final = await streamDeployLogs(api, deploy.id);
+            if (final.status !== "ready") {
+                console.error(chalk.red(`deploy failed (${final.status})${final.error_message ? `: ${final.error_message}` : ""}`));
+                process.exitCode = 1;
+                return;
+            }
+            console.log(chalk.green(`deploy ready → ${projectUrl(cliCfg.apiUrl, project.id)}`));
+            console.log(chalk.dim(`  site: https://${project.apex_hostname} (CDN may take ~30-60s to propagate)`));
+        }
+        finally {
+            if (upload) {
+                await fs.unlink(upload.archivePath).catch(() => undefined);
+            }
+        }
+        return;
+    }
+    // ─────────────────────────────────────────────────────────────────────
+    // Path B: no flag — upload the source, stash it on the project row,
+    //                    print the setup URL. The user finishes the flow
+    //                    in the browser, exactly like a GitHub import.
+    // ─────────────────────────────────────────────────────────────────────
+    let upload = null;
     try {
-        console.log(chalk.cyan("requesting upload URL..."));
-        const init = await api.initUpload(project.id);
-        console.log(chalk.cyan("uploading archive..."));
-        await uploadArchive(init, pack.archivePath);
+        upload = await packAndUpload(api, cwd, project);
+        await api.finalizeUpload(project.id, {
+            source_archive_key: upload.archive_key,
+            commit_sha: upload.commit_sha,
+        });
+        if (project.status === "pending_setup") {
+            const url = setupUrl(cliCfg.apiUrl, project.id);
+            console.log("");
+            console.log(chalk.green("source uploaded — finish setup in the browser:"));
+            console.log(`  ${chalk.bold(url)}`);
+            console.log("");
+            console.log(chalk.dim("  pick framework, build command, output dir, env vars and click Deploy."));
+            console.log(chalk.dim("  to skip the browser next time, fill .layero/project.json and run `layero deploy --config`."));
+            return;
+        }
+        // Already-active project: behave like the old `layero deploy` — fire
+        // a build straight from the freshly-uploaded archive.
         console.log(chalk.cyan("triggering deploy..."));
         const deploy = await api.triggerDeploy(project.id, {
-            source_archive_key: init.source_archive_key,
-            commit_sha: pack.sha256,
+            source_archive_key: upload.archive_key,
+            commit_sha: upload.commit_sha,
             commit_message: "CLI deploy",
             framework_hint: opts.type,
         });
@@ -138,11 +232,12 @@ export async function deployCmd(opts) {
             process.exitCode = 1;
             return;
         }
-        console.log(chalk.green(`deploy ready → ${projectUrl}`));
+        console.log(chalk.green(`deploy ready → ${projectUrl(cliCfg.apiUrl, project.id)}`));
         console.log(chalk.dim(`  site: https://${project.apex_hostname} (CDN may take ~30-60s to propagate)`));
     }
     finally {
-        // Always clean up the local archive.
-        await fs.unlink(pack.archivePath).catch(() => undefined);
+        if (upload) {
+            await fs.unlink(upload.archivePath).catch(() => undefined);
+        }
     }
 }

package/dist/commands/link.js

@@ -1,7 +1,7 @@
 import chalk from "chalk";
 import { ApiClient } from "../api.js";
 import { loadConfig } from "../config.js";
-import { saveProjectConfig } from "../project-config.js";
+import { persistProjectLinking } from "../project-config.js";
 export async function linkCmd(idOrSlug) {
     const cfg = await loadConfig();
     if (!cfg.token) {
@@ -26,12 +26,15 @@ export async function linkCmd(idOrSlug) {
         }
         proj = match;
     }
-    await saveProjectConfig(process.cwd(), {
+    await persistProjectLinking(process.cwd(), {
         project_id: proj.id,
         slug: proj.slug,
         owner_slug: proj.owner.slug,
         apex_hostname: proj.apex_hostname,
-        framework_hint: proj.framework_hint,
-    });
+    }, proj.framework_hint ?? null);
     console.log(chalk.green(`linked ${proj.slug} (${proj.id}) → ./.layero/project.json`));
+    if (proj.status === "pending_setup") {
+        console.log(chalk.yellow("  note: project is in pending_setup. finish the setup wizard in the dashboard, " +
+            "or run `layero deploy` to upload source and get the wizard URL."));
+    }
 }

package/dist/project-config.js

@@ -20,3 +20,49 @@ export async function saveProjectConfig(cwd, cfg) {
     await fs.mkdir(dir, { recursive: true });
     await fs.writeFile(projectConfigPath(cwd), JSON.stringify(cfg, null, 2), "utf-8");
 }
+/**
+ * Persist linking fields without disturbing user-managed config.
+ *
+ * `layero deploy` runs every time the user ships code, but the only thing
+ * it should ever write back to .layero/project.json is the linkage —
+ * project_id / slug / owner_slug / apex_hostname. Hand-edited fields
+ * (build_cmd, output_dir, env_vars, analytics_enabled, framework_hint)
+ * and any unknown keys the user added must be preserved verbatim, or we
+ * silently break the user's --config file on every interactive deploy.
+ *
+ * Reads the file as raw JSON, overlays the linking subset, and writes it
+ * back. Returns the merged config the caller should treat as the new
+ * source of truth (matters for first-deploy where there's no existing
+ * file).
+ */
+export async function persistProjectLinking(cwd, linking, fallbackHint) {
+    const file = projectConfigPath(cwd);
+    let raw = {};
+    try {
+        const text = await fs.readFile(file, "utf-8");
+        raw = JSON.parse(text);
+    }
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            throw err;
+        }
+    }
+    const merged = {
+        ...raw,
+        project_id: linking.project_id,
+        slug: linking.slug,
+        owner_slug: linking.owner_slug,
+        apex_hostname: linking.apex_hostname,
+    };
+    if (linking.api_url !== undefined)
+        merged.api_url = linking.api_url;
+    // Only seed framework_hint if the user hasn't set one yet — once it's in
+    // the file (manually or from a prior --type), leave it alone.
+    if (fallbackHint != null &&
+        (raw.framework_hint === undefined || raw.framework_hint === null)) {
+        merged.framework_hint = fallbackHint;
+    }
+    await fs.mkdir(path.join(cwd, ".layero"), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(merged, null, 2), "utf-8");
+    return merged;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "layero",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Layero CLI — publish a local site with one command.",
   "license": "MIT",
   "type": "module",

package/scripts/postinstall.cjs

@@ -1,9 +1,13 @@
 #!/usr/bin/env node
-// Print a quick-start banner after `npm install -g layero`. We write to
-// stderr because npm 10+ buffers postinstall stdout by default
-// (`foreground-scripts=false`) and only surfaces it on script failure —
-// stderr is passed through verbatim, which is how other CLIs (vite,
-// cypress, etc.) deliver post-install messages.
+// Print a quick-start banner after `npm install -g layero`.
+//
+// npm 10+ buffers postinstall stdout AND stderr (foreground-scripts=false
+// by default), so writing to either is invisible unless the script fails
+// or the user passes --foreground-scripts. Workaround: write directly to
+// the controlling terminal at /dev/tty, which bypasses npm's pipe.
+//
+// On Windows there's no /dev/tty; we fall back to stderr (which Windows
+// npm doesn't buffer the same way) and silently skip on any error.
 
 if (process.env.CI) return;
 if (process.env.LAYERO_SKIP_POSTINSTALL) return;
@@ -14,17 +18,15 @@ const isGlobal = process.env.npm_config_global === "true";
 const isDirect = process.env.npm_package_name === "layero";
 if (!isGlobal && !isDirect) return;
 
-// Best-effort color: stderr is usually a TTY, but stay safe.
-const useColor = process.stderr.isTTY && (process.stderr.hasColors?.() ?? true);
-const c = useColor
-  ? {
-      reset: "\x1b[0m",
-      bold: "\x1b[1m",
-      dim: "\x1b[2m",
-      cyan: "\x1b[36m",
-      green: "\x1b[32m",
-    }
-  : { reset: "", bold: "", dim: "", cyan: "", green: "" };
+const fs = require("node:fs");
+
+const c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+};
 
 const lines = [
   "",
@@ -37,4 +39,17 @@ const lines = [
   `  ${c.dim}Docs: https://layero.ru${c.reset}`,
   "",
 ];
-process.stderr.write(lines.join("\n"));
+const banner = lines.join("\n");
+
+try {
+  if (process.platform === "win32") {
+    process.stderr.write(banner);
+  } else {
+    // Open the controlling tty directly. This bypasses npm's stdio pipes.
+    const fd = fs.openSync("/dev/tty", "w");
+    fs.writeSync(fd, banner);
+    fs.closeSync(fd);
+  }
+} catch {
+  // Headless install (no tty), or perms issue — give up silently.
+}