layero 0.8.13 → 0.8.14

package/dist/commands/domains.js

@@ -0,0 +1,220 @@
+import chalk from "chalk";
+import { ApiClient, ApiError } from "../api.js";
+import { loadConfig } from "../config.js";
+import { loadProjectConfig } from "../project-config.js";
+import { LayeroError, detectMode, emit } from "../agent.js";
+async function resolveProjectId(api, opts, cwd) {
+    const linked = await loadProjectConfig(cwd);
+    const ref = opts.project ?? linked?.project_id;
+    if (!ref) {
+        throw new LayeroError("project_unknown", "не понятно, к какому проекту привязывать домен", "запусти из каталога проекта или передай --project <id|slug>");
+    }
+    try {
+        const p = await api.getProject(ref);
+        return { id: p.id, slug: p.slug };
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 404) {
+            throw new LayeroError("project_not_found", `нет проекта с id/slug "${ref}"`, "посмотри список: layero projects list");
+        }
+        throw err;
+    }
+}
+function stateOf(d) {
+    if (d.verified && d.ssl_status === "active")
+        return chalk.green("работает");
+    if (d.ssl_status === "dns_pending")
+        return chalk.yellow("ждёт DNS");
+    if (d.ssl_status === "issuing")
+        return chalk.yellow("выпускается сертификат");
+    if (d.ssl_status === "failed")
+        return chalk.red("ошибка");
+    return d.ssl_status;
+}
+export async function domainsListCmd(opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await resolveProjectId(api, opts, process.cwd());
+    const rows = await api.listDomains(project.id);
+    if (mode.json) {
+        emit({ event: "domains", project: project.slug, domains: rows });
+        return;
+    }
+    if (!rows.length) {
+        console.log(chalk.dim(`у проекта "${project.slug}" нет своих доменов`));
+        console.log(chalk.dim("добавить: layero domains add example.com"));
+        return;
+    }
+    for (const d of rows) {
+        const primary = d.is_primary ? chalk.cyan(" [основной]") : "";
+        console.log(`${d.domain}${primary}  ${stateOf(d)}`);
+        if (d.last_verification_error) {
+            console.log(chalk.dim(`    ${d.last_verification_error}`));
+        }
+    }
+}
+export async function domainsAddCmd(domain, opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await resolveProjectId(api, opts, process.cwd());
+    let created;
+    try {
+        created = await api.addDomain(project.id, domain);
+    }
+    catch (err) {
+        // Отказы здесь — почти всегда про сам домен, и сырое «API POST … → 400»
+        // не говорит пользователю ничего. Разворачиваем в объяснение.
+        if (err instanceof ApiError && (err.status === 400 || err.status === 409 || err.status === 422)) {
+            let detail = err.body;
+            try {
+                detail = JSON.parse(err.body)?.detail ?? err.body;
+            }
+            catch {
+                /* тело не JSON — покажем как есть */
+            }
+            throw new LayeroError("domain_rejected", `домен не принят: ${String(detail).slice(0, 300)}`, err.status === 409
+                ? "домен уже привязан — к этому или другому проекту"
+                : "проверь написание; платформенные адреса (*.layero.ru, *.layero.app) привязать нельзя — они и так твои");
+        }
+        throw err;
+    }
+    const instr = await api.getDomainInstructions(project.id, created.id);
+    if (mode.json) {
+        emit({
+            event: "domain_added",
+            domain: created.domain,
+            domain_id: created.id,
+            ssl_status: created.ssl_status,
+            records: instr.records,
+            // Ждать готовности здесь бессмысленно: DNS распространяется минутами,
+            // а платформа сама перепроверяет фоном.
+            next_action: "ask_user_to_add_dns_then_verify",
+        });
+        return;
+    }
+    console.log(chalk.green(`домен ${created.domain} добавлен к проекту "${project.slug}"`));
+    console.log(`\n${chalk.bold("впиши эти записи у своего регистратора:")}\n`);
+    for (const r of instr.records) {
+        const opt = r.optional ? chalk.dim(" (необязательно)") : "";
+        console.log(`  ${chalk.bold(r.type)}  ${r.name}${opt}`);
+        for (const v of r.values)
+            console.log(`       → ${v}`);
+    }
+    console.log(chalk.dim("\nDNS расходится от нескольких минут до часа. Проверить: layero domains verify " +
+        created.domain +
+        "\nМожно и не проверять вручную — платформа перепроверяет сама."));
+}
+export async function domainsVerifyCmd(domain, opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await resolveProjectId(api, opts, process.cwd());
+    const rows = await api.listDomains(project.id);
+    const found = rows.find((d) => d.domain === domain.toLowerCase().replace(/^https?:\/\//, ""));
+    if (!found) {
+        throw new LayeroError("domain_not_found", `домен "${domain}" не привязан к проекту "${project.slug}"`, "список: layero domains list");
+    }
+    // Неразошедшийся DNS — ОЖИДАЕМОЕ промежуточное состояние, а не сбой:
+    // между привязкой и работающим доменом стоит человек, правящий записи у
+    // регистратора. API отвечает на это 400 (для него «подтвердить не
+    // удалось» — отказ), но показывать пользователю ошибку там, где всё идёт
+    // по плану, — значит пугать его на ровном месте. Разворачиваем в отчёт
+    // о состоянии.
+    let after;
+    try {
+        after = await api.verifyDomain(project.id, found.id);
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 400) {
+            const fresh = (await api.listDomains(project.id)).find((d) => d.id === found.id);
+            after = fresh ?? found;
+        }
+        else {
+            throw err;
+        }
+    }
+    const instr = await api.getDomainInstructions(project.id, found.id);
+    if (mode.json) {
+        emit({
+            event: "domain_verified",
+            domain: after.domain,
+            verified: after.verified,
+            ssl_status: after.ssl_status,
+            checks: instr.checks,
+            next_check_at: after.next_check_at ?? undefined,
+            error: after.last_verification_error ?? undefined,
+        });
+        return;
+    }
+    if (after.verified && after.ssl_status === "active") {
+        console.log(chalk.green(`${after.domain} — работает`));
+        return;
+    }
+    console.log(`${after.domain} — ${stateOf(after)}`);
+    const c = instr.checks;
+    const mark = (v) => v === true ? chalk.green("✓") : v === false ? chalk.red("✗") : chalk.dim("—");
+    console.log(`  A ${mark(c.a_ok)}   CNAME ${mark(c.cname_ok)}   TXT ${mark(c.txt_ok)}   владение ${mark(c.ownership_ok)}`);
+    if (after.last_verification_error) {
+        console.log(chalk.dim(`  ${after.last_verification_error}`));
+    }
+    if (after.next_check_at) {
+        console.log(chalk.dim(`  платформа перепроверит сама: ${after.next_check_at}`));
+    }
+}
+export async function domainsPrimaryCmd(domain, opts) {
+    const api = new ApiClient(await loadConfig());
+    const project = await resolveProjectId(api, opts, process.cwd());
+    const rows = await api.listDomains(project.id);
+    const found = rows.find((d) => d.domain === domain.toLowerCase());
+    if (!found) {
+        throw new LayeroError("domain_not_found", `домен "${domain}" не привязан`, "layero domains list");
+    }
+    const out = await api.makeDomainPrimary(project.id, found.id);
+    if (detectMode().json) {
+        emit({ event: "domain_primary", domain: out.domain });
+        return;
+    }
+    console.log(chalk.green(`${out.domain} — теперь основной домен проекта`));
+    console.log(chalk.dim("платформенный адрес будет 301-редиректить на него"));
+}
+export async function domainsRemoveCmd(domain, opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await resolveProjectId(api, opts, process.cwd());
+    const rows = await api.listDomains(project.id);
+    const found = rows.find((d) => d.domain === domain.toLowerCase());
+    if (!found) {
+        throw new LayeroError("domain_not_found", `домен "${domain}" не привязан`, "layero domains list");
+    }
+    // Снятие домена рвёт живой трафик и требует scope `admin` на стороне API.
+    // Спрашиваем подтверждение — но только когда есть кому отвечать.
+    if (!opts.yes && mode.interactive) {
+        const readline = await import("node:readline/promises");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const a = (await rl.question(`снять ${found.domain} с проекта "${project.slug}"? [y/N]: `))
+                .trim()
+                .toLowerCase();
+            if (a !== "y" && a !== "yes") {
+                console.log(chalk.yellow("отменено."));
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    try {
+        await api.removeDomain(project.id, found.id);
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 403) {
+            throw new LayeroError("forbidden", "у токена нет прав на удаление домена", "удаление необратимо и требует токена со scope `admin` — выпусти такой в настройках");
+        }
+        throw err;
+    }
+    if (mode.json) {
+        emit({ event: "domain_removed", domain: found.domain });
+        return;
+    }
+    console.log(chalk.green(`${found.domain} снят с проекта`));
+}

package/dist/commands/env.js

@@ -0,0 +1,113 @@
+import chalk from "chalk";
+import { ApiClient } from "../api.js";
+import { loadConfig } from "../config.js";
+import { loadProjectConfig } from "../project-config.js";
+import { LayeroError, detectMode, emit } from "../agent.js";
+async function projectRef(api, opts) {
+    const linked = await loadProjectConfig(process.cwd());
+    const ref = opts.project ?? linked?.project_id;
+    if (!ref) {
+        throw new LayeroError("project_unknown", "не понятно, у какого проекта смотреть переменные", "запусти из каталога проекта или передай --project <id|slug>");
+    }
+    const p = await api.getProject(ref);
+    return { id: p.id, slug: p.slug };
+}
+export async function envListCmd(opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await projectRef(api, opts);
+    const rows = await api.listEnvVars(project.id);
+    if (mode.json) {
+        // Ни значения, ни префикса: только имя и длина. Длину отдаём, потому
+        // что она отвечает на реальный вопрос «а он вообще заполнен» и при
+        // этом ничего не выдаёт.
+        emit({
+            event: "env_vars",
+            project: project.slug,
+            vars: rows.map((r) => ({ key: r.key, length: r.length })),
+        });
+        return;
+    }
+    if (!rows.length) {
+        console.log(chalk.dim(`у проекта "${project.slug}" нет переменных окружения`));
+        console.log(chalk.dim("добавить: layero env set KEY=value"));
+        return;
+    }
+    for (const r of rows) {
+        console.log(`${r.key}${chalk.dim(`  (${r.length} симв.)`)}`);
+    }
+    console.log(chalk.dim("\nзначения не показываются — платформа их не отдаёт"));
+}
+function parsePair(raw) {
+    const i = raw.indexOf("=");
+    if (i <= 0) {
+        throw new LayeroError("bad_format", `ожидается KEY=value, получено "${raw.slice(0, 40)}"`, "например: layero env set DATABASE_URL=postgres://…");
+    }
+    return { key: raw.slice(0, i).trim(), value: raw.slice(i + 1) };
+}
+export async function envSetCmd(pairs, opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await projectRef(api, opts);
+    const incoming = pairs.map(parsePair);
+    if (!incoming.length) {
+        throw new LayeroError("nothing_to_set", "не передано ни одной переменной", "layero env set KEY=value");
+    }
+    // Остальные ключи переносим как есть — сентинел `null` говорит платформе
+    // «оставь значение». Читать чужие секреты для добавления одной своей не
+    // нужно, и это принципиально: иначе команда требовала бы прав, которых
+    // у неё быть не должно.
+    const existing = await api.listEnvVars(project.id);
+    const payload = {};
+    for (const r of existing)
+        payload[r.key] = null;
+    for (const { key, value } of incoming)
+        payload[key] = value;
+    const after = await api.replaceEnvVars(project.id, payload);
+    const names = incoming.map((x) => x.key);
+    if (mode.json) {
+        emit({ event: "env_set", project: project.slug, keys: names, total: after.length });
+        return;
+    }
+    console.log(chalk.green(`сохранено: ${names.join(", ")}`));
+    console.log(chalk.yellow("переменные подхватятся при следующей сборке — задеплой проект, чтобы применить"));
+}
+export async function envUnsetCmd(keys, opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const project = await projectRef(api, opts);
+    const existing = await api.listEnvVars(project.id);
+    const known = new Set(existing.map((r) => r.key));
+    const missing = keys.filter((k) => !known.has(k));
+    if (missing.length) {
+        throw new LayeroError("env_not_found", `нет таких переменных: ${missing.join(", ")}`, "посмотри список: layero env list");
+    }
+    if (!opts.yes && mode.interactive) {
+        const readline = await import("node:readline/promises");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const a = (await rl.question(`удалить ${keys.join(", ")} из "${project.slug}"? [y/N]: `))
+                .trim()
+                .toLowerCase();
+            if (a !== "y" && a !== "yes") {
+                console.log(chalk.yellow("отменено."));
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const drop = new Set(keys);
+    const payload = {};
+    for (const r of existing)
+        if (!drop.has(r.key))
+            payload[r.key] = null;
+    await api.replaceEnvVars(project.id, payload);
+    if (mode.json) {
+        emit({ event: "env_unset", project: project.slug, keys });
+        return;
+    }
+    console.log(chalk.green(`удалено: ${keys.join(", ")}`));
+    console.log(chalk.yellow("изменение применится при следующей сборке"));
+}

package/dist/commands/perf.js

@@ -0,0 +1,99 @@
+import chalk from "chalk";
+import { ApiClient, ApiError } from "../api.js";
+import { loadConfig } from "../config.js";
+import { loadProjectConfig } from "../project-config.js";
+import { LayeroError, detectMode, emit } from "../agent.js";
+async function projectId(api, opts) {
+    const linked = await loadProjectConfig(process.cwd());
+    const ref = opts.project ?? linked?.project_id;
+    if (!ref) {
+        throw new LayeroError("project_unknown", "не понятно, какой проект мерить", "запусти из каталога проекта или передай --project <id|slug>");
+    }
+    const p = await api.getProject(ref);
+    return p.id;
+}
+function render(d) {
+    const colour = d.verdict === "regressed" ? chalk.red : d.verdict === "improved" ? chalk.green : chalk.dim;
+    console.log(colour(d.message));
+    if (d.score !== null && d.score !== undefined) {
+        const t = d.timings ?? {};
+        const bits = [
+            `балл ${d.score}`,
+            t.lcp_ms ? `LCP ${t.lcp_ms} мс` : null,
+            t.ttfb_ms ? `TTFB ${t.ttfb_ms} мс` : null,
+        ].filter(Boolean);
+        console.log(chalk.dim("  " + bits.join("  ·  ")));
+        console.log(chalk.dim("  тайминги справочно: на одном и том же коде они гуляют на десятки процентов"));
+    }
+}
+export async function perfCheckCmd(opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const id = await projectId(api, opts);
+    let started;
+    try {
+        started = await api.startPerfCheck(id);
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 429) {
+            // Замер уже идёт — это не ошибка, а ответ на вопрос «когда будет».
+            const current = await api.getPerfCheck(id).catch(() => null);
+            if (current) {
+                if (mode.json) {
+                    emit({ event: "perf_check", ...current });
+                    return;
+                }
+                console.log(chalk.dim("замер уже идёт — вот его состояние:"));
+                render(current);
+                return;
+            }
+        }
+        if (err instanceof ApiError && err.status === 409) {
+            throw new LayeroError("no_deploy", "у проекта нет успешного деплоя — мерить нечего", "сначала `layero deploy`");
+        }
+        throw err;
+    }
+    if (mode.json && !opts.wait) {
+        emit({ event: "perf_check_started", ...started });
+        return;
+    }
+    if (!opts.wait) {
+        console.log(chalk.dim("замер запущен; результат — `layero perf show` через минуту-две"));
+        return;
+    }
+    // --wait: опрашиваем, но с потолком. Прогон занимает десятки секунд;
+    // висеть дольше нескольких минут смысла нет — лучше вернуть управление.
+    const deadline = Date.now() + 240_000;
+    let last = started;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 8000));
+        last = await api.getPerfCheck(id);
+        if (last.verdict !== "pending")
+            break;
+    }
+    if (mode.json) {
+        emit({ event: "perf_check", ...last });
+        return;
+    }
+    render(last);
+}
+export async function perfShowCmd(opts) {
+    const mode = detectMode();
+    const api = new ApiClient(await loadConfig());
+    const id = await projectId(api, opts);
+    let out;
+    try {
+        out = await api.getPerfCheck(id);
+    }
+    catch (err) {
+        if (err instanceof ApiError && err.status === 404) {
+            throw new LayeroError("no_runs", "замеров по этому проекту ещё не было", "запусти: layero perf check");
+        }
+        throw err;
+    }
+    if (mode.json) {
+        emit({ event: "perf_check", ...out });
+        return;
+    }
+    render(out);
+}

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, username: me.username, email: me.email };
+        cfg.user = { id: me.id, username: me.username ?? null, email: me.email };
     }
     catch (err) {
         console.error(chalk.red(`token rejected by API: ${err.message}`));

package/dist/generated/api-types.js

@@ -0,0 +1,5 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+export {};

package/package.json

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