@m-kopa/launchpad-cli 0.32.1 → 0.33.0

package/dist/cli.js

@@ -19,7 +19,7 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/version.ts
-var CLI_VERSION = "0.32.1";
+var CLI_VERSION = "0.33.0";
 
 // src/config.ts
 import * as os from "node:os";
@@ -8406,6 +8406,593 @@ function printUsage5(io) {
 
 // src/commands/status.ts
 import { readFileSync as readFileSync13 } from "node:fs";
+
+// src/watch/capabilities.ts
+function isUtf8(env) {
+  const v = `${env.LC_ALL ?? ""}|${env.LC_CTYPE ?? ""}|${env.LANG ?? ""}`.toLowerCase();
+  return v.includes("utf-8") || v.includes("utf8");
+}
+function knownModernTerminal(env) {
+  if (env.WT_SESSION)
+    return true;
+  if (env.ConEmuANSI === "ON")
+    return true;
+  const prog = (env.TERM_PROGRAM ?? "").toLowerCase();
+  return prog === "iterm.app" || prog === "apple_terminal" || prog === "vscode" || prog === "ghostty" || prog === "wezterm";
+}
+function probeCapabilities(p) {
+  const isTTY = p.isTTY === true;
+  if (!isTTY)
+    return { isTTY: false, ansi: false, unicode: false };
+  const term = (p.env.TERM ?? "").toLowerCase();
+  const dumb = term === "dumb";
+  const ansi = !dumb && (p.platform !== "win32" || knownModernTerminal(p.env) || term.startsWith("xterm"));
+  const unicode = isUtf8(p.env) || knownModernTerminal(p.env) || p.platform === "darwin";
+  return { isTTY, ansi, unicode };
+}
+function selectTier(caps) {
+  if (!caps.isTTY)
+    return "plain";
+  if (!caps.ansi)
+    return "append";
+  return caps.unicode ? "inline" : "ascii";
+}
+function detectTier(stream = process.stdout) {
+  const caps = probeCapabilities({
+    platform: process.platform,
+    env: process.env,
+    isTTY: stream.isTTY === true
+  });
+  return { caps, tier: selectTier(caps) };
+}
+
+// src/watch/phases.ts
+var PHASE_NAMES = [
+  "Repo",
+  "Build",
+  "Infra",
+  "Certificate",
+  "Access",
+  "Verify"
+];
+var STAGE_ORDER = [
+  "pending",
+  "repo_created",
+  "bootstrap_pr_opened",
+  "bootstrap_pr_merged",
+  "content_seeded",
+  "tf_pr_opened",
+  "tf_pr_merged",
+  "tf_applied",
+  "cert_active",
+  "policy_attached",
+  "tf_env_pr_opened",
+  "tf_env_pr_merged",
+  "tf_env_applied",
+  "ready_for_content",
+  "deployment_verified"
+];
+var TOTAL_STAGES = STAGE_ORDER.length;
+var STAGE_TO_PHASE = {
+  pending: "Repo",
+  repo_created: "Repo",
+  bootstrap_pr_opened: "Repo",
+  bootstrap_pr_merged: "Repo",
+  content_seeded: "Build",
+  tf_pr_opened: "Infra",
+  tf_pr_merged: "Infra",
+  tf_applied: "Infra",
+  cert_active: "Certificate",
+  policy_attached: "Access",
+  tf_env_pr_opened: "Access",
+  tf_env_pr_merged: "Access",
+  tf_env_applied: "Access",
+  ready_for_content: "Verify",
+  deployment_verified: "Verify"
+};
+var FAILURE_STAGE_TO_PHASE = {
+  validator_rejected: "Repo",
+  bot_pr_ci_failed: "Infra",
+  tf_apply_failed: "Infra",
+  abandoned: "Repo",
+  failed: "Verify"
+};
+function ordinalOfStage(stage) {
+  const i = STAGE_ORDER.indexOf(stage);
+  return i < 0 ? null : i + 1;
+}
+function phaseOfStage(stage) {
+  return STAGE_TO_PHASE[stage] ?? FAILURE_STAGE_TO_PHASE[stage] ?? null;
+}
+function phaseIndex(phase) {
+  return PHASE_NAMES.indexOf(phase);
+}
+
+// src/watch/model.ts
+class WatchModel {
+  slug;
+  startedAtMs = null;
+  stageFirstSeen = new Map;
+  observedOrder = [];
+  currentStage = null;
+  terminal = null;
+  failure = null;
+  liveUrl = null;
+  constructor(slug) {
+    this.slug = slug;
+  }
+  ingest(view, nowMs) {
+    if (this.startedAtMs === null)
+      this.startedAtMs = nowMs;
+    if (view.stage && !this.stageFirstSeen.has(view.stage)) {
+      this.stageFirstSeen.set(view.stage, nowMs);
+      this.observedOrder.push(view.stage);
+    }
+    if (view.stage)
+      this.currentStage = view.stage;
+    if (view.liveUrl)
+      this.liveUrl = view.liveUrl;
+    if (view.state === "live") {
+      this.terminal = "live";
+    } else if (view.state === "failed") {
+      this.terminal = "failed";
+      this.failure = view.failedAt ?? this.failure;
+      if (view.failedAt?.stage)
+        this.currentStage = view.failedAt.stage;
+    }
+  }
+  isTerminal() {
+    return this.terminal !== null;
+  }
+  snapshot(nowMs) {
+    const started = this.startedAtMs ?? nowMs;
+    const activePhase = this.currentStage !== null ? phaseOfStage(this.currentStage) : null;
+    const activeIdx = activePhase !== null ? phaseIndex(activePhase) : -1;
+    const phases = PHASE_NAMES.map((name) => {
+      const idx = phaseIndex(name);
+      let status;
+      if (this.terminal === "live") {
+        status = "done";
+      } else if (this.terminal === "failed") {
+        if (idx < activeIdx)
+          status = "done";
+        else if (idx === activeIdx)
+          status = "failed";
+        else
+          status = "pending";
+      } else if (activeIdx < 0) {
+        status = "pending";
+      } else if (idx < activeIdx) {
+        status = "done";
+      } else if (idx === activeIdx) {
+        status = "active";
+      } else {
+        status = "pending";
+      }
+      return { name, status, elapsedMs: this.phaseElapsed(name, nowMs) };
+    });
+    const stageOrdinal = this.terminal === "live" ? TOTAL_STAGES : this.currentStage !== null ? ordinalOfStage(this.currentStage) : null;
+    return {
+      slug: this.slug,
+      phases,
+      currentStage: this.currentStage,
+      stageOrdinal,
+      totalStages: TOTAL_STAGES,
+      terminal: this.terminal,
+      failure: this.failure ? {
+        stage: this.failure.stage,
+        message: this.failure.message,
+        retryable: this.failure.retryable
+      } : null,
+      liveUrl: this.liveUrl,
+      startedAtMs: started,
+      elapsedTotalMs: Math.max(0, nowMs - started)
+    };
+  }
+  phaseElapsed(phase, nowMs) {
+    let startMs = null;
+    for (const stage of this.observedOrder) {
+      if (phaseOfStage(stage) === phase) {
+        const seen = this.stageFirstSeen.get(stage);
+        if (seen !== undefined && (startMs === null || seen < startMs)) {
+          startMs = seen;
+        }
+      }
+    }
+    if (startMs === null)
+      return null;
+    const targetIdx = phaseIndex(phase);
+    let endMs = null;
+    for (const stage of this.observedOrder) {
+      const p = phaseOfStage(stage);
+      if (p !== null && phaseIndex(p) > targetIdx) {
+        const seen = this.stageFirstSeen.get(stage);
+        if (seen !== undefined && (endMs === null || seen < endMs)) {
+          endMs = seen;
+        }
+      }
+    }
+    if (endMs === null)
+      endMs = nowMs;
+    return Math.max(0, endMs - startMs);
+  }
+}
+
+// src/watch/engine.ts
+var DEFAULTS = {
+  pollIntervalMs: 2000,
+  backoffFactor: 1.5,
+  maxBackoffMs: 30000,
+  maxDurationMs: 20 * 60 * 1000
+};
+async function runWatchLoop(slug, deps, options = {}) {
+  const opts = { ...DEFAULTS, ...options };
+  const model = new WatchModel(slug);
+  const startedAt = deps.now();
+  let backoffMs = opts.pollIntervalMs;
+  let lastSnapshot = null;
+  while (true) {
+    if (deps.signal.aborted)
+      return { outcome: "interrupted", snapshot: lastSnapshot };
+    let nextDelay = opts.pollIntervalMs;
+    try {
+      const view = await deps.fetchLifecycle();
+      if (view === null) {
+        return { outcome: "not_found", snapshot: lastSnapshot };
+      }
+      model.ingest(view, deps.now());
+      lastSnapshot = model.snapshot(deps.now());
+      if (model.isTerminal()) {
+        deps.onTerminal(lastSnapshot);
+        return {
+          outcome: lastSnapshot.terminal === "live" ? "live" : "failed",
+          snapshot: lastSnapshot
+        };
+      }
+      deps.onTick(lastSnapshot);
+      backoffMs = opts.pollIntervalMs;
+    } catch (error) {
+      backoffMs = Math.min(backoffMs * opts.backoffFactor, opts.maxBackoffMs);
+      nextDelay = backoffMs;
+      deps.onPollError?.(error, nextDelay);
+    }
+    if (deps.signal.aborted)
+      return { outcome: "interrupted", snapshot: lastSnapshot };
+    if (deps.now() - startedAt >= opts.maxDurationMs) {
+      return { outcome: "timeout", snapshot: lastSnapshot };
+    }
+    await deps.sleep(nextDelay, deps.signal);
+  }
+}
+function makeRealSleep() {
+  return (ms, signal) => new Promise((resolve11) => {
+    if (signal.aborted)
+      return resolve11();
+    const t = setTimeout(resolve11, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(t);
+      resolve11();
+    }, { once: true });
+  });
+}
+
+// src/watch/sanitize.ts
+function isControlCodePoint(cp) {
+  return cp <= 31 || cp >= 127 && cp <= 159;
+}
+function sanitizeForTerminal(input2) {
+  let out = "";
+  for (const ch of input2) {
+    const cp = ch.codePointAt(0);
+    if (cp !== undefined && !isControlCodePoint(cp))
+      out += ch;
+  }
+  return out;
+}
+function sanitizeField(input2, max = 160) {
+  if (input2 == null)
+    return "";
+  const clean = sanitizeForTerminal(input2);
+  if (clean.length <= max)
+    return clean;
+  return clean.slice(0, Math.max(0, max - 1)) + "…";
+}
+
+// src/watch/render.ts
+var GLYPHS = {
+  unicode: {
+    done: "✓",
+    pending: "○",
+    fail: "✗",
+    active: ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"],
+    sep: "·",
+    arrow: "→",
+    dash: "—"
+  },
+  ascii: {
+    done: "v",
+    pending: ".",
+    fail: "x",
+    active: ["|", "/", "-", "\\"],
+    sep: "-",
+    arrow: "->",
+    dash: "-"
+  }
+};
+var ESC = "\x1B";
+var CURSOR_HIDE = `${ESC}[?25l`;
+var CURSOR_SHOW = `${ESC}[?25h`;
+var cursorUp = (n) => n > 0 ? `${ESC}[${n}A` : "";
+var CLEAR_FROM_CURSOR = `${ESC}[0J`;
+function styleForTier(tier) {
+  return tier === "inline" ? "unicode" : "ascii";
+}
+function launchpadUrl(slug) {
+  return `https://${sanitizeField(slug, 80)}.launchpad.m-kopa.us`;
+}
+function formatDuration(ms, dash = "—") {
+  if (ms == null)
+    return dash;
+  const total = Math.floor(ms / 1000);
+  const m = Math.floor(total / 60);
+  const s = total % 60;
+  return `${m}:${String(s).padStart(2, "0")}`;
+}
+function phaseGlyph(g, status, spinnerFrame) {
+  switch (status) {
+    case "done":
+      return g.done;
+    case "failed":
+      return g.fail;
+    case "active":
+      return g.active[spinnerFrame % g.active.length] ?? g.active[0];
+    default:
+      return g.pending;
+  }
+}
+function headerSpinner(g, spinnerFrame) {
+  return g.active[spinnerFrame % g.active.length] ?? g.active[0];
+}
+var PAD = 12;
+function renderProvisioningFrame(s, opts) {
+  const g = GLYPHS[opts.style];
+  const slug = sanitizeField(s.slug, 80);
+  const lines = [];
+  lines.push(`  launchpad ${g.sep} provisioning ${slug}      ${headerSpinner(g, opts.spinnerFrame)} ${formatDuration(s.elapsedTotalMs, g.dash)}`);
+  lines.push("");
+  for (const p of s.phases) {
+    const glyph = phaseGlyph(g, p.status, opts.spinnerFrame);
+    const name = p.name.padEnd(PAD);
+    const detail = p.status === "active" ? "..." : p.status === "done" ? formatDuration(p.elapsedMs, g.dash) : "";
+    lines.push(`  ${glyph} ${name} ${detail}`);
+  }
+  lines.push("");
+  const stage = s.currentStage ? sanitizeField(s.currentStage, 40) : g.dash;
+  const ord = s.stageOrdinal ?? "?";
+  lines.push(`  stage ${ord}/${s.totalStages} ${g.sep} ${stage}`);
+  lines.push(`  Ctrl-C to stop watching ${g.sep} provisioning continues`);
+  return lines.join(`
+`);
+}
+function renderAppendLine(s, opts) {
+  const g = GLYPHS[opts.style];
+  const active = s.phases.find((p) => p.status === "active");
+  const phase = active ? active.name : s.terminal === "live" ? "live" : "...";
+  const stage = s.currentStage ? sanitizeField(s.currentStage, 40) : g.dash;
+  return `  ${headerSpinner(g, opts.spinnerFrame)} ${phase} ${g.sep} stage ${s.stageOrdinal ?? "?"}/${s.totalStages} ${g.sep} ${stage} ${g.sep} ${formatDuration(s.elapsedTotalMs, g.dash)}`;
+}
+function renderPlainLine(s) {
+  const slug = sanitizeField(s.slug, 80);
+  if (s.terminal === "live") {
+    const url = s.liveUrl ? sanitizeField(s.liveUrl, 120) : launchpadUrl(s.slug);
+    return `${slug}: live -> ${url}`;
+  }
+  if (s.terminal === "failed") {
+    const stage2 = s.failure ? sanitizeField(s.failure.stage, 40) : "unknown";
+    const reason = s.failure ? sanitizeField(s.failure.message, 200) : "";
+    return `${slug}: failed at ${stage2}${reason ? ` - ${reason}` : ""}`;
+  }
+  const stage = s.currentStage ? sanitizeField(s.currentStage, 40) : "pending";
+  return `${slug}: provisioning (stage: ${stage}) [${s.stageOrdinal ?? "?"}/${s.totalStages}]`;
+}
+function renderLiveFrame(s, opts) {
+  const g = GLYPHS[opts.style];
+  const slug = sanitizeField(s.slug, 80);
+  const url = s.liveUrl ? sanitizeField(s.liveUrl, 120) : launchpadUrl(s.slug);
+  const row = s.phases.map((p) => `${p.name} ${g.done}`).join("   ");
+  return [
+    `  launchpad ${g.sep} ${slug} is LIVE`,
+    "",
+    `  ${row}`,
+    "",
+    `  Live ${g.arrow} ${url}`
+  ].join(`
+`);
+}
+function renderFailedFrame(s, opts) {
+  const g = GLYPHS[opts.style];
+  const slug = sanitizeField(s.slug, 80);
+  const row = s.phases.map((p) => `${p.name} ${p.status === "failed" ? g.fail : p.status === "done" ? g.done : g.pending}`).join("   ");
+  const stage = s.failure ? sanitizeField(s.failure.stage, 40) : "—";
+  const reason = s.failure ? sanitizeField(s.failure.message, 200) : "unknown";
+  const recovery = s.failure?.retryable === false ? "recover" : "deploy --resume";
+  return [
+    `  launchpad ${g.sep} ${slug} ${g.dash} provisioning failed`,
+    "",
+    `  ${row}`,
+    "",
+    `  ${g.fail} ${stage}: ${reason}`,
+    `  Next ${g.arrow} launchpad ${recovery} ${slug}`
+  ].join(`
+`);
+}
+
+class Renderer {
+  write;
+  tier;
+  prevLines = 0;
+  spinnerFrame = 0;
+  cursorHidden = false;
+  style;
+  constructor(write, tier) {
+    this.write = write;
+    this.tier = tier;
+    this.style = styleForTier(tier);
+  }
+  tick(s) {
+    if (this.tier === "plain")
+      return;
+    this.spinnerFrame += 1;
+    if (this.tier === "append") {
+      this.write(renderAppendLine(s, { style: this.style, spinnerFrame: this.spinnerFrame }) + `
+`);
+      return;
+    }
+    if (!this.cursorHidden) {
+      this.write(CURSOR_HIDE);
+      this.cursorHidden = true;
+    }
+    this.redraw(renderProvisioningFrame(s, { style: this.style, spinnerFrame: this.spinnerFrame }));
+  }
+  terminal(s) {
+    if (this.tier === "plain")
+      return;
+    const frame = s.terminal === "live" ? renderLiveFrame(s, { style: this.style }) : renderFailedFrame(s, { style: this.style });
+    if (this.tier === "append") {
+      this.write(frame + `
+`);
+    } else {
+      this.redraw(frame);
+    }
+    this.restoreCursor();
+  }
+  restoreCursor() {
+    if (this.cursorHidden) {
+      this.write(CURSOR_SHOW);
+      this.cursorHidden = false;
+    }
+  }
+  redraw(body) {
+    const out = (this.prevLines > 0 ? cursorUp(this.prevLines) + CLEAR_FROM_CURSOR : "") + body + `
+`;
+    this.write(out);
+    this.prevLines = body.split(`
+`).length;
+  }
+}
+
+// src/watch/index.ts
+async function fetchLifecycleView(cfg, slug) {
+  try {
+    return await apiJson(cfg, {
+      path: `/apps/${slug}/lifecycle`
+    });
+  } catch (e) {
+    if (e instanceof NotFoundError)
+      return null;
+    throw e;
+  }
+}
+function mapWatchError(e, slug, io) {
+  if (e instanceof UnauthenticatedError) {
+    io.err(`launchpad watch: ${e.message}`);
+    io.err("  session expired, run `launchpad login`");
+    return 2;
+  }
+  if (e instanceof ForbiddenError) {
+    io.err(`launchpad watch: not authorised for app "${slug}" (owner or editor required)`);
+    return 2;
+  }
+  if (e instanceof NotFoundError) {
+    io.err(`launchpad watch: app "${slug}" not found`);
+    return 2;
+  }
+  if (e instanceof ApiError || e instanceof TransportError) {
+    io.err(`launchpad watch: ${e.message}`);
+    return 2;
+  }
+  io.err(`launchpad watch failed: ${e instanceof Error ? e.message : String(e)}`);
+  return 2;
+}
+function defaultSignalRegistrar(handler) {
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+  return () => {
+    process.off("SIGINT", handler);
+    process.off("SIGTERM", handler);
+  };
+}
+async function runWatch(slug, io, deps = {}) {
+  const cfg = loadConfig();
+  const now = deps.now ?? (() => Date.now());
+  const stdout = deps.stdout ?? process.stdout;
+  let first;
+  try {
+    first = await fetchLifecycleView(cfg, slug);
+  } catch (e) {
+    return mapWatchError(e, slug, io);
+  }
+  if (first === null) {
+    io.err(`launchpad watch: no app "${slug}" to watch (unknown slug, or first deploy not started)`);
+    return 1;
+  }
+  if (first.state === "destroyed" || first.state === "destroying" || first.state === "destroy_failed") {
+    io.out(`${slug}: ${first.state} — nothing to watch.`);
+    return 0;
+  }
+  const { tier } = detectTier(stdout);
+  const renderer = new Renderer((s) => stdout.write(s), tier);
+  const controller = new AbortController;
+  const registrar = deps.onSignal ?? defaultSignalRegistrar;
+  const unregister = registrar(() => {
+    controller.abort();
+    renderer.restoreCursor();
+  });
+  const onTick = (s) => {
+    if (tier === "plain")
+      io.out(renderPlainLine(s));
+    else
+      renderer.tick(s);
+  };
+  const onTerminal = (s) => {
+    if (tier === "plain")
+      io.out(renderPlainLine(s));
+    else
+      renderer.terminal(s);
+  };
+  try {
+    const res = await runWatchLoop(slug, {
+      fetchLifecycle: () => fetchLifecycleView(cfg, slug),
+      now,
+      sleep: makeRealSleep(),
+      signal: controller.signal,
+      onTick,
+      onTerminal
+    }, deps.engineOptions);
+    switch (res.outcome) {
+      case "live":
+        return 0;
+      case "failed":
+        return 1;
+      case "not_found":
+        io.err(`launchpad watch: app "${slug}" is no longer known to the platform`);
+        return 1;
+      case "interrupted":
+        io.err(`
+stopped watching ${slug} — provisioning continues. Re-run \`launchpad watch ${slug}\`.`);
+        return 130;
+      case "timeout":
+        io.err(`
+still provisioning after the watch window — re-run \`launchpad watch ${slug}\` or check \`launchpad status ${slug}\`.`);
+        return 0;
+    }
+  } finally {
+    unregister();
+    renderer.restoreCursor();
+  }
+}
+
+// src/commands/status.ts
 var statusCommand = {
   name: "status",
   summary: "show drift between local launchpad.yaml and deployed state",
@@ -8449,6 +9036,9 @@ async function runStatus(args, io) {
     printUsage6(io);
     return 64;
   }
+  if (parsed.watch) {
+    return runWatch(parsed.slug, io);
+  }
   const cfg = loadConfig();
   let lifecycle;
   try {
@@ -8815,6 +9405,7 @@ function parseArgs9(args, cwd = process.cwd(), warn) {
   let file = "./launchpad.yaml";
   let json = false;
   let strict = false;
+  let watch = false;
   let i = 0;
   while (i < args.length) {
     const a = args[i] ?? "";
@@ -8847,6 +9438,11 @@ function parseArgs9(args, cwd = process.cwd(), warn) {
       i += 1;
       continue;
     }
+    if (a === "--watch") {
+      watch = true;
+      i += 1;
+      continue;
+    }
     if (a.startsWith("--")) {
       return `unknown flag "${a}"`;
     }
@@ -8866,7 +9462,7 @@ function parseArgs9(args, cwd = process.cwd(), warn) {
   if (!SLUG_RE11.test(slug)) {
     return `invalid slug "${slug}" — expected ${SLUG_RE11.source}`;
   }
-  return { slug, file, json, strict };
+  return { slug, file, json, strict, watch };
 }
 function printUsage6(io) {
   io.err([
@@ -8911,6 +9507,53 @@ function isEnoent(e) {
   return typeof e === "object" && e !== null && e.code === "ENOENT";
 }
 
+// src/commands/watch.ts
+var SLUG_RE12 = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+function printUsage7(io) {
+  io.err("usage: launchpad watch [<slug>] [--slug <slug>] [--file <path>]");
+  io.err("       Watch an app provision to live in real time.");
+}
+function resolveWatchSlug(args, cwd, warn) {
+  let explicit;
+  let file;
+  for (let i = 0;i < args.length; i += 1) {
+    const a = args[i];
+    if (a === "--slug") {
+      explicit = args[++i];
+    } else if (a === "--file") {
+      file = args[++i];
+    } else if (a === "--watch") {} else if (a.startsWith("-")) {
+      return { error: `unknown flag: ${a}` };
+    } else if (explicit === undefined) {
+      explicit = a;
+    } else {
+      return { error: `unexpected argument: ${a}` };
+    }
+  }
+  const slug = explicit ?? inferSlug({ cwd, file, warn }) ?? undefined;
+  if (slug === undefined) {
+    return { error: "no slug given and none could be inferred from the current directory" };
+  }
+  if (!SLUG_RE12.test(slug)) {
+    return { error: `invalid slug: "${slug}"` };
+  }
+  return { slug };
+}
+async function runWatchCommand(args, io) {
+  const resolved = resolveWatchSlug(args, process.cwd(), (l) => io.err(l));
+  if ("error" in resolved) {
+    io.err(`launchpad watch: ${resolved.error}`);
+    printUsage7(io);
+    return 64;
+  }
+  return runWatch(resolved.slug, io);
+}
+var watchCommand = {
+  name: "watch",
+  summary: "watch an app provision to live in real time",
+  run: runWatchCommand
+};
+
 // src/commands/review.ts
 import * as path12 from "node:path";
 var reviewCommand = {
@@ -8918,7 +9561,7 @@ var reviewCommand = {
   summary: "show the review state for a PR (slug-scoped)",
   run: runReview
 };
-var SLUG_RE12 = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+var SLUG_RE13 = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
 async function runReview(args, io) {
   const parsed = parseArgs10(args);
   if (parsed === null) {
@@ -8938,8 +9581,8 @@ async function runReview(args, io) {
     }
     slug = inferred;
   }
-  if (!SLUG_RE12.test(slug)) {
-    io.err(`launchpad review: invalid slug "${slug}" — expected ${SLUG_RE12.source}`);
+  if (!SLUG_RE13.test(slug)) {
+    io.err(`launchpad review: invalid slug "${slug}" — expected ${SLUG_RE13.source}`);
     return 64;
   }
   try {
@@ -11851,6 +12494,7 @@ var COMMANDS = [
   generateCommand,
   pullCommand,
   statusCommand,
+  watchCommand,
   recoverCommand,
   destroyCommand,
   rollbackCommand,