layero 0.1.8 → 0.3.0

package/dist/api.js

@@ -70,11 +70,18 @@ export class ApiClient {
     pollLogs(deployId, afterId) {
         return this.request("GET", `/deploys/${deployId}/logs?after_id=${afterId}`);
     }
-    setHandle(value) {
-        return this.request("POST", "/me/handle", { value });
+    listProjectDeploys(projectId, branch) {
+        const qs = branch ? `?branch=${encodeURIComponent(branch)}` : "";
+        return this.request("GET", `/projects/${projectId}/deploys${qs}`);
     }
-    checkHandle(value) {
-        return this.request("GET", `/me/handle/check?value=${encodeURIComponent(value)}`);
+    rollbackProject(projectId, input) {
+        return this.request("POST", `/projects/${projectId}/rollback`, input);
+    }
+    setUsername(value) {
+        return this.request("POST", "/auth/me/username", { 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

@@ -10,6 +10,7 @@ import { projectsListCmd } from "../commands/projects.js";
 import { linkCmd } from "../commands/link.js";
 import { tokenSetCmd } from "../commands/token.js";
 import { deployCmd } from "../commands/deploy.js";
+import { deploysListCmd, rollbackCmd } from "../commands/deploys.js";
 import { loginCmd } from "../commands/login.js";
 // Read version from the shipped package.json (two levels up from dist/bin/).
 const pkgPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
@@ -44,6 +45,33 @@ async function main() {
         .command("list")
         .description("List your projects.")
         .action(projectsListCmd);
+    const deploys = program
+        .command("deploys")
+        .description("List and inspect deploys for the linked project.");
+    deploys
+        .command("list")
+        .description("List recent deploys for the project's default branch (or --branch).")
+        .option("--project <id_or_slug>", "target project (default: linked .layero/project.json)")
+        .option("--branch <name>", "branch to list deploys from (default: project's default_branch)")
+        .option("--limit <n>", "max entries to show (default 20)", (v) => Number(v))
+        .action(async (opts) => {
+        await deploysListCmd(opts);
+    });
+    program
+        .command("rollback")
+        .description("Re-activate the previous successful deploy on the project's default branch.")
+        .option("--project <id_or_slug>", "target project (default: linked .layero/project.json)")
+        .option("--branch <name>", "branch to roll back (default: project's default_branch)")
+        .option("--deploy <id_or_sha>", "explicit deploy id or commit sha prefix to roll back to")
+        .option("-y, --yes", "skip the confirmation prompt (CI)")
+        .addHelpText("after", "\nExamples:\n" +
+        "  $ layero rollback                       # roll back default branch to previous ready deploy\n" +
+        "  $ layero rollback --branch=staging      # roll back the staging branch\n" +
+        "  $ layero rollback --deploy=a3f9c2b      # roll back to a specific commit/deploy\n" +
+        "  $ layero rollback --yes                 # CI-friendly, no prompt")
+        .action(async (opts) => {
+        await rollbackCmd(opts);
+    });
     program
         .command("link <id_or_slug>")
         .description("Link the current directory to an existing project.")
@@ -62,13 +90,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")
+        .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                      # uploads source, opens setup wizard in the browser\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\n" +
-        "  $ layero deploy --project my-site --yes")
+        "  $ layero deploy --type vite")
         .action(async (opts) => {
         await deployCmd(opts);
     });

package/dist/commands/deploy.js

@@ -52,6 +52,25 @@ async function prompt(question, fallback) {
         rl.close();
     }
 }
+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();
@@ -77,8 +96,8 @@ async function resolveOrCreateProject(api, cwd, opts, existing) {
         }
     }
     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);
@@ -133,19 +152,29 @@ export async function deployCmd(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.");
+    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/owner_slug/apex_hostname, and
-    // writes it back.
+    // 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,
-        owner_slug: project.owner.slug,
+        organization_slug: project.organization.slug,
         apex_hostname: project.apex_hostname,
     }, opts.type ?? null);
     if (createdNow) {
@@ -171,11 +200,14 @@ export async function deployCmd(opts) {
         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);
@@ -185,7 +217,12 @@ export async function deployCmd(opts) {
                 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)`));
+            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) {
@@ -219,11 +256,14 @@ export async function deployCmd(opts) {
         // 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: 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);

package/dist/commands/deploys.js

@@ -0,0 +1,146 @@
+import readline from "node:readline/promises";
+import chalk from "chalk";
+import { ApiClient, ApiError } from "../api.js";
+import { loadConfig } from "../config.js";
+import { loadProjectConfig } from "../project-config.js";
+async function resolveProjectId(api, cwd, override) {
+    if (override) {
+        // Accept slug or id; resolve via list to keep consistent error UX.
+        const all = await api.listProjects();
+        const match = all.find((p) => p.id === override) ?? all.find((p) => p.slug === override);
+        if (!match)
+            throw new Error(`no project with id/slug "${override}"`);
+        return match.id;
+    }
+    const cfg = await loadProjectConfig(cwd);
+    if (!cfg) {
+        throw new Error("no .layero/project.json found. run `layero deploy` to create one, or pass --project <slug>.");
+    }
+    return cfg.project_id;
+}
+function shortSha(sha) {
+    return (sha ?? "").slice(0, 7);
+}
+function statusBadge(status) {
+    switch (status) {
+        case "ready":
+            return chalk.green("● ready");
+        case "building":
+        case "queued":
+            return chalk.cyan(`● ${status}`);
+        case "failed":
+            return chalk.red("● failed");
+        default:
+            return chalk.dim(`● ${status}`);
+    }
+}
+function fmtTime(iso) {
+    if (!iso)
+        return "—";
+    const d = new Date(iso);
+    // YYYY-MM-DD HH:mm
+    const pad = (n) => String(n).padStart(2, "0");
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function fmtSource(d) {
+    const t = d.source_type ?? "github";
+    if (t === "cli")
+        return chalk.dim("(cli)");
+    if (d.triggered_by_user_id)
+        return chalk.dim("(manual)");
+    return chalk.dim("(push)");
+}
+export async function deploysListCmd(opts) {
+    const cliCfg = await loadConfig();
+    if (!cliCfg.token)
+        throw new Error("not logged in. run `layero login` first.");
+    const api = new ApiClient(cliCfg);
+    const projectId = await resolveProjectId(api, process.cwd(), opts.project);
+    const deploys = await api.listProjectDeploys(projectId, opts.branch);
+    const limit = opts.limit ?? 20;
+    const rows = deploys.slice(0, limit);
+    if (rows.length === 0) {
+        console.log(chalk.dim("no deploys yet."));
+        return;
+    }
+    for (const d of rows) {
+        const line = [
+            statusBadge(d.status),
+            chalk.bold(shortSha(d.commit_sha).padEnd(7)),
+            fmtTime(d.created_at).padEnd(16),
+            fmtSource(d),
+            d.commit_message
+                ? chalk.dim(((d.commit_message ?? "").split("\n")[0] ?? "").slice(0, 60))
+                : "",
+        ].join("  ");
+        console.log(line);
+    }
+    if (deploys.length > rows.length) {
+        console.log(chalk.dim(`  …${deploys.length - rows.length} more (use --limit to show)`));
+    }
+}
+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();
+    }
+}
+export async function rollbackCmd(opts) {
+    const cliCfg = await loadConfig();
+    if (!cliCfg.token)
+        throw new Error("not logged in. run `layero login` first.");
+    const api = new ApiClient(cliCfg);
+    const cwd = process.cwd();
+    const projectId = await resolveProjectId(api, cwd, opts.project);
+    // Show what we're rolling back from/to so the user can sanity-check
+    // before confirming. The dashboard does this visually; the CLI shows
+    // the equivalent: current deploy + the candidate target.
+    const deploys = await api.listProjectDeploys(projectId, opts.branch);
+    if (deploys.length === 0) {
+        throw new Error("no deploys for this project/branch");
+    }
+    const current = deploys.find((d) => d.status === "ready");
+    let target;
+    if (opts.deploy) {
+        target = deploys.find((d) => d.id === opts.deploy || d.commit_sha.startsWith(opts.deploy));
+        if (!target)
+            throw new Error(`no deploy matching "${opts.deploy}"`);
+    }
+    else {
+        // Find the latest ready deploy that isn't the current active one.
+        const ready = deploys.filter((d) => d.status === "ready");
+        target = ready.find((d) => d.id !== current?.id);
+        if (!target)
+            throw new Error("no eligible deploy to roll back to");
+    }
+    console.log(chalk.cyan("rollback plan:"));
+    if (current) {
+        console.log(`  from: ${shortSha(current.commit_sha)}  ${fmtTime(current.created_at)}  ${chalk.dim(current.commit_message?.split("\n")[0] ?? "")}`);
+    }
+    console.log(`  to:   ${shortSha(target.commit_sha)}  ${fmtTime(target.created_at)}  ${chalk.dim(target.commit_message?.split("\n")[0] ?? "")}`);
+    if (!opts.yes) {
+        const ok = await confirm("proceed with rollback?");
+        if (!ok) {
+            console.log(chalk.yellow("aborted."));
+            return;
+        }
+    }
+    try {
+        const out = await api.rollbackProject(projectId, {
+            branch: opts.branch,
+            deploy_id: target.id,
+        });
+        console.log(chalk.green(`rolled back to ${shortSha(out.commit_sha)}.`));
+        console.log(chalk.dim("  CDN cache purged; new requests serve the rolled-back artifact."));
+    }
+    catch (err) {
+        if (err instanceof ApiError) {
+            throw new Error(`rollback failed (${err.status}): ${err.body.slice(0, 200)}`);
+        }
+        throw err;
+    }
+}

package/dist/commands/link.js

@@ -29,7 +29,7 @@ export async function linkCmd(idOrSlug) {
     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,
     }, proj.framework_hint ?? null);
     console.log(chalk.green(`linked ${proj.slug} (${proj.id}) → ./.layero/project.json`));

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") {
@@ -25,15 +33,16 @@ export async function saveProjectConfig(cwd, cfg) {
  *
  * `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.
+ * 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. Returns the merged config the caller should treat as the new
- * source of truth (matters for first-deploy where there's no existing
- * file).
+ * 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);
@@ -47,11 +56,13 @@ export async function persistProjectLinking(cwd, linking, fallbackHint) {
             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,
-        owner_slug: linking.owner_slug,
+        organization_slug: linking.organization_slug,
         apex_hostname: linking.apex_hostname,
     };
     if (linking.api_url !== undefined)

package/package.json

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