@kryd/cli 0.4.0 → 0.5.0

package/README.md

@@ -17,8 +17,8 @@ Requires Node.js ≥ 22 and git (the CLI shells out to git for `kryd init` and `
 ```sh
 kryd login                    # sign in via the browser
 kryd init                     # link this folder to a Kryd project (+ a `kryd` git remote)
-kryd push                     # push the current branch → build → deploy → live, streamed
-kryd logs                     # follow the linked project's latest deploy (kryd push already does)
+kryd push                     # push the current branch → build → deploy → live, with live progress
+kryd logs                     # the full build log of the latest deploy (kryd push shows progress, not log lines)
 kryd logs <project> --runtime # tail the live app's stdout/stderr
 ```
 
@@ -30,9 +30,9 @@ Once you've run `kryd init` in a directory, the commands below work **arg-less**
 |---|---|
 | `kryd login` / `logout` / `whoami` | Authenticate the CLI (browser flow); the token is stored in `~/.kryd`. |
 | `kryd init` | Link the current repo to a Kryd project + register the deploy webhook + add a `kryd` git remote. |
-| `kryd push [branch]` | Push to the `kryd` remote and follow the deploy it triggers (defaults to the current branch). |
+| `kryd push [branch]` | Push to the `kryd` remote and follow the deploy it triggers (defaults to the current branch). Shows which step the deploy is on, how long it has taken and a progress bar; `--logs` streams the full build log instead. |
 | `kryd deploy [project]` | Re-deploy the production-branch HEAD already on the forge — no new commit. |
-| `kryd logs [target]` | Follow a deploy's build/deploy log (`--runtime` tails the live container instead). |
+| `kryd logs [target]` | Follow a deploy's build/deploy log **in full** — this is where the build output lives (`--runtime` tails the live container instead). |
 | `kryd rollback [project] [deployment]` | Roll back to a previous successful deploy — no rebuild. |
 | `kryd db create \| detach [project]` | Attach / tear down managed Postgres (shared or bring-your-own). |
 | `kryd storage create \| detach [project]` | Attach / tear down S3-compatible object storage. |

package/dist/index.js

@@ -14666,6 +14666,23 @@ function date4(params) {
 config(en_default());
 
 // ../../packages/shared-types/dist/usage.js
+var USAGE_OUTCOME = {
+  ok: "ok",
+  /** Refused by the request-rate limiter. */
+  throttledRate: "throttled_rate",
+  /** Refused by the daily token cap. */
+  throttledCap: "throttled_cap"
+};
+var USAGE_OUTCOMES = [
+  USAGE_OUTCOME.ok,
+  USAGE_OUTCOME.throttledRate,
+  USAGE_OUTCOME.throttledCap
+];
+var STORAGE_FRESHNESS_MS = 3 * 60 * 60 * 1e3;
+var USAGE_THROTTLED_OUTCOMES = [
+  USAGE_OUTCOME.throttledRate,
+  USAGE_OUTCOME.throttledCap
+];
 var usageEventSchema = external_exports.object({
   // Gateway-assigned id (stable across POST retries) → the ingest inserts `onConflictDoNothing` on
   // it, so a re-sent batch after a lost ACK never double-counts (KRYD-35 review).
@@ -14688,7 +14705,7 @@ var usageEventSchema = external_exports.object({
   // fail the whole batch — so one malformed outcome can't discard up to 999 valid usage events in the
   // same POST (the batch-loss failure mode the FK-free `account_id` decision already guards, KRYD-35).
   // Because only in-set values are ever persisted, the DB column needs no CHECK constraint.
-  outcome: external_exports.enum(["ok", "throttled_rate", "throttled_cap"]).default("ok").catch("ok")
+  outcome: external_exports.enum(USAGE_OUTCOMES).default(USAGE_OUTCOME.ok).catch(USAGE_OUTCOME.ok)
 });
 var usageIngestBatchSchema = external_exports.object({
   events: external_exports.array(usageEventSchema).min(1).max(1e3)
@@ -14838,6 +14855,24 @@ var BUILD_ENV_PUBLIC_WARNING = "\u26A0 Build-time values are compiled into your
 var BUILD_ENV_REBUILD_NOTE = "This takes effect at your next BUILD, not your next deploy \u2014 the value is compiled into the image, so redeploying the existing image keeps the old value. Push a commit (`kryd push`) to rebuild.";
 
 // ../../packages/shared-types/dist/index.js
+var DEPLOY_STATES = [
+  "queued",
+  "building",
+  "deploying",
+  // KRYD-360: the container exists, and the app is now being asked whether it answers. It is a
+  // step of its own because it asks a different question than `deploying` does — that one is
+  // Kryd's infrastructure creating compute, this one is the customer's app booting — and the
+  // two were sharing a budget that the first one spent entirely. See the health gate section
+  // in `packages/deploy-state-machine`.
+  "verifying",
+  "live",
+  "failed",
+  "superseded",
+  // Compute reclaimed by the Story 3.10 cleanup job — the deploy's tenant container (and, for
+  // a preview, its ephemeral host) no longer exists. Reached from live/failed/superseded via
+  // the state machine's `TEARDOWN` event; fully terminal (a torn-down deploy is gone for good).
+  "torn_down"
+];
 var TERMINAL_DEPLOY_STATES = [
   "live",
   "failed",
@@ -15726,6 +15761,20 @@ async function streamRuntime(apiUrl, token, id, handlers, opts = {}) {
     }
   }
 }
+async function fetchDeployLog(apiUrl, token, deploymentId, opts = {}) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const res = await doFetch(`${apiUrl}/deployments/${deploymentId}/log`, {
+    headers: { authorization: `Bearer ${token}` }
+  });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    throw new ApiError(
+      `Fetching the stored log failed (${res.status})`,
+      await parseEnvelope(res)
+    );
+  }
+  return (await res.json()).log;
+}
 
 // src/framework.ts
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
@@ -15750,6 +15799,29 @@ var VITE_META_FRAMEWORKS = [
   "vike"
 ];
 var SERVER_FRAMEWORKS = ["hono", "express", "fastify", "koa"];
+var NON_NODE_START_TOOLS = [
+  "vite",
+  "next",
+  "astro",
+  "nuxt",
+  "remix",
+  "react-router",
+  "svelte",
+  "solid-start",
+  "qwik",
+  "vike",
+  "parcel",
+  "webpack",
+  "rollup",
+  "serve",
+  "http-server"
+];
+function startScriptLooksLikePlainNode(start) {
+  const s = start.toLowerCase();
+  return !NON_NODE_START_TOOLS.some(
+    (tool) => new RegExp(`(^|[\\s/"'\`=])${tool}([\\s@/"'\`]|$)`).test(s)
+  );
+}
 function readPackageJson(cwd) {
   try {
     return JSON.parse(readFileSync2(join2(cwd, "package.json"), "utf8"));
@@ -15767,6 +15839,8 @@ function frameworkFrom(pkg, cwd) {
   if (VITE_META_FRAMEWORKS.some(has)) return null;
   if (SERVER_FRAMEWORKS.some(has)) return "node";
   if (has("vite")) return "vite-spa";
+  const start = pkg?.scripts?.start?.trim();
+  if (start && startScriptLooksLikePlainNode(start)) return "node";
   return null;
 }
 function nameFrom(pkg, cwd) {
@@ -15777,6 +15851,286 @@ function inspectProject(cwd) {
   return { framework: frameworkFrom(pkg, cwd), name: nameFrom(pkg, cwd) };
 }
 
+// src/progress.ts
+var STEPS = DEPLOY_STATES.filter(
+  (s) => !TERMINAL_DEPLOY_STATES.includes(s)
+);
+var STEP_FLOOR = {
+  queued: 0,
+  building: 0.04,
+  deploying: 0.42,
+  verifying: 0.88,
+  live: 1,
+  failed: 1,
+  superseded: 1,
+  torn_down: 1
+};
+var STEP_TYPICAL_MS = {
+  queued: 3e3,
+  building: 12e4,
+  deploying: 15e4,
+  verifying: 2e4,
+  live: 0,
+  failed: 0,
+  superseded: 0,
+  torn_down: 0
+};
+var MAX_ESTIMATED_FILL = 0.95;
+var TAIL_LINES = 50;
+var ESTIMATE_SAMPLE = 5;
+var FRAME_MS = 80;
+var LABEL_WIDTH = 7;
+var NAME_WIDTH = 12;
+function formatClock(ms) {
+  const total = Math.max(0, Math.round(ms / 1e3));
+  const minutes = Math.floor(total / 60);
+  const seconds = total % 60;
+  return `${minutes}:${String(seconds).padStart(2, "0")}`;
+}
+function estimateTotalMs(deployments) {
+  const durations = deployments.filter((d) => d.status === "live").slice(0, ESTIMATE_SAMPLE).map((d) => Date.parse(d.statusChangedAt) - Date.parse(d.createdAt)).filter((ms) => Number.isFinite(ms) && ms > 0).sort((a, b) => a - b);
+  if (durations.length === 0) return null;
+  return durations[Math.floor(durations.length / 2)] ?? null;
+}
+function resolveRenderMode(input) {
+  if (input.want === "lines") return "lines";
+  if (!input.isTTY) return "lines";
+  if (input.env.NO_COLOR !== void 0) return "lines";
+  if (input.env.CI !== void 0 && input.env.CI !== "") return "lines";
+  return "progress";
+}
+function resolveColourMode(input) {
+  if (!input.isTTY) return "none";
+  if (input.env.NO_COLOR !== void 0) return "none";
+  const colorterm = input.env.COLORTERM ?? "";
+  if (colorterm === "truecolor" || colorterm === "24bit") return "truecolor";
+  return "basic";
+}
+function supportsUnicode(env2) {
+  const locale = env2.LC_ALL ?? env2.LC_CTYPE ?? env2.LANG ?? "";
+  return /utf-?8/i.test(locale);
+}
+function usableColumns(columns) {
+  return columns !== void 0 && columns > 0 ? columns : 80;
+}
+function defaultProgressIO() {
+  const stdout = process.stdout;
+  const isTTY = Boolean(stdout.isTTY);
+  return {
+    out: stdout,
+    isTTY,
+    now: () => Date.now(),
+    columns: usableColumns(stdout.columns),
+    colour: resolveColourMode({ isTTY, env: process.env }),
+    unicode: supportsUnicode(process.env)
+  };
+}
+var TRUECOLOR = {
+  done: "38;2;46;125;87",
+  // --status-live     #2e7d57
+  busy: "38;2;217;145;0",
+  // --status-building #d99100
+  bad: "38;2;192;69;60"
+  // --status-failed   #c0453c
+};
+var BASIC = { done: "32", busy: "33", bad: "31" };
+var CSI = "\x1B[";
+var CLEAR_LINE = `${CSI}2K`;
+var CURSOR_UP = `${CSI}1A`;
+var RESET = `${CSI}0m`;
+var BLOCKS = ["", "\u258F", "\u258E", "\u258D", "\u258C", "\u258B", "\u258A", "\u2589"];
+var ELLIPSIS_FRAMES = ["   ", ".  ", ".. ", "..."];
+var ELLIPSIS_WIDTH = 3;
+var ELLIPSIS_MS = 420;
+function trimEllipsis(line) {
+  return line.replace(/(\.{3}|…)\s*$/u, "");
+}
+function createDeployProgress(io) {
+  const unicode = io.unicode ?? true;
+  const columns = usableColumns(io.columns);
+  const startedAt = io.now();
+  const tail = [];
+  let current = null;
+  let currentStartedAt = startedAt;
+  let activity = "";
+  let estimateMs = null;
+  let deploymentId = "";
+  let highWaterFill = 0;
+  let drawnRows = 0;
+  let timer = null;
+  let finished = false;
+  const paint = (role, text) => {
+    if (io.colour === "none") return text;
+    if (role === "muted") return `${CSI}2m${text}${RESET}`;
+    return `${CSI}${io.colour === "truecolor" ? TRUECOLOR[role] : BASIC[role]}m${text}${RESET}`;
+  };
+  const write = (s) => {
+    io.out.write(s);
+  };
+  const clip = (s, max) => {
+    if (max <= 0) return "";
+    if (s.length <= max) return s;
+    return max <= 1 ? s.slice(0, max) : `${s.slice(0, max - 1)}\u2026`;
+  };
+  const row = (word, role, name, right) => {
+    const left = word.padStart(LABEL_WIDTH);
+    const middle = name.padEnd(NAME_WIDTH);
+    const budget = columns - LABEL_WIDTH - 1;
+    const body = clip(`${middle} ${right}`.trimEnd(), Math.max(0, budget));
+    const pad = Math.max(0, budget - body.length);
+    const spaced = pad > 0 && right.length > 0 ? `${middle}${" ".repeat(pad + 1)}${right}` : body;
+    return `${paint(role, left)} ${clip(spaced, Math.max(0, budget))}`;
+  };
+  const eraseAnimated = () => {
+    if (drawnRows === 0) return;
+    write(`\r${CLEAR_LINE}`);
+    for (let i = 1; i < drawnRows; i++) write(`${CURSOR_UP}\r${CLEAR_LINE}`);
+    drawnRows = 0;
+  };
+  const ellipsis = () => {
+    if (activity.length === 0) return "";
+    const frame = Math.floor((io.now() - startedAt) / ELLIPSIS_MS) % ELLIPSIS_FRAMES.length;
+    return ELLIPSIS_FRAMES[frame] ?? "";
+  };
+  const ceilingAfter = (step) => {
+    const next = STEPS[STEPS.indexOf(step) + 1];
+    return next ? STEP_FLOOR[next] : MAX_ESTIMATED_FILL;
+  };
+  const withinStep = (step, elapsedInStep) => {
+    const typical = STEP_TYPICAL_MS[step];
+    if (typical <= 0) return 0;
+    const progress = 1 - Math.exp(-Math.max(0, elapsedInStep) / typical);
+    return STEP_FLOOR[step] + (ceilingAfter(step) - STEP_FLOOR[step]) * progress;
+  };
+  const fill = () => {
+    const now = io.now();
+    const stepwise = current ? withinStep(current, now - currentStartedAt) : 0;
+    const estimated = estimateMs !== null && estimateMs > 0 ? (now - startedAt) / estimateMs : 0;
+    highWaterFill = Math.max(highWaterFill, stepwise, estimated);
+    return Math.min(highWaterFill, MAX_ESTIMATED_FILL);
+  };
+  const bar = (fraction, width) => {
+    if (width <= 0) return "";
+    if (!unicode) {
+      const filled = Math.max(0, Math.min(width, Math.round(fraction * width)));
+      const head = filled > 0 && filled < width ? ">" : "";
+      return `${"=".repeat(Math.max(0, filled - head.length))}${head}${" ".repeat(width - filled)}`;
+    }
+    const exact = Math.max(0, Math.min(width, fraction * width));
+    const full = Math.floor(exact);
+    const partial2 = BLOCKS[Math.floor((exact - full) * 8)] ?? "";
+    const used = full + (partial2 ? 1 : 0);
+    return `${"\u2588".repeat(full)}${partial2}${"\u2591".repeat(Math.max(0, width - used))}`;
+  };
+  const draw = () => {
+    if (finished || current === null || !io.isTTY) return;
+    eraseAnimated();
+    const elapsed = formatClock(io.now() - startedAt);
+    const counter = estimateMs !== null ? `${elapsed} / ~${formatClock(estimateMs)}` : elapsed;
+    const prefixWidth = LABEL_WIDTH + 1 + NAME_WIDTH + 1;
+    const barWidth = columns - prefixWidth - counter.length - 3;
+    const barPart = current !== "queued" && barWidth >= 8 ? `[${bar(fill(), barWidth)}] ` : "";
+    write(`\r${CLEAR_LINE}${row("Loading", "busy", current, `${barPart}${counter}`)}
+`);
+    const indent = " ".repeat(LABEL_WIDTH + 1);
+    const room = Math.max(0, columns - indent.length - 2 - ELLIPSIS_WIDTH);
+    write(
+      `\r${CLEAR_LINE}${paint("muted", `${indent}\u2514 ${clip(trimEllipsis(activity), room)}${ellipsis()}`)}`
+    );
+    drawnRows = 2;
+  };
+  const startTimer = () => {
+    if (timer !== null || !io.isTTY) return;
+    timer = setInterval(draw, FRAME_MS);
+    timer.unref?.();
+  };
+  const stopTimer = () => {
+    if (timer === null) return;
+    clearInterval(timer);
+    timer = null;
+  };
+  const closeCurrent = (role) => {
+    if (current === null) return;
+    eraseAnimated();
+    const step = { status: current, ms: io.now() - currentStartedAt, role };
+    const word = role === "bad" ? "Failed" : "Success";
+    write(`${row(word, role, step.status, formatClock(step.ms))}
+`);
+    current = null;
+  };
+  return {
+    onLog(line) {
+      tail.push(line);
+      if (tail.length > TAIL_LINES) tail.shift();
+      activity = line;
+      draw();
+    },
+    onStatus(event) {
+      if (TERMINAL_DEPLOY_STATES.includes(event.status)) return;
+      if (event.status === current) return;
+      const incoming = STEPS.indexOf(event.status);
+      const running = current === null ? -1 : STEPS.indexOf(current);
+      if (incoming !== -1 && incoming < running) return;
+      closeCurrent("done");
+      current = event.status;
+      currentStartedAt = io.now();
+      activity = "";
+      startTimer();
+      draw();
+    },
+    finish(terminal, outcome) {
+      stopTimer();
+      const failed = terminal === "failed";
+      closeCurrent(failed ? "bad" : "done");
+      finished = true;
+      const total = formatClock(io.now() - startedAt);
+      if (failed) {
+        write("\n");
+        if (tail.length > 0) {
+          write(`${paint("muted", `--- last ${tail.length} log line${tail.length === 1 ? "" : "s"} ---`)}
+`);
+          for (const line of tail) write(`${line}
+`);
+          write(`${paint("muted", "---")}
+
+`);
+        } else {
+          write(`${paint("muted", "No log lines arrived before this failed.")}
+
+`);
+        }
+        write(`${paint("bad", "Failed".padStart(LABEL_WIDTH))} ${outcome.failure?.reason ?? "the deploy failed"}
+`);
+        if (deploymentId) {
+          write(`${paint("muted", `${" ".repeat(LABEL_WIDTH + 1)}Full log: kryd logs ${deploymentId}`)}
+`);
+        }
+        return;
+      }
+      if (terminal === "live") {
+        write(`${row("Live", "done", outcome.url ?? "(no url reported)", total)}
+`);
+        return;
+      }
+      const text = terminal === "superseded" ? "superseded by a newer push" : "torn down \u2014 this deploy's compute was reclaimed by cleanup";
+      write(`${row("Done", "muted", text, "")}
+`);
+    },
+    setEstimate(ms) {
+      estimateMs = ms !== null && ms > 0 ? ms : null;
+    },
+    setDeploymentId(id) {
+      deploymentId = id;
+    },
+    tick() {
+      draw();
+    },
+    isAnimating() {
+      return timer !== null;
+    }
+  };
+}
+
 // src/input.ts
 import { createInterface } from "node:readline";
 import { Writable } from "node:stream";
@@ -15885,16 +16239,34 @@ function configureGitRemote(cwd, remote, url2) {
   }
   try {
     const remotes = run(["remote"]).split(/\s+/).filter(Boolean);
-    if (remotes.includes(remote)) {
-      run(["remote", "set-url", remote, url2]);
-      return { status: "updated", remote };
-    }
-    run(["remote", "add", remote, url2]);
-    return { status: "added", remote };
+    const status = remotes.includes(remote) ? "updated" : "added";
+    if (status === "updated") run(["remote", "set-url", remote, url2]);
+    else run(["remote", "add", remote, url2]);
+    return { status, remote, tracking: setUpstreamIfUnset(run, remote) };
   } catch {
     return { status: "unavailable" };
   }
 }
+function setUpstreamIfUnset(run, remote) {
+  let branch;
+  try {
+    branch = run(["symbolic-ref", "--short", "HEAD"]);
+  } catch {
+    return "detached";
+  }
+  if (!branch) return "detached";
+  try {
+    if (run(["config", "--get", `branch.${branch}.remote`])) return "kept-existing";
+  } catch {
+  }
+  try {
+    run(["config", `branch.${branch}.remote`, remote]);
+    run(["config", `branch.${branch}.merge`, `refs/heads/${branch}`]);
+    return "set";
+  } catch {
+    return "unavailable";
+  }
+}
 function probe(cwd, args) {
   try {
     const value = execFileSync("git", args, {
@@ -16063,7 +16435,9 @@ async function runInit(opts) {
       case "added":
       case "updated":
         nextStep = `${remote.status === "added" ? "Added" : "Updated"} git remote "${remote.remote}" (with your push credential).
-Next: kryd push   # push to deploy (same as \`git push ${remote.remote} ${branch}\`)
+` + (remote.tracking === "set" ? `Tracking set: \`git push\` and \`kryd push\` both deploy this branch.
+` : remote.tracking === "kept-existing" ? `This branch already tracks another remote, so it was left alone \u2014 deploy with \`kryd push\`.
+` : "") + `Next: kryd push   # push to deploy (same as \`git push ${remote.remote} ${branch}\`)
 `;
         break;
       case "not-a-repo":
@@ -16103,19 +16477,82 @@ function formatStatus(event) {
       return "\u2298 superseded by a newer push";
     case "torn_down":
       return "\u232B torn down \u2014 this deploy's compute was reclaimed by cleanup";
+    // KRYD-360: the container exists and the app is being asked whether it answers. Named, rather
+    // than falling through to the generic `→ verifying`, because this is the step where a customer's
+    // own app is on the clock and the next line they see may be about their crash.
+    case "verifying":
+      return "\u2192 verifying the app answers\u2026";
     default:
       return `\u2192 ${event.status}`;
   }
 }
-async function followDeploy(apiUrl, token, deploymentId) {
-  const terminal = await streamDeploy(apiUrl, token, deploymentId, {
-    onLog: (line) => process.stdout.write(`${line}
-`),
-    onStatus: (event) => process.stdout.write(`${formatStatus(event)}
-`)
+async function followDeploy(apiUrl, token, deploymentId, opts = {}) {
+  let streamedLines = 0;
+  const mode = resolveRenderMode({
+    want: opts.render ?? "lines",
+    isTTY: Boolean(process.stdout.isTTY),
+    env: process.env
   });
+  let terminal;
+  if (mode === "lines") {
+    terminal = await streamDeploy(apiUrl, token, deploymentId, {
+      onLog: (line) => {
+        streamedLines++;
+        process.stdout.write(`${line}
+`);
+      },
+      onStatus: (event) => process.stdout.write(`${formatStatus(event)}
+`)
+    });
+  } else {
+    const progress = createDeployProgress(defaultProgressIO());
+    progress.setDeploymentId(deploymentId);
+    progress.setEstimate(estimateTotalMs(opts.estimateFrom ?? []));
+    let last;
+    try {
+      terminal = await streamDeploy(apiUrl, token, deploymentId, {
+        onLog: (line) => {
+          streamedLines++;
+          progress.onLog(line);
+        },
+        onStatus: (event) => {
+          last = event;
+          progress.onStatus(event);
+        }
+      });
+    } catch (err) {
+      progress.finish("failed", { failure: { code: "streamFailed", reason: "the log stream ended" } });
+      throw err;
+    }
+    progress.finish(terminal, {
+      url: last?.url,
+      failure: last?.failure
+    });
+  }
+  if (streamedLines === 0) {
+    await replayStoredLog(apiUrl, token, deploymentId);
+  }
   if (terminal !== "live" && terminal !== "torn_down") process.exitCode = 1;
 }
+async function replayStoredLog(apiUrl, token, deploymentId) {
+  try {
+    const log = await fetchDeployLog(apiUrl, token, deploymentId);
+    if (log === null) {
+      process.stderr.write(
+        `No stored log for ${deploymentId} \u2014 it finished before its log was persisted.
+`
+      );
+      return;
+    }
+    process.stdout.write(log.endsWith("\n") ? log : `${log}
+`);
+  } catch (err) {
+    process.stderr.write(
+      `Could not read the stored log (${err instanceof Error ? err.message : String(err)}). It is kept for later viewing \u2014 try \`kryd logs ${deploymentId}\` again.
+`
+    );
+  }
+}
 async function runLogs(opts) {
   const apiUrl = resolveApiUrl(opts.apiUrl);
   const token = loadConfig().token;
@@ -16212,11 +16649,15 @@ async function runDeploy(opts) {
     const deploymentId = await triggerDeploy(apiUrl, token, project2);
     process.stdout.write(`Triggered deploy ${deploymentId}
 `);
-    await followDeploy(apiUrl, token, deploymentId);
+    await followDeploy(apiUrl, token, deploymentId, { render: renderFor(opts.logs) });
   } catch (err) {
     reportError(err);
   }
 }
+function renderFor(logs) {
+  return logs ? "lines" : "progress";
+}
+var LOGS_FLAG_HELP = "stream the full build log line by line instead of the progress display";
 async function runPush(opts) {
   const apiUrl = resolveApiUrl(opts.apiUrl);
   const token = loadConfig().token;
@@ -16301,8 +16742,10 @@ async function runPush(opts) {
     }
     const fetchDeployments = () => listDeployments(apiUrl, token, projectId ?? void 0);
     let known = null;
+    let recent = [];
     try {
-      known = findDeploymentsForCommit(await fetchDeployments(), commitSha, branch);
+      recent = await fetchDeployments();
+      known = findDeploymentsForCommit(recent, commitSha, branch);
     } catch {
       known = null;
     }
@@ -16341,7 +16784,10 @@ async function runPush(opts) {
       }
       return;
     }
-    await followDeploy(apiUrl, token, deployment.id);
+    await followDeploy(apiUrl, token, deployment.id, {
+      render: renderFor(opts.logs),
+      estimateFrom: recent
+    });
   } catch (err) {
     reportError(err);
   }
@@ -16371,7 +16817,7 @@ async function runRollback(opts) {
 \u26A0 ${note}
 `
     );
-    await followDeploy(apiUrl, token, deploymentId);
+    await followDeploy(apiUrl, token, deploymentId, { render: renderFor(opts.logs) });
   } catch (err) {
     reportError(err);
   }
@@ -16400,7 +16846,7 @@ async function runRedeploy(opts) {
 ${note}
 `
     );
-    await followDeploy(apiUrl, token, deploymentId);
+    await followDeploy(apiUrl, token, deploymentId, { render: renderFor(opts.logs) });
   } catch (err) {
     reportError(err);
   }
@@ -17212,7 +17658,7 @@ Run \`kryd env list\` to see what is set. (If you meant the runtime variable of
     reportError(err);
   }
 }
-var CLI_VERSION = true ? "0.4.0" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.5.0" : "0.0.0-dev";
 var program = new Command();
 program.name("kryd").description("Kryd CLI").version(CLI_VERSION);
 program.command("login").description("Sign in via the browser (default) and store a token").option("--email <email>", "account email (with --password; non-interactive escape hatch)").option("--password <password>", "account password (with --email; visible in `ps` \u2014 prefer the browser flow)").option(
@@ -17248,16 +17694,16 @@ program.command("logs [target]").description(
 );
 program.command("push [branch]").description(
   "Push to the kryd remote and follow the deploy it triggers (defaults to the current branch)"
-).option("--api-url <url>", "control-plane API base URL").action(
+).option("--logs", LOGS_FLAG_HELP).option("--api-url <url>", "control-plane API base URL").action(
   (branch, opts, cmd) => runPush({ ...opts, branch, gitArgs: cmd.args.slice(1) })
 );
-program.command("deploy [project]").description("Trigger a deploy of the project's production branch and follow it live").option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runDeploy({ ...opts, project: project2 }));
-program.command("rollback [project] [deployment]").description("Roll back to a previous successful deploy (no rebuild) and follow it live").option("--api-url <url>", "control-plane API base URL").action(
+program.command("deploy [project]").description("Trigger a deploy of the project's production branch and follow it live").option("--logs", LOGS_FLAG_HELP).option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runDeploy({ ...opts, project: project2 }));
+program.command("rollback [project] [deployment]").description("Roll back to a previous successful deploy (no rebuild) and follow it live").option("--logs", LOGS_FLAG_HELP).option("--api-url <url>", "control-plane API base URL").action(
   (project2, deployment, opts) => runRollback({ ...opts, project: project2, deployment })
 );
 program.command("redeploy [project]").description(
   "Redeploy the current live commit (no rebuild) to apply config/env changes, and follow it live"
-).option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runRedeploy({ ...opts, project: project2 }));
+).option("--logs", LOGS_FLAG_HELP).option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runRedeploy({ ...opts, project: project2 }));
 var project = program.command("project").description("Manage your projects");
 project.command("list").description("List your projects \u2014 name, subdomain, status and id").option("--api-url <url>", "control-plane API base URL").action((opts) => runProjectList(opts));
 project.command("rm [project]").description(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kryd/cli",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Kryd CLI — push a React / Vite / Next.js app to the European cloud for your AI: git push → live with SSL, one-click managed Postgres & object storage, and an EU-hosted AI gateway already wired in. Your code and your model calls stay in the EU.",
   "keywords": [
     "kryd",