@walkeros/cli 4.3.0 → 4.3.1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Flow, PreviewKey, Elb, Ingest, WalkerOS, Simulation } from '@walkeros/core';
+import { Flow, PreviewKey, Elb, Ingest, WalkerOS, Simulation, ObserveWeb } from '@walkeros/core';
 export { Flow } from '@walkeros/core';
 import { BuildOptions as BuildOptions$1 } from 'esbuild';
 import { z } from '@walkeros/core/dev';
@@ -218,6 +218,15 @@ interface BundleStats {
  * payload by construction.
  */
 declare function buildDataPayload(flowSettings: Flow): Record<string, unknown>;
+/**
+ * Generate a stage 2 entry file for wrapping an ALREADY-embedded skeleton.
+ *
+ * Unlike `generateWebEntry`, this variant imports `__configData` from the
+ * skeleton (instead of inlining a `dataPayload` string). Used by the
+ * publish-time `wrapSkeleton` helper, which runs on a stage 1 skeleton
+ * produced via `bundle({ skipWrapper: true })` — those skeletons already
+ * export `__configData` alongside `wireConfig` and `startFlow`.
+ */
 /**
  * Preview activation wiring. When present and enabled, the generated entry
  * imports the activator from core and lets it decide whether a preview bundle
@@ -9837,8 +9846,6 @@ interface components {
       flowId: string;
       flowSettingsId: string;
       projectId: string;
-      /** @example k9x2m4p7abcd */
-      token: string;
       /** Format: uri */
       bundleUrl: string;
       activationUrl: string | null;
@@ -9893,17 +9900,33 @@ interface components {
       serverFlowName: string | null;
       serverEndpoint: string | null;
       web: components['schemas']['ObserveSessionWeb'];
+      server: components['schemas']['ObserveSessionServer'];
+      /** Format: date-time */
+      expiresAt: string;
+      recordsReceived: number;
       createdBy: string;
       /** Format: date-time */
       createdAt: string;
     };
     ObserveSessionWeb: {
-      previewId: string;
-      token: string;
+      /** Format: uri */
+      activationUrl: string | null;
+      credential: string;
       previewEnabled: boolean;
       /** Format: uri */
       bundleUrl: string;
     } | null;
+    ObserveSessionServer: {
+      /** Format: uri */
+      endpoint: string | null;
+      env: components['schemas']['ObserveSessionServerEnv'];
+    } | null;
+    ObserveSessionServerEnv: {
+      /** Format: uri */
+      WALKEROS_OBSERVER_URL: string;
+      WALKEROS_DEPLOYMENT_ID: string;
+      WALKEROS_INGEST_TOKEN: string;
+    };
     ObserveSessionJourneysResponse: {
       /** @example ses_abc123xyz456 */
       sessionId: string;
@@ -9921,7 +9944,12 @@ interface components {
     CreateObserveSessionRequest: {
       settingsName: string;
       force?: boolean;
+      replace?: boolean;
+      level?: components['schemas']['ObserveLevel'];
+      origins?: string[];
     };
+    /** @enum {string} */
+    ObserveLevel: 'off' | 'standard' | 'trace';
     ObserveSessionHeartbeatResponse: {
       /** @enum {boolean} */
       ok: true;
@@ -11512,15 +11540,14 @@ interface WrapSkeletonOptions {
      */
     previewGrantTargets?: string[];
     /**
-     * Browser-only: telemetry wiring. When provided, the wrapped bundle
-     * installs an observer built via `createTelemetryObserver` onto
-     * `collector.observers` and forwards FlowState records to `observerUrl`
-     * using `createBatchedPoster`.
-     *
-     * Omit (or pass `level: 'off'`) to ship a bundle with zero telemetry
-     * plumbing.
+     * Browser-only: STATIC observe connect config baked onto the startFlow
+     * config. PUBLIC values only (`url` + `binding`, plus optional
+     * `flowId`/`level`/`sample` scoping); the runtime connect module reads the
+     * per-session credential out-of-band at boot via the `elbObserve` slot.
+     * This is the preview-artifact observation wiring: it bakes no ingest
+     * token into the emitted bytes.
      */
-    telemetry?: TelemetryBundleOptions;
+    observe?: ObserveWeb;
     /**
      * esbuild target. @default 'es2018' for browser, 'node18' for node.
      */
@@ -11530,31 +11557,6 @@ interface WrapSkeletonOptions {
     /** Fine-grained minification options, forwarded to esbuild. */
     minifyOptions?: MinifyOptions;
 }
-interface TelemetryBundleOptions {
-    /** Absolute ingest URL. POST receives JSON array of FlowState. */
-    observerUrl: string;
-    /**
-     * Full deployment-scoped trace endpoint, e.g.
-     * `https://observer.example.com/trace/<deploymentId>`. Baked into the bundle
-     * and polled verbatim; the browser never constructs it from a base.
-     *
-     * Optional: when omitted, the bundle wires the observer at a fixed `level`
-     * with no polling. Suits short-lived, URL-opted-in sessions (e.g. a preview
-     * at `level: 'trace'`).
-     */
-    traceUrl?: string;
-    /** Deployment-scoped plaintext token. Sent as `Authorization: Bearer`. */
-    ingestToken: string;
-    /** Used as the `flowId` on every emitted FlowState. */
-    flowId: string;
-    /**
-     * Baseline verbosity. Default 'standard'. Even an 'off' baseline is wired
-     * (as a supplier) so the runtime trace poll can flip it to trace.
-     */
-    level?: 'off' | 'standard' | 'trace';
-    /** Deterministic sample fraction in [0, 1]. Default 1. */
-    sample?: number;
-}
 declare function wrapSkeleton(options: WrapSkeletonOptions): Promise<void>;
 
 declare function createApiClient(): openapi_fetch.Client<paths, `${string}/${string}`>;

package/dist/index.js

@@ -2506,7 +2506,8 @@ ${dataDeclaration}`;
       const stage2Entry = (buildOptions.platform || "node") === "browser" ? generateWebEntry(stage1Path, dataPayload, {
         windowCollector: buildOptions.windowCollector,
         windowElb: buildOptions.windowElb,
-        platform: buildOptions.platform
+        platform: buildOptions.platform,
+        observe: readObserveConnect(flowSettings, logger)
       }) : generateServerEntry(stage1Path, dataPayload);
       const stage2EntryPath = path12.join(TEMP_DIR, "stage2.mjs");
       await fs11.writeFile(stage2EntryPath, stage2Entry);
@@ -3265,6 +3266,45 @@ export default async function(context = {}) {
   return { ...result, httpHandler: httpSource ? httpSource.httpHandler : undefined };
 }`;
 }
+function readObserveConnect(flowSettings, logger) {
+  const observe = flowSettings.config?.observe;
+  if (!observe) return void 0;
+  const { url, binding, level, sample } = observe;
+  if (url === void 0 && binding === void 0) return void 0;
+  const trimmedUrl = typeof url === "string" ? url.trim() : "";
+  const trimmedBinding = typeof binding === "string" ? binding.trim() : "";
+  if (trimmedUrl !== "" && trimmedBinding !== "") {
+    return {
+      url: trimmedUrl,
+      binding: trimmedBinding,
+      // Same JSON-borne prudence as the pair: only known-shaped public
+      // values reach the emitted literal.
+      ...level === "off" || level === "standard" || level === "trace" ? { level } : {},
+      // Sample is a fraction in [0, 1] per the Flow.Observe contract; the
+      // range test also drops NaN and the infinities.
+      ...typeof sample === "number" && sample >= 0 && sample <= 1 ? { sample } : {}
+    };
+  }
+  const missing = [
+    ...trimmedUrl === "" ? ["url"] : [],
+    ...trimmedBinding === "" ? ["binding"] : []
+  ].join(" and ");
+  logger?.warn(
+    `config.observe has no effect: missing or empty ${missing}. Observe connect wiring was skipped; set both config.observe.url and config.observe.binding to non-empty public values.`
+  );
+  return void 0;
+}
+function emitObserveAssignment(observe) {
+  const literal = {
+    url: observe.url,
+    binding: observe.binding,
+    ...observe.flowId !== void 0 ? { flowId: observe.flowId } : {},
+    ...observe.level !== void 0 ? { level: observe.level } : {},
+    ...observe.sample !== void 0 ? { sample: observe.sample } : {}
+  };
+  return `
+  config.observe = ${JSON.stringify(literal)};`;
+}
 function generateWebEntry(stage1Path, dataPayload, options = {}) {
   const assignments = [];
   if (options.windowCollector) {
@@ -3285,30 +3325,14 @@ function generateWebEntry(stage1Path, dataPayload, options = {}) {
     }
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
-  const telemetryImport = options.telemetry ? `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto } from '@walkeros/core';` : "";
-  const telemetryBlock = options.telemetry ? `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    const __observer = __cto(__emit, {
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-      sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-    });
-    collector.observers.add(__observer);
-    collector.observeLevel = function () { return ${JSON.stringify(options.telemetry.level ?? "standard")}; };
-  }` : "";
-  return `import { startFlow, wireConfig } from '${stage1Specifier}';${telemetryImport}
+  const observeBlock = options.observe ? emitObserveAssignment(options.observe) : "";
+  return `import { startFlow, wireConfig } from '${stage1Specifier}';
 
 const __configData = ${dataPayload};
 
 (async () => {
-  const config = wireConfig(__configData);${envBlock}
-  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
+  const config = wireConfig(__configData);${envBlock}${observeBlock}
+  const { collector, elb } = await startFlow(config);${assignmentCode}
 })();`;
 }
 function generateWrapEntry(stage1Path, options = {}) {
@@ -3376,92 +3400,12 @@ ${grantTargets.map((key) => {
     }
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
-  const hasPoll = !!options.telemetry?.traceUrl;
-  const telemetryImport = options.telemetry ? hasPoll ? `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto, resolveTelemetryOptions as __cto_resolve } from '@walkeros/core';` : `
-import { createBatchedPoster as __cbp, createTelemetryObserver as __cto } from '@walkeros/core';` : "";
-  const telemetryPoller = options.telemetry && hasPoll ? `
-let __traceUntil = null;
-let __tracePollInFlight = false;
-function __pollTrace() {
-  if (typeof fetch === 'undefined' || __tracePollInFlight) return;
-  __tracePollInFlight = true;
-  // Bound each poll so a stalled trace endpoint can't pin the in-flight guard
-  // forever (and stack concurrent fetches via setInterval).
-  var __ctrl = typeof AbortController !== 'undefined' ? new AbortController() : null;
-  var __t = __ctrl ? setTimeout(function () { __ctrl.abort(); }, 10000) : null;
-  fetch(${JSON.stringify(options.telemetry.traceUrl)}, {
-    headers: { Authorization: ${JSON.stringify(`Bearer ${options.telemetry.ingestToken}`)} },
-    signal: __ctrl ? __ctrl.signal : undefined,
-  })
-    .then(function (__res) {
-      if (!__res || __res.status !== 200) return;
-      return __res.json().then(function (__body) {
-        if (!__body || typeof __body !== 'object') return;
-        var __value = __body.traceUntil;
-        // Mirror the server poller: set on a non-empty string, clear on null,
-        // leave unchanged on anything else. The null path is the disable case
-        // (stop a trace early) and MUST be honored so web deployments can be
-        // turned off without waiting for the old timestamp to lapse.
-        if (typeof __value === 'string' && __value.length > 0) {
-          __traceUntil = __value;
-        } else if (__value === null) {
-          __traceUntil = null;
-        }
-      });
-    })
-    .catch(function () {})
-    .finally(function () {
-      if (__t) clearTimeout(__t);
-      __tracePollInFlight = false;
-    });
-}
-` : "";
-  const telemetryBlock = options.telemetry ? hasPoll ? `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    // Single resolver drives both the observer projection and observeLevel so
-    // the reported level can never drift from what the observer emits.
-    const __resolveTelemetry = () => __cto_resolve({
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      observe: {
-        level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-        sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-      },
-      traceUntil: __traceUntil,
-    });
-    const __observer = __cto(__emit, __resolveTelemetry);
-    collector.observers.add(__observer);
-    collector.observeLevel = function () {
-      const __opts = __resolveTelemetry();
-      return __opts ? __opts.level : 'off';
-    };
-    __pollTrace();
-    setInterval(__pollTrace, 15000 + Math.floor(Math.random() * 5000));
-  }` : `
-  // --- Telemetry wiring ---
-  {
-    const __emit = __cbp({
-      url: ${JSON.stringify(options.telemetry.observerUrl)},
-      token: ${JSON.stringify(options.telemetry.ingestToken)},
-    });
-    const __observer = __cto(__emit, {
-      flowId: ${JSON.stringify(options.telemetry.flowId)},
-      level: ${JSON.stringify(options.telemetry.level ?? "standard")},
-      sample: ${JSON.stringify(options.telemetry.sample ?? 1)},
-    });
-    collector.observers.add(__observer);
-    collector.observeLevel = function () { return ${JSON.stringify(options.telemetry.level ?? "standard")}; };
-  }` : "";
-  return `${previewImport}import { startFlow, wireConfig, __configData } from '${stage1Specifier}';${telemetryImport}
-${telemetryPoller}
+  const observeBlock = options.observe ? emitObserveAssignment(options.observe) : "";
+  return `${previewImport}import { startFlow, wireConfig, __configData } from '${stage1Specifier}';
+
 (async () => {${previewBlock}
-  const config = wireConfig(__configData);${envBlock}${previewGrantBlock}
-  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
+  const config = wireConfig(__configData);${envBlock}${previewGrantBlock}${observeBlock}
+  const { collector, elb } = await startFlow(config);${assignmentCode}
 })();`;
 }
 function singleQuoteLiteral(value) {
@@ -8305,7 +8249,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.3.0";
+var CLIENT_HEADER = "walkeros-cli/4.3.1";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path20, flowConfig) {
   const flows = flowConfig.flows;
@@ -8870,8 +8814,8 @@ import createClient from "openapi-fetch";
 init_config_file();
 import { createHash } from "crypto";
 import semver4 from "semver";
-var bakedContractVersion = true ? "3.1.0" : PLACEHOLDER;
-var bakedContractHash = true ? "d3753dd02864fc19892f74a6a9afddb2081fc7a3f249991a681ae6c5540be650" : "";
+var bakedContractVersion = true ? "4.0.0" : PLACEHOLDER;
+var bakedContractHash = true ? "79c9e2d3bd2a72f1a95ba52742c4acdfe446c3835d5d169654f94e95da0e545e" : "";
 function isRecord3(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -10195,23 +10139,13 @@ async function wrapSkeleton(options) {
   const absoluteSkeletonPath = path19.resolve(skeletonPath);
   const skeletonText = await fs18.readFile(absoluteSkeletonPath, "utf-8");
   const devExternals = extractDevExternals(skeletonText);
-  const tInput = options.telemetry;
-  const tLevel = tInput?.level ?? "standard";
-  const telemetry = tInput ? {
-    observerUrl: tInput.observerUrl,
-    ingestToken: tInput.ingestToken,
-    flowId: tInput.flowId,
-    level: tLevel,
-    ...tInput.traceUrl !== void 0 ? { traceUrl: tInput.traceUrl } : {},
-    ...tInput.sample !== void 0 ? { sample: tInput.sample } : {}
-  } : void 0;
   const entryText = platform === "browser" ? generateWrapEntry(absoluteSkeletonPath, {
     ...windowCollector ? { windowCollector } : {},
     ...windowElb ? { windowElb } : {},
     ...options.preview ? { preview: options.preview } : {},
     ...options.previewGrantTargets ? { previewGrantTargets: options.previewGrantTargets } : {},
     platform,
-    ...telemetry ? { telemetry } : {}
+    ...options.observe ? { observe: options.observe } : {}
   }) : generateWrapEntryServer(absoluteSkeletonPath);
   const entryDir = await fs18.mkdtemp(path19.join(os3.tmpdir(), "walkeros-wrap-"));
   const entryPath = path19.join(entryDir, "flow.mjs");
@@ -10224,7 +10158,7 @@ async function wrapSkeleton(options) {
       format: "esm",
       platform,
       outfile: outputPath,
-      // Resolve `@walkeros/core` (used by the telemetry block) from the CLI
+      // Resolve `@walkeros/core` (used by the preview activator) from the CLI
       // package's own dependency tree and the workspace root. Without this,
       // esbuild looks under the temp entryDir which has no node_modules.
       // The wrap step always runs from inside the CLI process; both the