layero 0.1.7 → 0.2.0

package/dist/api.js

@@ -58,17 +58,23 @@ 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);
     }
     pollLogs(deployId, afterId) {
         return this.request("GET", `/deploys/${deployId}/logs?after_id=${afterId}`);
     }
-    setHandle(value) {
-        return this.request("POST", "/me/handle", { value });
+    setUsername(value) {
+        return this.request("POST", "/auth/me/username", { value });
     }
-    checkHandle(value) {
-        return this.request("GET", `/me/handle/check?value=${encodeURIComponent(value)}`);
+    checkUsername(value) {
+        return this.request("GET", `/auth/me/username/check?value=${encodeURIComponent(value)}`);
     }
 }
 export async function uploadArchive(init, filePath) {

package/dist/bin/layero.js

@@ -62,8 +62,17 @@ async function main() {
         .option("-t, --type <preset>", "framework hint (vite | next | astro | cra | sveltekit | nuxt | gatsby | static)")
         .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("-y, --yes", "non-interactive: accept defaults and skip --prod confirmation")
+        .option("--config", "use framework/build settings + env vars from .layero/project.json (skips the browser setup wizard)")
+        .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("--branch <name>", "deploy to a specific branch's environment. Wins over --prod.")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ layero deploy                      # preview on CLI pseudo-branch (never replaces prod)\n" +
+        "  $ layero deploy --prod               # production deploy (interactive confirm)\n" +
+        "  $ layero deploy --prod --yes         # production deploy, no prompt (CI)\n" +
+        "  $ layero deploy --branch=staging     # preview on a specific branch\n" +
+        "  $ layero deploy --config             # uses .layero/project.json end-to-end (CI-friendly)\n" +
+        "  $ layero deploy --type vite")
         .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,26 @@ async function prompt(question, fallback) {
         rl.close();
     }
 }
-async function resolveProject(api, cwd, opts) {
+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();
+    }
+}
+function deployTargeting(opts) {
+    if (opts.branch) {
+        return { target: "preview", branch: opts.branch };
+    }
+    return { target: opts.prod ? "production" : "preview" };
+}
+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 +81,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,63 +95,175 @@ 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 " +
+    if (!me.username) {
+        throw new Error("no username 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);
-    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);
+    const existing = await loadProjectConfig(cwd);
+    const { project: created, createdNow } = await resolveOrCreateProject(api, cwd, opts, existing);
+    let project = created;
+    if (project.cli_deploys_enabled === false) {
+        throw new Error(`CLI deploys are disabled on project "${project.slug}". ` +
+            "Enable them in project settings or use the dashboard's Deploy button.");
+    }
+    // Prompt before overwriting production. CLI deploys default to a per-project
+    // "cli" pseudo-branch (preview-only); --prod is the explicit opt-in to land
+    // on apex_hostname. --yes (CI) or --branch=<default_branch> bypass.
+    if (opts.prod && !opts.yes && !opts.branch) {
+        const ok = await confirm(`deploy to production (https://${project.apex_hostname})?`);
+        if (!ok) {
+            console.log(chalk.yellow("aborted."));
+            return;
+        }
+    }
+    // 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/organization_slug/apex_hostname,
+    // and writes it back.
+    const persistedCfg = await persistProjectLinking(cwd, {
+        project_id: project.id,
+        slug: project.slug,
+        organization_slug: project.organization.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 targeting = deployTargeting(opts);
+            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,
+                target: targeting.target,
+                branch: targeting.branch,
+            });
+            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)}`));
+            if (opts.prod && !opts.branch) {
+                console.log(chalk.dim(`  production: https://${project.apex_hostname} (CDN may take ~30-60s to propagate)`));
+            }
+            else {
+                console.log(chalk.dim(`  preview deploy — open the dashboard for the exact URL`));
+            }
+        }
+        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 targeting = deployTargeting(opts);
         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,
+            target: targeting.target,
+            branch: targeting.branch,
         });
         console.log(chalk.dim(`  deploy_id=${deploy.id}`));
         const final = await streamDeployLogs(api, deploy.id);
@@ -138,11 +272,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,
+        organization_slug: proj.organization.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/commands/login.js

@@ -66,7 +66,17 @@ export async function loginCmd(opts) {
         });
         server.on("error", reject);
         server.listen(desiredPort, "127.0.0.1", () => {
-            const port = server.address().port;
+            const addr = server.address();
+            // Defence-in-depth: confirm we actually bound to loopback before
+            // emitting `callback=…` to the browser. If listen() somehow returned
+            // a non-loopback address (Node bug, weird /etc/hosts) we'd otherwise
+            // hand the JWT redirect target out to whoever owns that interface.
+            if (!addr || addr.address !== "127.0.0.1") {
+                server.close();
+                reject(new Error(`expected to bind 127.0.0.1, got ${addr?.address ?? "null"}`));
+                return;
+            }
+            const port = addr.port;
             const callback = `http://127.0.0.1:${port}/callback`;
             const startUrl = `${cfg.apiUrl.replace(/\/+$/, "")}/auth/cli/start` +
                 `?provider=${provider}` +
@@ -87,10 +97,10 @@ export async function loginCmd(opts) {
     cfg.token = token;
     const probe = new ApiClient(cfg);
     const me = await probe.me();
-    cfg.user = { id: me.id, handle: me.handle, email: me.email };
+    cfg.user = { id: me.id, username: me.username, email: me.email };
     await saveConfig(cfg);
-    console.log(chalk.green(`logged in as ${me.handle ?? me.email ?? me.id}`));
-    if (!me.handle) {
-        console.log(chalk.yellow("no handle set — open https://app.layero.ru/onboarding to pick one."));
+    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."));
     }
 }

package/dist/commands/token.js

@@ -8,7 +8,7 @@ export async function tokenSetCmd(jwt) {
     const probe = new ApiClient(cfg);
     try {
         const me = await probe.me();
-        cfg.user = { id: me.id, handle: me.handle, email: me.email };
+        cfg.user = { id: me.id, username: me.username, email: me.email };
     }
     catch (err) {
         console.error(chalk.red(`token rejected by API: ${err.message}`));
@@ -16,9 +16,9 @@ export async function tokenSetCmd(jwt) {
         return;
     }
     await saveConfig(cfg);
-    console.log(chalk.green(`saved token for ${cfg.user?.handle ?? cfg.user?.email ?? cfg.user?.id}`));
-    if (!cfg.user?.handle) {
-        console.log(chalk.yellow("no handle set — open https://app.layero.ru/onboarding to pick one " +
+    console.log(chalk.green(`saved token for ${cfg.user?.username ?? cfg.user?.email ?? cfg.user?.id}`));
+    if (!cfg.user?.username) {
+        console.log(chalk.yellow("no username set — open https://app.layero.ru/onboarding to pick one " +
             "before `layero deploy`."));
     }
 }

package/dist/commands/whoami.js

@@ -11,7 +11,7 @@ export async function whoamiCmd() {
     const api = new ApiClient(cfg);
     const me = await api.me();
     console.log(`id:     ${me.id}`);
-    console.log(`handle: ${me.handle ?? chalk.yellow("(not set)")}`);
+    console.log(`username: ${me.username ?? chalk.yellow("(not set)")}`);
     console.log(`email:  ${me.email ?? "(none)"}`);
     if (me.github_login) {
         console.log(`github: ${me.github_login}`);

package/dist/project-config.js

@@ -6,7 +6,15 @@ export function projectConfigPath(cwd) {
 export async function loadProjectConfig(cwd) {
     try {
         const raw = await fs.readFile(projectConfigPath(cwd), "utf-8");
-        return JSON.parse(raw);
+        const parsed = JSON.parse(raw);
+        // Backward-read: configs written before V050 stored the field as
+        // `owner_slug`. Promote it to `organization_slug` in-memory so the
+        // rest of the CLI doesn't have to handle both names. Disk file gets
+        // rewritten on the next persistProjectLinking() call.
+        if (!parsed.organization_slug && parsed.owner_slug) {
+            parsed.organization_slug = parsed.owner_slug;
+        }
+        return parsed;
     }
     catch (err) {
         if (err?.code === "ENOENT") {
@@ -20,3 +28,52 @@ 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 / organization_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. Drops any legacy `owner_slug` key once the new name has been
+ * written, so future reads see only `organization_slug`. Returns the
+ * merged config the caller should treat as the new source of truth.
+ */
+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;
+        }
+    }
+    // Strip the legacy owner_slug if it sneaks in from an older CLI write.
+    delete raw.owner_slug;
+    const merged = {
+        ...raw,
+        project_id: linking.project_id,
+        slug: linking.slug,
+        organization_slug: linking.organization_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.7",
+  "version": "0.2.0",
   "description": "Layero CLI — publish a local site with one command.",
   "license": "MIT",
   "type": "module",