@walkeros/cli 4.2.0 → 4.2.1-next-1781526381392

package/dist/index.js

@@ -2755,6 +2755,9 @@ ${firstError.text}`
 ` + (location ? `  at ${location.file}:${location.line}:${location.column}` : "")
   );
 }
+function buildDataPayload(flowSettings) {
+  return buildSplitConfigObject(flowSettings, detectNamedImports(flowSettings)).dataPayloadObj;
+}
 function buildSplitConfigObject(flowSettings, namedImports) {
   const sources = flowSettings.sources || {};
   const destinations = flowSettings.destinations || {};
@@ -2777,7 +2780,7 @@ function buildSplitConfigObject(flowSettings, namedImports) {
     }
     return props;
   }
-  function buildSplitStepEntry(section, stepId, step) {
+  function buildSplitStepEntry(section, stepId2, step) {
     const codeVar = resolveCodeVar(step);
     const stepProps = getStepProps(step);
     const { codeProps, dataProps } = classifyStepProperties(stepProps);
@@ -2788,13 +2791,13 @@ function buildSplitConfigObject(flowSettings, namedImports) {
       codeEntries.push(`${key}: ${processConfigValue(value)}`);
     }
     for (const key of Object.keys(dataProps)) {
-      codeEntries.push(`${key}: __data.${section}.${stepId}.${key}`);
+      codeEntries.push(`${key}: __data.${section}.${stepId2}.${key}`);
     }
     if (Object.keys(dataProps).length > 0) {
       if (!dataPayloadObj[section]) dataPayloadObj[section] = {};
-      dataPayloadObj[section][stepId] = dataProps;
+      dataPayloadObj[section][stepId2] = dataProps;
     }
-    return `    ${stepId}: {
+    return `    ${stepId2}: {
       ${codeEntries.join(",\n      ")}
     }`;
   }
@@ -2904,7 +2907,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 ? `
@@ -3848,7 +3851,8 @@ import {
   createIngest,
   getPlatform as getPlatform3,
   getNextSteps,
-  buildCacheContext
+  buildCacheContext,
+  stepId
 } from "@walkeros/core";
 import {
   enrichEvent,
@@ -4052,13 +4056,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
@@ -4071,13 +4075,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
@@ -4354,7 +4358,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 {
@@ -4363,6 +4367,7 @@ function buildSimulationResult(args) {
     events,
     calls,
     duration: Date.now() - startTime,
+    ...mappingKey !== void 0 ? { mappingKey } : {},
     ...error !== void 0 ? { error: toError(error) } : {}
   };
 }
@@ -4956,7 +4961,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 = {
@@ -5061,7 +5068,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 = {};
@@ -5227,7 +5236,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 = {};
@@ -5330,7 +5341,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 = [];
@@ -5366,6 +5379,16 @@ async function simulateDestination(configOrPath, event, options) {
           );
         }
         logger.info(`Simulating destination: ${options.destinationId}`);
+        let mappingKey;
+        const targetStepId = stepId("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]
         });
@@ -5374,7 +5397,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({
@@ -5419,8 +5443,117 @@ import {
 import { dirname as dirname3, join as join4 } 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((resolve5) => {
+    setTimeout(resolve5, 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";
@@ -5445,9 +5578,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}`
@@ -5568,10 +5699,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 };
   }
@@ -6113,8 +6241,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) {
@@ -6129,13 +6260,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 {
@@ -6164,20 +6303,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,
@@ -6294,17 +6437,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 = createBatchedPoster({ url, token });
+  const observe = observeLevel !== void 0 ? { level: observeLevel } : void 0;
   return [
     createTelemetryObserver(
       emit,
-      () => resolveTelemetryOptions({ flowId, traceUntil: getTraceUntil() })
+      () => resolveTelemetryOptions({ flowId, observe, traceUntil: getTraceUntil() })
     )
   ];
 }
@@ -7235,7 +7400,7 @@ function validateMapping(input) {
 // src/commands/validate/validators/entry.ts
 import Ajv from "ajv";
 import { fetchPackageSchema } from "@walkeros/core";
-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(path20, flowConfig) {
   const flows = flowConfig.flows;
@@ -7800,8 +7965,8 @@ import createClient from "openapi-fetch";
 init_config_file();
 import { createHash } from "crypto";
 import semver4 from "semver";
-var bakedContractVersion = true ? "1.1.0" : PLACEHOLDER;
-var bakedContractHash = true ? "847253b928a84dcdfc448e296418a5e48fa97b95f4a655e47e400d59d8e7f3cd" : "";
+var bakedContractVersion = true ? "2.0.0" : PLACEHOLDER;
+var bakedContractHash = true ? "b9ac141c5d759debbb52b838669daabec64659c3b79038dee69e5488b3f31dea" : "";
 function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -7932,9 +8097,13 @@ function createApiClient() {
 }
 
 // src/core/api-error.ts
+var EXIT_RETRYABLE = 75;
 var ApiError = class extends Error {
   code;
   details;
+  status;
+  retryable;
+  retryAfterSeconds;
   // Populated only for CLIENT_OUTDATED responses (HTTP 426).
   minVersion;
   clientVersion;
@@ -7946,6 +8115,9 @@ var ApiError = class extends Error {
     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;
@@ -7953,25 +8125,62 @@ var ApiError = class extends Error {
     this.docs = options?.docs;
   }
 };
-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}
@@ -7981,8 +8190,12 @@ ${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);
 }
 
@@ -8278,6 +8491,7 @@ async function readFlowStdin() {
 }
 
 // src/commands/deploy/index.ts
+import { randomUUID } from "crypto";
 init_auth();
 init_http();
 init_sse();
@@ -8308,8 +8522,9 @@ async function getAvailableFlowNames(options) {
   const settings = flow.settings;
   return settings?.map((c) => c.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`,
     {
@@ -8368,7 +8583,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": randomUUID() }
+    }
   );
   if (error) {
     try {
@@ -8398,13 +8616,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": randomUUID() } }
   );
+  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 (e) {
+      if (e instanceof ApiError && e.retryable) {
+        const waitSeconds = Math.min(e.retryAfterSeconds ?? 5, 60);
+        options.onStatus?.("rate_limited", `retrying in ${waitSeconds}s`);
+        await new Promise((resolve5) => setTimeout(resolve5, waitSeconds * 1e3));
+        response = await triggerDeploy();
+      } else {
+        throw e;
+      }
+    }
+  }
   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;
@@ -8428,7 +8671,7 @@ async function getDeployment(options) {
     );
     if (!response.ok) {
       const body = await response.json().catch(() => ({}));
-      throwApiError(body, "Failed to get deployment");
+      throwApiResponseError(response, body, "Failed to get deployment");
     }
     return response.json();
   }
@@ -8441,16 +8684,20 @@ async function getDeployment(options) {
   return data;
 }
 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;
@@ -8462,10 +8709,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) {
@@ -8480,7 +8724,7 @@ async function deployCommand(flowId, options) {
     } else if (r.status === "failed") {
       log.error(`Failed: ${r.errorMessage || "Unknown error"}`);
       process.exit(1);
-    } else if (r.status === "bundling") {
+    } else if (r.status === "deploying") {
       log.info(`Deployment started: ${r.deploymentId} (${r.type})`);
     } else {
       log.info(`Status: ${r.status}`);
@@ -8708,20 +8952,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) {
@@ -8807,14 +9047,14 @@ init_config_file();
 
 // src/telemetry/install-id.ts
 init_config_file();
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 function getInstallationId() {
   return readConfig()?.installationId;
 }
 function createInstallationId() {
   const existing = readConfig()?.installationId;
   if (existing) return existing;
-  const id = randomUUID();
+  const id = randomUUID2();
   writeTelemetryOnlyConfig({ installationId: id });
   return id;
 }
@@ -8875,6 +9115,8 @@ function telemetryDisableCommand() {
 
 // src/index.ts
 init_bundle();
+init_bundler();
+init_config_classifier();
 
 // src/commands/bundle/validate-structure.ts
 init_structural_validators();
@@ -9560,12 +9802,15 @@ export {
   apiFetch,
   bakedContractHash,
   bakedContractVersion,
+  buildDataPayload,
   bundle,
   bundleCommand,
   canonicalContractHash,
+  classifyStepProperties,
   clientContextHeaders,
   compareContract,
   compareOutput,
+  containsCodeMarkers,
   createApiClient,
   createDeployCommand,
   createDeployment,