@kryd/cli 0.4.1 → 0.5.1

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

@@ -14855,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",
@@ -14876,8 +14894,9 @@ function isTerminalResourceStatus(status) {
 }
 
 // src/index.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync3, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 
 // src/config.ts
 import {
@@ -15046,6 +15065,7 @@ function browserLogin(dashboardUrl, opts = {}) {
       fn();
     };
     const server = createServer((req, res) => {
+      res.setHeader("connection", "close");
       const reqUrl = new URL(req.url ?? "/", "http://127.0.0.1");
       if (reqUrl.pathname !== "/callback") {
         res.writeHead(404);
@@ -15057,20 +15077,26 @@ function browserLogin(dashboardUrl, opts = {}) {
       const gotState = reqUrl.searchParams.get("state");
       if (!token || gotState !== state) {
         res.writeHead(400, { "content-type": "text/html" });
-        res.end(FAIL_HTML);
-        settle(() => {
-          server.close();
-          reject(new Error("Login failed \u2014 the approval didn't match this request. Try `kryd login` again."));
+        res.end(FAIL_HTML, () => {
+          settle(() => {
+            shutdown();
+            reject(new Error("Login failed \u2014 the approval didn't match this request. Try `kryd login` again."));
+          });
         });
         return;
       }
       res.writeHead(200, { "content-type": "text/html" });
-      res.end(SUCCESS_HTML);
-      settle(() => {
-        server.close();
-        resolve2({ token, ...apiUrl ? { apiUrl } : {} });
+      res.end(SUCCESS_HTML, () => {
+        settle(() => {
+          shutdown();
+          resolve2({ token, ...apiUrl ? { apiUrl } : {} });
+        });
       });
     });
+    const shutdown = () => {
+      server.closeAllConnections();
+      server.close();
+    };
     server.on("error", (err) => settle(() => reject(err)));
     server.listen(0, "127.0.0.1", () => {
       const port = server.address().port;
@@ -15087,7 +15113,7 @@ Waiting for approval\u2026
     });
     setTimeout(
       () => settle(() => {
-        server.close();
+        shutdown();
         reject(new Error("Login timed out after 2 minutes."));
       }),
       timeoutMs
@@ -15743,6 +15769,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";
@@ -15819,6 +15859,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";
@@ -16165,19 +16485,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;
@@ -16274,11 +16657,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;
@@ -16363,8 +16750,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;
     }
@@ -16403,7 +16792,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);
   }
@@ -16433,7 +16825,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);
   }
@@ -16462,7 +16854,7 @@ async function runRedeploy(opts) {
 ${note}
 `
     );
-    await followDeploy(apiUrl, token, deploymentId);
+    await followDeploy(apiUrl, token, deploymentId, { render: renderFor(opts.logs) });
   } catch (err) {
     reportError(err);
   }
@@ -17274,7 +17666,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.1" : "0.0.0-dev";
+var CLI_VERSION = true ? "0.5.1" : "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(
@@ -17310,16 +17702,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(
@@ -17366,7 +17758,16 @@ env.command("pull [project]").description(
 ).option("--force", "overwrite the --out file if it already exists").option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runEnvPull({ ...opts, project: project2 }));
 var ai = program.command("ai").description("Manage the app's EU AI gateway");
 ai.command("enable [project]").description("Give the project an authenticated EU AI endpoint (injects on next deploy)").option("--api-url <url>", "control-plane API base URL").action((project2, opts) => runAiEnable({ ...opts, project: project2 }));
-if (import.meta.url === `file://${process.argv[1]}`) {
+function invokedDirectly() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  try {
+    return import.meta.url === pathToFileURL(realpathSync(entry)).href;
+  } catch {
+    return false;
+  }
+}
+if (invokedDirectly()) {
   program.parseAsync().catch((err) => {
     process.stderr.write(
       `${err instanceof Error ? err.message : String(err)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kryd/cli",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "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",
@@ -58,6 +58,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint src",
     "test": "vitest run",
+    "smoke": "bash scripts/smoke-package.sh",
     "dev": "tsx src/index.ts"
   }
 }