@walkeros/cli 4.2.0 → 4.2.1-next-1781526381392

package/dist/cli.js

@@ -31,25 +31,62 @@ var init_client_context = __esm({
 });
 
 // src/core/api-error.ts
-function throwApiError(error, fallbackMessage) {
-  if (error && typeof error === "object" && "error" in error && typeof error.error === "object") {
-    const inner = error.error;
-    const message = inner.message || fallbackMessage;
-    const code = inner.code;
-    const details = inner.details?.errors;
-    const options = { code, details };
-    if (code === "CLIENT_OUTDATED") {
-      options.minVersion = inner.minVersion;
-      options.clientVersion = inner.clientVersion;
-      options.client = inner.client;
-      options.upgrade = inner.upgrade;
-      options.docs = inner.docs;
-    }
-    throw new ApiError(message, options);
+function extractApiErrorOptions(error, fallbackMessage) {
+  if (!error || typeof error !== "object" || !("error" in error) || typeof error.error !== "object") {
+    return null;
+  }
+  const inner = error.error;
+  const message = inner.message || fallbackMessage;
+  const code = inner.code;
+  const details = inner.details?.errors;
+  const options = { code, details };
+  if (code === "CLIENT_OUTDATED") {
+    options.minVersion = inner.minVersion;
+    options.clientVersion = inner.clientVersion;
+    options.client = inner.client;
+    options.upgrade = inner.upgrade;
+    options.docs = inner.docs;
   }
+  return { message, options };
+}
+function throwApiError(error, fallbackMessage) {
+  const extracted = extractApiErrorOptions(error, fallbackMessage);
+  if (extracted) throw new ApiError(extracted.message, extracted.options);
   throw new ApiError(fallbackMessage);
 }
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) return parseInt(trimmed, 10);
+  const when = Date.parse(trimmed);
+  if (Number.isNaN(when)) return void 0;
+  return Math.max(0, Math.round((when - Date.now()) / 1e3));
+}
+function throwApiResponseError(response, body, fallbackMessage) {
+  const status = response.status;
+  const retryAfterSeconds = parseRetryAfter(
+    response.headers.get("retry-after")
+  );
+  const retryable = status === 429 || status === 503 && retryAfterSeconds !== void 0;
+  const extracted = extractApiErrorOptions(body, fallbackMessage);
+  const message = extracted?.message ?? fallbackMessage;
+  const options = {
+    ...extracted?.options ?? {},
+    status,
+    retryable,
+    retryAfterSeconds
+  };
+  throw new ApiError(message, options);
+}
+function machineReadableErrorLine(err) {
+  const code = err instanceof ApiError ? err.code ?? "UNKNOWN" : "UNKNOWN";
+  const retryable = err instanceof ApiError ? err.retryable === true : false;
+  const retryAfter = err instanceof ApiError && err.retryAfterSeconds !== void 0 ? ` retryAfter=${err.retryAfterSeconds}` : "";
+  const message = err instanceof Error ? err.message : String(err);
+  return `error: code=${code} retryable=${retryable}${retryAfter} message=${message}`;
+}
 function handleCliError(err) {
+  console.error(machineReadableErrorLine(err));
   if (err instanceof ApiError && err.code === "CLIENT_OUTDATED") {
     console.error(`
 ${err.message}
@@ -59,17 +96,25 @@ ${err.message}
 `);
     process.exit(2);
   }
-  const message = err instanceof Error ? err.message : String(err);
-  console.error(message);
+  if (err instanceof ApiError && err.retryable) {
+    const hint = err.retryAfterSeconds !== void 0 ? ` Retry after ${err.retryAfterSeconds}s.` : " This is temporary, retry shortly.";
+    console.error(`${err.message}${hint}`);
+    process.exit(EXIT_RETRYABLE);
+  }
+  console.error(err instanceof Error ? err.message : String(err));
   process.exit(1);
 }
-var ApiError;
+var EXIT_RETRYABLE, ApiError;
 var init_api_error = __esm({
   "src/core/api-error.ts"() {
     "use strict";
+    EXIT_RETRYABLE = 75;
     ApiError = class extends Error {
       code;
       details;
+      status;
+      retryable;
+      retryAfterSeconds;
       // Populated only for CLIENT_OUTDATED responses (HTTP 426).
       minVersion;
       clientVersion;
@@ -81,6 +126,9 @@ var init_api_error = __esm({
         this.name = "ApiError";
         this.code = options?.code;
         this.details = options?.details;
+        this.status = options?.status;
+        this.retryable = options?.retryable;
+        this.retryAfterSeconds = options?.retryAfterSeconds;
         this.minVersion = options?.minVersion;
         this.clientVersion = options?.clientVersion;
         this.client = options?.client;
@@ -4570,7 +4618,7 @@ ${destinationsEntries.join(",\n")}
   stores${collectorStr}
 }`;
   const dataPayload = JSON.stringify(dataPayloadObj, null, 2);
-  return { storesDeclaration, codeConfigObject, dataPayload };
+  return { storesDeclaration, codeConfigObject, dataPayloadObj, dataPayload };
 }
 function generateSplitWireConfigModule(storesDeclaration, codeConfigObject, userCode) {
   const codeSection = userCode ? `
@@ -5314,7 +5362,7 @@ var init_contract = __esm({
   "src/core/contract.ts"() {
     "use strict";
     init_config_file();
-    bakedContractVersion = true ? "1.1.0" : PLACEHOLDER;
+    bakedContractVersion = true ? "2.0.0" : PLACEHOLDER;
   }
 });
 
@@ -6698,7 +6746,7 @@ async function wt(e4, t4, o4) {
   }
 }
 function vt(e4, t4) {
-  return { timing: Math.round((Date.now() - e4.timing) / 10) / 100, source: { type: "collector", schema: "4", version: "4.2.0" }, ...t4 };
+  return { timing: Math.round((Date.now() - e4.timing) / 10) / 100, source: { type: "collector", schema: "4", version: "4.2.1-next-1781526381392" }, ...t4 };
 }
 function bt(e4, t4) {
   if (!t4.name) throw new Error("Event name is required");
@@ -7451,13 +7499,13 @@ function installTimerInterception(options = {}) {
       setInterval: Reflect.get(target, "setInterval"),
       clearInterval: Reflect.get(target, "clearInterval")
     });
-    const trackedSetTimeout = (callback, delay, ...args) => {
+    const trackedSetTimeout = (callback, delay2, ...args) => {
       if (typeof callback !== "function") return 0;
       const id = nextId++;
       pending.set(id, {
         id,
         callback,
-        delay: delay ?? 0,
+        delay: delay2 ?? 0,
         type: "timeout",
         args,
         cleared: false
@@ -7470,13 +7518,13 @@ function installTimerInterception(options = {}) {
       const entry = pending.get(numId);
       if (entry) entry.cleared = true;
     };
-    const trackedSetInterval = (callback, delay, ...args) => {
+    const trackedSetInterval = (callback, delay2, ...args) => {
       if (typeof callback !== "function") return 0;
       const id = nextId++;
       pending.set(id, {
         id,
         callback,
-        delay: delay ?? 0,
+        delay: delay2 ?? 0,
         type: "interval",
         args,
         cleared: false
@@ -7753,7 +7801,7 @@ function toError(error) {
   return error instanceof Error ? error : new Error(getErrorMessage(error));
 }
 function buildSimulationResult(args) {
-  const { step, name, startTime, captured, usage, error } = args;
+  const { step, name, startTime, captured, usage, mappingKey, error } = args;
   const events = (captured ?? []).filter(hasEvent).map((entry) => entry.event);
   const calls = usage ? Object.values(usage).flat().map((call) => ({ fn: call.fn, args: call.args, ts: call.ts })) : [];
   return {
@@ -7762,6 +7810,7 @@ function buildSimulationResult(args) {
     events,
     calls,
     duration: Date.now() - startTime,
+    ...mappingKey !== void 0 ? { mappingKey } : {},
     ...error !== void 0 ? { error: toError(error) } : {}
   };
 }
@@ -8355,7 +8404,9 @@ async function simulateSource(configOrPath, input, options) {
             `Source package "${sourceConfig.package}" has no createTrigger in /dev export`
           );
         }
-        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        const flowConfig = module.wireConfig(
+          options.data ?? module.__configData ?? void 0
+        );
         applyOverrides(flowConfig, prepared.overrides);
         const captured = [];
         flowConfig.hooks = {
@@ -8460,7 +8511,9 @@ async function simulateTransformer(configOrPath, event, options) {
         networkCalls
       },
       async (module) => {
-        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        const flowConfig = module.wireConfig(
+          options.data ?? module.__configData ?? void 0
+        );
         applyOverrides(flowConfig, prepared.overrides);
         if (flowConfig.sources) flowConfig.sources = {};
         if (flowConfig.destinations) flowConfig.destinations = {};
@@ -8626,7 +8679,9 @@ async function simulateCollector(configOrPath, event, options) {
         networkCalls
       },
       async (module) => {
-        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        const flowConfig = module.wireConfig(
+          options.data ?? module.__configData ?? void 0
+        );
         applyOverrides(flowConfig, prepared.overrides);
         if (flowConfig.sources) flowConfig.sources = {};
         if (flowConfig.destinations) flowConfig.destinations = {};
@@ -8729,7 +8784,9 @@ async function simulateDestination(configOrPath, event, options) {
         networkCalls
       },
       async (module) => {
-        const flowConfig = module.wireConfig(module.__configData ?? void 0);
+        const flowConfig = module.wireConfig(
+          options.data ?? module.__configData ?? void 0
+        );
         applyOverrides(flowConfig, prepared.overrides);
         const destPkg = (prepared.flowSettings.destinations ?? {})[options.destinationId];
         let trackedCalls = [];
@@ -8765,6 +8822,16 @@ async function simulateDestination(configOrPath, event, options) {
           );
         }
         logger.info(`Simulating destination: ${options.destinationId}`);
+        let mappingKey;
+        const targetStepId = o("destination", options.destinationId);
+        const captureMappingKey = (state) => {
+          if (state.stepId === targetStepId && state.mappingKey) {
+            mappingKey = state.mappingKey;
+          }
+        };
+        if (collector.observers instanceof Set) {
+          collector.observers.add(captureMappingKey);
+        }
         await collector.push(event, {
           include: [options.destinationId]
         });
@@ -8773,7 +8840,8 @@ async function simulateDestination(configOrPath, event, options) {
           step: "destination",
           name: options.destinationId,
           startTime,
-          usage: trackedCalls.length ? { [options.destinationId]: trackedCalls } : void 0
+          usage: trackedCalls.length ? { [options.destinationId]: trackedCalls } : void 0,
+          mappingKey
         });
       },
       (error) => buildSimulationResult({
@@ -8818,8 +8886,117 @@ import {
 import { dirname as dirname4, join as join5 } from "path";
 import { Readable } from "stream";
 import { x as tarExtract } from "tar";
+
+// src/runtime/fetch-retry.ts
+var DEFAULT_PER_ATTEMPT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_TOTAL_MS = 6e4;
+var DEFAULT_ATTEMPTS = 3;
+var MIN_ATTEMPT_BUDGET_MS = 1e3;
+var BASE_BACKOFF_MS = [2e3, 5e3];
+var JITTER = 0.2;
+var RETRYABLE_NETWORK_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "ENOTFOUND"
+]);
+function readErrorCode(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const code = Reflect.get(value, "code");
+  return typeof code === "string" ? code : void 0;
+}
+function readErrorName(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const name = Reflect.get(value, "name");
+  return typeof name === "string" ? name : void 0;
+}
+function isTransientThrow(error) {
+  const name = readErrorName(error);
+  if (name === "TimeoutError" || name === "AbortError") return true;
+  const directCode = readErrorCode(error);
+  if (directCode && RETRYABLE_NETWORK_CODES.has(directCode)) return true;
+  if (typeof error === "object" && error !== null) {
+    const causeCode = readErrorCode(Reflect.get(error, "cause"));
+    if (causeCode && RETRYABLE_NETWORK_CODES.has(causeCode)) return true;
+  }
+  return error instanceof TypeError;
+}
+function isTransientStatus(status) {
+  return status >= 500 || status === 429;
+}
+function readErrorMessage(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const message = Reflect.get(value, "message");
+  return typeof message === "string" ? message : void 0;
+}
+function describeReason(reason) {
+  if (reason.kind === "status") return `HTTP ${reason.status}`;
+  const name = readErrorName(reason.error);
+  const message = reason.error instanceof Error ? reason.error.message : String(reason.error);
+  let detail = name ? `${name}: ${message}` : message;
+  if (typeof reason.error === "object" && reason.error !== null) {
+    const cause = Reflect.get(reason.error, "cause");
+    const causeCode = readErrorCode(cause);
+    const causeMessage = readErrorMessage(cause);
+    const causeDetail = causeCode ?? causeMessage;
+    if (causeDetail) detail = `${detail} (${causeDetail})`;
+  }
+  return detail;
+}
+function backoffForAttempt(index) {
+  const base = BASE_BACKOFF_MS[Math.min(index, BASE_BACKOFF_MS.length - 1)] ?? 0;
+  const spread = base * JITTER;
+  return base + (Math.random() * 2 - 1) * spread;
+}
+function delay(ms) {
+  return new Promise((resolve4) => {
+    setTimeout(resolve4, ms);
+  });
+}
+async function fetchWithRetry(url, options = {}) {
+  const attempts = options.attempts ?? DEFAULT_ATTEMPTS;
+  const perAttemptTimeoutMs = options.perAttemptTimeoutMs ?? DEFAULT_PER_ATTEMPT_TIMEOUT_MS;
+  const maxTotalMs = options.maxTotalMs ?? DEFAULT_MAX_TOTAL_MS;
+  const init = options.init;
+  const start = Date.now();
+  let lastReason;
+  let made = 0;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    const remaining = maxTotalMs - (Date.now() - start);
+    if (remaining <= MIN_ATTEMPT_BUDGET_MS) break;
+    const attemptTimeoutMs = Math.min(perAttemptTimeoutMs, remaining);
+    made = attempt + 1;
+    let reason;
+    try {
+      const response = await fetch(url, {
+        ...init,
+        signal: AbortSignal.timeout(attemptTimeoutMs)
+      });
+      if (!isTransientStatus(response.status)) return response;
+      await response.body?.cancel();
+      reason = { kind: "status", status: response.status };
+    } catch (error) {
+      if (!isTransientThrow(error)) throw error;
+      reason = { kind: "throw", error };
+    }
+    lastReason = reason;
+    const isLastAttempt = attempt === attempts - 1;
+    const budgetSpent = Date.now() - start >= maxTotalMs;
+    if (isLastAttempt || budgetSpent) break;
+    const sleepMs = Math.min(
+      backoffForAttempt(attempt),
+      maxTotalMs - (Date.now() - start)
+    );
+    if (sleepMs <= 0) break;
+    await delay(sleepMs);
+  }
+  const cause = lastReason ? describeReason(lastReason) : "no attempts made";
+  throw new Error(`Fetch failed after ${made} attempts: ${cause}`);
+}
+
+// src/runtime/resolve-bundle.ts
 var ARCHIVE_ENTRY = "flow.mjs";
-var FETCH_TIMEOUT_MS = 3e4;
 function getDefaultWritePath() {
   if (existsSync2("/app/flow")) return "/app/flow/flow.mjs";
   return "/tmp/walkeros-flow.mjs";
@@ -8844,9 +9021,7 @@ function writeBundleToDisk(writePath, content) {
   writeFileSync2(writePath, content, "utf-8");
 }
 async function fetchOk(url) {
-  const response = await fetch(url, {
-    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
-  });
+  const response = await fetchWithRetry(url);
   if (!response.ok) {
     throw new Error(
       `Failed to fetch bundle from ${url}: ${response.status} ${response.statusText}`
@@ -8967,10 +9142,7 @@ async function fetchConfig(options) {
     options.token,
     options.lastEtag ? { "If-None-Match": options.lastEtag } : void 0
   );
-  const response = await fetch(url, {
-    headers,
-    signal: AbortSignal.timeout(3e4)
-  });
+  const response = await fetchWithRetry(url, { init: { headers } });
   if (response.status === 304) {
     return { changed: false };
   }
@@ -9482,8 +9654,11 @@ var SecretsHttpError = class extends Error {
 async function fetchSecrets(options) {
   const { appUrl, token, projectId, flowId } = options;
   const url = `${appUrl}/api/projects/${encodeURIComponent(projectId)}/flows/${encodeURIComponent(flowId)}/secrets/values`;
-  const res = await fetch(url, {
-    headers: mergeAuthHeaders(token, { "Content-Type": "application/json" })
+  const res = await fetchWithRetry(url, {
+    maxTotalMs: 2e4,
+    init: {
+      headers: mergeAuthHeaders(token, { "Content-Type": "application/json" })
+    }
   });
   await throwIfRunnerAuthFailure(res);
   if (!res.ok) {
@@ -9498,13 +9673,21 @@ init_cache();
 async function runPipeline(options) {
   const { bundlePath, port, logger, loggerConfig, api } = options;
   let configVersion;
+  const configFrozen = readConfigFrozen();
   if (api) {
     await injectSecrets(api, logger);
   }
   logger.info(`walkeros/flow v${VERSION}`);
   logger.info(`Instance: ${getInstanceId()}`);
+  if (configFrozen) {
+    logger.info("Config frozen: hot-swap and heartbeat disabled");
+  }
   const healthServer = await createHealthServer(port, logger);
-  const telemetryObservers = buildTelemetryObservers(api?.flowId ?? "flow");
+  const observeLevel = readObserveLevel(logger);
+  const telemetryObservers = buildTelemetryObservers(
+    api?.flowId ?? "flow",
+    observeLevel
+  );
   const runtimeConfig = { port };
   let handle;
   try {
@@ -9533,20 +9716,24 @@ async function runPipeline(options) {
   const ingestToken = process.env.WALKEROS_INGEST_TOKEN;
   const deploymentId = process.env.WALKEROS_DEPLOYMENT_ID;
   if (observerBase && ingestToken && deploymentId) {
-    tracePoller = createTracePoller(
-      {
-        url: `${observerBase}/trace/${deploymentId}`,
-        token: ingestToken,
-        intervalMs: 15e3
-      },
-      logger
-    );
-    tracePoller.start();
-    logger.info("Trace poller: active (every 15s)");
+    if (observeLevel === "trace") {
+      logger.info("Trace poller: skipped (observe level is trace)");
+    } else {
+      tracePoller = createTracePoller(
+        {
+          url: `${observerBase}/trace/${deploymentId}`,
+          token: ingestToken,
+          intervalMs: 15e3
+        },
+        logger
+      );
+      tracePoller.start();
+      logger.info("Trace poller: active (every 15s)");
+    }
   }
   let currentBundleCleanup;
   let currentConfigPath;
-  if (api) {
+  if (api && !configFrozen) {
     heartbeat = createHeartbeat(
       {
         appUrl: api.appUrl,
@@ -9663,17 +9850,39 @@ async function runPipeline(options) {
   await new Promise(() => {
   });
 }
-function buildTelemetryObservers(flowId) {
+var OBSERVE_LEVELS = [
+  "off",
+  "standard",
+  "trace"
+];
+function readConfigFrozen() {
+  const raw = process.env.WALKEROS_CONFIG_FROZEN;
+  return raw === "1" || raw === "true";
+}
+function readObserveLevel(logger) {
+  const raw = process.env.WALKEROS_OBSERVE_LEVEL;
+  if (raw === void 0 || raw === "") return void 0;
+  const level = OBSERVE_LEVELS.find((candidate) => candidate === raw);
+  if (!level) {
+    logger.warn(
+      `Ignoring invalid WALKEROS_OBSERVE_LEVEL "${raw}" (expected off, standard, or trace)`
+    );
+    return void 0;
+  }
+  return level;
+}
+function buildTelemetryObservers(flowId, observeLevel) {
   const base = process.env.WALKEROS_OBSERVER_URL;
   const token = process.env.WALKEROS_INGEST_TOKEN;
   const deploymentId = process.env.WALKEROS_DEPLOYMENT_ID;
   if (!base || !token || !deploymentId) return void 0;
   const url = `${base}/ingest/${deploymentId}`;
   const emit = ht({ url, token });
+  const observe = observeLevel !== void 0 ? { level: observeLevel } : void 0;
   return [
     ft(
       emit,
-      () => pt({ flowId, traceUntil: mt() })
+      () => pt({ flowId, observe, traceUntil: mt() })
     )
   ];
 }
@@ -11940,7 +12149,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 init_dist();
 import Ajv from "ajv";
-var CLIENT_HEADER = "walkeros-cli/4.2.0";
+var CLIENT_HEADER = "walkeros-cli/4.2.1-next-1781526381392";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path19, flowConfig) {
   const flows = flowConfig.flows;
@@ -12575,6 +12784,7 @@ init_sse();
 init_cli_logger();
 init_output();
 init_flows();
+import { randomUUID as randomUUID2 } from "crypto";
 async function resolveSettingsId(options) {
   const flow = await getFlow({
     flowId: options.flowId,
@@ -12600,8 +12810,9 @@ async function getAvailableFlowNames(options) {
   const settings = flow.settings;
   return settings?.map((c2) => c2.name) ?? [];
 }
+var DEFAULT_DEPLOY_WAIT_MS = 12 * 60 * 1e3;
 async function streamDeploymentStatus(projectId, deploymentId, options) {
-  const timeoutMs = options.timeout ?? 12e4;
+  const timeoutMs = options.timeout ?? DEFAULT_DEPLOY_WAIT_MS;
   const response = await apiFetch(
     `/api/projects/${projectId}/deployments/${deploymentId}/stream`,
     {
@@ -12660,7 +12871,10 @@ async function deploy(options) {
   }
   const { data, error } = await client.POST(
     "/api/projects/{projectId}/flows/{flowId}/deploy",
-    { params: { path: { projectId, flowId: options.flowId } } }
+    {
+      params: { path: { projectId, flowId: options.flowId } },
+      headers: { "Idempotency-Key": randomUUID2() }
+    }
   );
   if (error) {
     try {
@@ -12690,13 +12904,38 @@ Available: ${names.join(", ")}`,
 }
 async function deploySettings(options) {
   const { flowId, projectId, settingsId } = options;
-  const response = await apiFetch(
+  const triggerDeploy = () => apiFetch(
     `/api/projects/${projectId}/flows/${flowId}/settings/${settingsId}/deploy`,
-    { method: "POST" }
+    { method: "POST", headers: { "Idempotency-Key": randomUUID2() } }
   );
+  let response = await triggerDeploy();
+  if (!response.ok && options.wait) {
+    let retryBody = {};
+    try {
+      retryBody = await response.clone().json();
+    } catch {
+      retryBody = {};
+    }
+    try {
+      throwApiResponseError(
+        response,
+        retryBody,
+        `Deploy failed (${response.status})`
+      );
+    } catch (e4) {
+      if (e4 instanceof ApiError && e4.retryable) {
+        const waitSeconds = Math.min(e4.retryAfterSeconds ?? 5, 60);
+        options.onStatus?.("rate_limited", `retrying in ${waitSeconds}s`);
+        await new Promise((resolve4) => setTimeout(resolve4, waitSeconds * 1e3));
+        response = await triggerDeploy();
+      } else {
+        throw e4;
+      }
+    }
+  }
   if (!response.ok) {
     const body = await response.json().catch(() => ({}));
-    throwApiError(body, `Deploy failed (${response.status})`);
+    throwApiResponseError(response, body, `Deploy failed (${response.status})`);
   }
   const data = await response.json();
   if (!options.wait) return data;
@@ -12708,16 +12947,20 @@ async function deploySettings(options) {
   return { ...data, ...result };
 }
 var statusLabels = {
-  bundling: "Building bundle...",
-  "bundling:building": "Building bundle...",
-  "bundling:publishing": "Publishing to web...",
-  deploying: "Deploying container...",
+  "deploying:building": "Building bundle...",
+  "deploying:publishing": "Publishing to web...",
   "deploying:provisioning": "Provisioning container...",
   "deploying:starting": "Starting container...",
+  deploying: "Deploying...",
   active: "Container is live",
   published: "Published",
+  stopped: "Stopped",
   failed: "Deployment failed"
 };
+function renderStatusLabel(status, substatus) {
+  const key = substatus ? `${status}:${substatus}` : status;
+  return statusLabels[key] || statusLabels[status] || `Status: ${status}`;
+}
 async function deployCommand(flowId, options) {
   const log = createCLILogger(options);
   const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1e3 : void 0;
@@ -12729,10 +12972,7 @@ async function deployCommand(flowId, options) {
       wait: options.wait !== false,
       timeout: timeoutMs,
       onStatus: options.json ? void 0 : (status, substatus) => {
-        const key = substatus ? `${status}:${substatus}` : status;
-        log.info(
-          statusLabels[key] || statusLabels[status] || `Status: ${status}`
-        );
+        log.info(renderStatusLabel(status, substatus));
       }
     });
     if (options.json) {
@@ -12747,7 +12987,7 @@ async function deployCommand(flowId, options) {
     } else if (r5.status === "failed") {
       log.error(`Failed: ${r5.errorMessage || "Unknown error"}`);
       process.exit(1);
-    } else if (r5.status === "bundling") {
+    } else if (r5.status === "deploying") {
       log.info(`Deployment started: ${r5.deploymentId} (${r5.type})`);
     } else {
       log.info(`Status: ${r5.status}`);
@@ -12902,20 +13142,16 @@ async function createDeployCommand(config, options) {
     log.info(`Deployment created: ${result.id}`);
     log.info(`  Slug:  ${result.slug}`);
     log.info(`  Type:  ${result.type}`);
-    if (result.deployToken) {
-      log.info(`  Token: ${result.deployToken}`);
-      log.warn("  Save this token \u2014 it will not be shown again.");
-    }
     log.info("");
     log.info("Run locally:");
     log.info(
       `  walkeros run ${isRemoteFlow ? "flow.json" : config} --deploy ${result.id}`
     );
     log.info("");
-    log.info("Docker:");
-    log.info(
-      `  docker run -e WALKEROS_DEPLOY_TOKEN=${result.deployToken ?? "<token>"} \\`
-    );
+    log.info("Create a deploy token for this flow in the app");
+    log.info("(Settings, Self-hosted deploy token) and set it as");
+    log.info("WALKEROS_DEPLOY_TOKEN, then run with Docker:");
+    log.info("  docker run -e WALKEROS_DEPLOY_TOKEN \\");
     log.info("             -e WALKEROS_APP_URL=https://app.walkeros.io \\");
     log.info("             walkeros/flow:latest");
   } catch (err) {
@@ -13231,7 +13467,7 @@ deployCmd.command("create [config]").description(
 });
 deployCmd.command("start <flowId>").description("Deploy a flow to walkerOS cloud (auto-detects web or server)").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("-f, --flow <name>", "flow name for multi-config flows").option("--no-wait", "do not wait for deployment to complete").option(
   "--timeout <seconds>",
-  "timeout for deployment polling (default: 120)"
+  "timeout in seconds for deployment polling (default: 720, the 12-minute server deploy budget)"
 ).option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
   await deployCommand(flowId, options);
 });