@walkeros/cli 4.1.1-next-1779485810490 → 4.1.1

package/dist/index.d.ts

@@ -729,6 +729,8 @@ interface ProjectsCommandOptions extends GlobalOptions {
     output?: string;
     project?: string;
     name?: string;
+    cursor?: string;
+    limit?: number;
 }
 declare function listProjectsCommand(options: ProjectsCommandOptions): Promise<void>;
 declare function getProjectCommand(projectId: string | undefined, options: ProjectsCommandOptions): Promise<void>;
@@ -4791,7 +4793,7 @@ interface components {
       total: number;
       limit: number;
       offset: number;
-      nextCursor?: string | null;
+      nextCursor: string | null;
     };
     UpdateDeploymentResponse: {
       /** @example dep_a1b2c3d4 */
@@ -5419,6 +5421,8 @@ declare function listFlowsCommand(options: FlowsCommandOptions & {
     sort?: string;
     order?: string;
     includeDeleted?: boolean;
+    cursor?: string;
+    limit?: number;
 }): Promise<void>;
 declare function getFlowCommand(flowId: string, options: FlowsCommandOptions): Promise<void>;
 declare function createFlowCommand(name: string, options: FlowsCommandOptions & {
@@ -5523,6 +5527,8 @@ interface DeploymentsCommandOptions extends GlobalOptions {
     type?: string;
     status?: string;
     label?: string;
+    cursor?: string;
+    limit?: number;
 }
 declare function listDeploymentsCommand(options: DeploymentsCommandOptions): Promise<void>;
 declare function getDeploymentBySlugCommand(slug: string, options: DeploymentsCommandOptions): Promise<void>;
@@ -5602,6 +5608,16 @@ interface WrapSkeletonOptions {
     previewOrigin?: string;
     /** Browser-only: project scope for preview URL isolation. */
     previewScope?: 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.
+     */
+    telemetry?: TelemetryBundleOptions;
     /**
      * esbuild target. @default 'es2018' for browser, 'node18' for node.
      */
@@ -5611,6 +5627,18 @@ interface WrapSkeletonOptions {
     /** Fine-grained minification options, forwarded to esbuild. */
     minifyOptions?: MinifyOptions;
 }
+interface TelemetryBundleOptions {
+    /** Absolute ingest URL. POST receives JSON array of FlowState. */
+    observerUrl: string;
+    /** Deployment-scoped plaintext token. Sent as `Authorization: Bearer`. */
+    ingestToken: string;
+    /** Used as the `flowId` on every emitted FlowState. */
+    flowId: string;
+    /** Verbosity. Default 'standard'. 'off' suppresses the entire wiring. */
+    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

@@ -2895,6 +2895,16 @@ export default async function(context = {}) {
 
   const result = await startFlow(config);
 
+  // Telemetry observer installation: the host (pipeline.ts) builds the
+  // observer functions via createTelemetryObserver + createBatchedPoster
+  // and forwards them through context. Added to collector.observers so the
+  // runtime self-emission loop drives them.
+  if (context.observers) {
+    for (const observer of context.observers) {
+      result.collector.observers.add(observer);
+    }
+  }
+
   const httpSource = Object.values(result.collector.sources || {})
     .find(s => 'httpHandler' in s && typeof s.httpHandler === 'function');
 
@@ -2926,13 +2936,29 @@ function generateWebEntry(stage1Path, dataPayload, options = {}) {
     }
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
-  return `import { startFlow, wireConfig } from '${stage1Specifier}';
+  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);
+  }` : "";
+  return `import { startFlow, wireConfig } from '${stage1Specifier}';${telemetryImport}
 
 const __configData = ${dataPayload};
 
 (async () => {
   const config = wireConfig(__configData);${envBlock}
-  const { collector, elb } = await startFlow(config);${assignmentCode}
+  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
 })();`;
 }
 function generateWrapEntry(stage1Path, options = {}) {
@@ -3014,11 +3040,27 @@ function generateWrapEntry(stage1Path, options = {}) {
     }
   }` : "";
   const stage1Specifier = toFileImportSpecifier(stage1Path);
-  return `import { startFlow, wireConfig, __configData } from '${stage1Specifier}';
+  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);
+  }` : "";
+  return `import { startFlow, wireConfig, __configData } from '${stage1Specifier}';${telemetryImport}
 
 (async () => {${preflightBlock}
   const config = wireConfig(__configData);${envBlock}
-  const { collector, elb } = await startFlow(config);${assignmentCode}
+  const { collector, elb } = await startFlow(config);${telemetryBlock}${assignmentCode}
 })();`;
 }
 function generateWrapEntryServer(stage1Path) {
@@ -3040,6 +3082,16 @@ export default async function(context = {}) {
 
   const result = await startFlow(config);
 
+  // Telemetry observer installation: the host (pipeline.ts) builds the
+  // observer functions via createTelemetryObserver + createBatchedPoster
+  // and forwards them through context. Added to collector.observers so the
+  // runtime self-emission loop drives them.
+  if (context.observers) {
+    for (const observer of context.observers) {
+      result.collector.observers.add(observer);
+    }
+  }
+
   const httpSource = Object.values(result.collector.sources || {})
     .find(s => 'httpHandler' in s && typeof s.httpHandler === 'function');
 
@@ -5223,6 +5275,11 @@ init_utils3();
 init_tmp();
 import { writeFileSync as writeFileSync4 } from "fs";
 import fs17 from "fs-extra";
+import {
+  createBatchedPoster,
+  createTelemetryObserver,
+  resolveTelemetryOptions
+} from "@walkeros/core";
 
 // src/runtime/health-server.ts
 import http from "http";
@@ -5298,14 +5355,15 @@ async function loadBundle(file, context2, logger) {
 }
 
 // src/runtime/runner.ts
-async function loadFlow(file, config, logger, loggerConfig, healthServer) {
+async function loadFlow(file, config, logger, loggerConfig, healthServer, observers) {
   const absolutePath = resolve3(file);
   const flowDir = dirname4(absolutePath);
   process.chdir(flowDir);
   const flowContext = {
     ...config,
     ...loggerConfig ? { logger: loggerConfig } : {},
-    ...healthServer ? { sourceSettings: { port: void 0 } } : {}
+    ...healthServer ? { sourceSettings: { port: void 0 } } : {},
+    ...observers ? { observers } : {}
   };
   const result = await loadBundle(absolutePath, flowContext, logger);
   if (healthServer && typeof result.httpHandler === "function") {
@@ -5320,7 +5378,7 @@ async function loadFlow(file, config, logger, loggerConfig, healthServer) {
     httpHandler: result.httpHandler
   };
 }
-async function swapFlow(currentHandle, newFile, config, logger, loggerConfig, healthServer) {
+async function swapFlow(currentHandle, newFile, config, logger, loggerConfig, healthServer, observers) {
   logger.info("Shutting down current flow for hot-swap...");
   if (healthServer) {
     healthServer.setFlowHandler(null);
@@ -5337,7 +5395,8 @@ async function swapFlow(currentHandle, newFile, config, logger, loggerConfig, he
     config,
     logger,
     loggerConfig,
-    healthServer
+    healthServer,
+    observers
   );
   logger.info("Flow swapped successfully");
   return newHandle;
@@ -5407,6 +5466,24 @@ var instanceId = randomBytes(8).toString("hex");
 function getInstanceId() {
   return instanceId;
 }
+async function applyTraceUntilFromResponse(response, logger) {
+  let parsed;
+  try {
+    parsed = await response.json();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.debug(`Heartbeat response parse failed: ${message}`);
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null) return;
+  if (!("traceUntil" in parsed)) return;
+  const value = parsed.traceUntil;
+  if (typeof value === "string" && value.length > 0) {
+    process.env.WALKEROS_TRACE_UNTIL = value;
+  } else if (value === null) {
+    delete process.env.WALKEROS_TRACE_UNTIL;
+  }
+}
 function createHeartbeat(config, logger) {
   let timer = null;
   const startTime = Date.now();
@@ -5455,6 +5532,9 @@ function createHeartbeat(config, logger) {
       if (response.ok && counters && current) {
         lastReported = current;
       }
+      if (response.ok) {
+        await applyTraceUntilFromResponse(response, logger);
+      }
       if (response.status === 401 || response.status === 403) {
         logger.error(
           `Heartbeat auth failed (${response.status}). Token may have expired \u2014 redeploy to rotate.`
@@ -5556,6 +5636,7 @@ async function runPipeline(options) {
   logger.info(`walkeros/flow v${VERSION}`);
   logger.info(`Instance: ${getInstanceId()}`);
   const healthServer = await createHealthServer(port, logger);
+  const telemetryObservers = buildTelemetryObservers(api?.flowId ?? "flow");
   const runtimeConfig = { port };
   let handle;
   try {
@@ -5564,7 +5645,8 @@ async function runPipeline(options) {
       runtimeConfig,
       logger,
       loggerConfig,
-      healthServer
+      healthServer,
+      telemetryObservers
     );
   } catch (error) {
     await healthServer.close();
@@ -5630,7 +5712,8 @@ async function runPipeline(options) {
             runtimeConfig,
             logger,
             loggerConfig,
-            healthServer
+            healthServer,
+            telemetryObservers
           );
           writeCache(
             api.cacheDir,
@@ -5689,6 +5772,15 @@ async function runPipeline(options) {
   await new Promise(() => {
   });
 }
+function buildTelemetryObservers(flowId) {
+  const url = process.env.WALKEROS_OBSERVER_URL;
+  const token = process.env.WALKEROS_INGEST_TOKEN;
+  if (!url || !token) return void 0;
+  const emit = createBatchedPoster({ url, token });
+  return [
+    createTelemetryObserver(emit, () => resolveTelemetryOptions({ flowId }))
+  ];
+}
 async function injectSecrets(api, logger) {
   try {
     const secrets = await fetchSecrets({
@@ -6582,7 +6674,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.1.1-next-1779485810490";
+var CLIENT_HEADER = "walkeros-cli/4.1.1";
 var SECTIONS = ["destinations", "sources", "transformers"];
 function resolveEntry(path20, flowConfig) {
   const flows = flowConfig.flows;
@@ -7291,7 +7383,10 @@ async function handleResult(fn, options) {
   }
 }
 async function listProjectsCommand(options) {
-  await handleResult(() => listProjects(), options);
+  await handleResult(
+    () => listProjects({ cursor: options.cursor, limit: options.limit }),
+    options
+  );
 }
 async function getProjectCommand(projectId, options) {
   await handleResult(
@@ -7441,7 +7536,9 @@ async function listFlowsCommand(options) {
       projectId: options.project,
       sort: options.sort,
       order: options.order,
-      includeDeleted: options.includeDeleted
+      includeDeleted: options.includeDeleted,
+      cursor: options.cursor,
+      limit: options.limit
     }),
     options
   );
@@ -7842,7 +7939,9 @@ async function listDeploymentsCommand(options) {
     () => listDeployments({
       projectId: options.project,
       type: options.type,
-      status: options.status
+      status: options.status,
+      cursor: options.cursor,
+      limit: options.limit
     }),
     options
   );
@@ -8091,8 +8190,22 @@ init_bundle();
 init_bundler();
 import * as path19 from "path";
 import * as os3 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import fs18 from "fs-extra";
 import * as esbuild2 from "esbuild";
+function getNodeResolutionPaths() {
+  const here = path19.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [];
+  let dir = here;
+  for (let i = 0; i < 8; i++) {
+    const candidate = path19.join(dir, "node_modules");
+    candidates.push(candidate);
+    const parent = path19.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return candidates;
+}
 async function wrapSkeleton(options) {
   const {
     skeletonPath,
@@ -8118,12 +8231,22 @@ async function wrapSkeleton(options) {
     throw new Error(`wrapSkeleton: skeleton not found at ${skeletonPath}`);
   }
   const absoluteSkeletonPath = path19.resolve(skeletonPath);
+  const tInput = options.telemetry;
+  const tLevel = tInput?.level ?? "standard";
+  const telemetry = tInput && tLevel !== "off" ? {
+    observerUrl: tInput.observerUrl,
+    ingestToken: tInput.ingestToken,
+    flowId: tInput.flowId,
+    level: tLevel,
+    ...tInput.sample !== void 0 ? { sample: tInput.sample } : {}
+  } : void 0;
   const entryText = platform === "browser" ? generateWrapEntry(absoluteSkeletonPath, {
     ...windowCollector ? { windowCollector } : {},
     ...windowElb ? { windowElb } : {},
     ...options.previewOrigin ? { previewOrigin: options.previewOrigin } : {},
     ...options.previewScope ? { previewScope: options.previewScope } : {},
-    platform
+    platform,
+    ...telemetry ? { telemetry } : {}
   }) : generateWrapEntryServer(absoluteSkeletonPath);
   const entryDir = await fs18.mkdtemp(path19.join(os3.tmpdir(), "walkeros-wrap-"));
   const entryPath = path19.join(entryDir, "flow.mjs");
@@ -8136,6 +8259,12 @@ async function wrapSkeleton(options) {
       format: "esm",
       platform,
       outfile: outputPath,
+      // Resolve `@walkeros/core` (used by the telemetry block) 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
+      // CLI's local node_modules and the workspace root are safe anchors.
+      nodePaths: getNodeResolutionPaths(),
       treeShaking: true,
       logLevel: "error",
       minify,