hobots 4.0.0 → 4.1.0

package/dist/index.d.cts

@@ -340,6 +340,18 @@ declare class Transaction {
     setTag(key: string, value: string): this;
     setStatus(status: string): this;
     setName(name: string): this;
+    /**
+     * Envia já as steps raiz finalizadas (e todas as descendentes, fechando as que
+     * ficaram abertas) como transactions parciais da mesma run (`op` hobots.run.flush,
+     * `event_id` novo, até 200 steps cada) e as tira da memória. Steps raiz ainda abertas
+     * ficam para o próximo flush ou para o `finish()`. É assim que um agente sempre
+     * ligado (`start()`), cuja run não termina, entrega as etapas enquanto processa.
+     * Devolve quantas steps foram enviadas.
+     */
+    flush(): number;
+    /** Entrega já (com teto) o que está na fila do transport — as transactions parciais inclusive. */
+    drain(timeoutMs: number): Promise<void>;
+    private payload;
     finish(): void;
 }
 
@@ -489,6 +501,14 @@ interface RunContext {
      * medir as etapas (steps); elas aparecem como waterfall na aba de performance da execução.
      */
     readonly transaction: Transaction;
+    /**
+     * Entrega já o que a execução fez: as steps raiz finalizadas viram transactions parciais
+     * (waterfall da Central sem esperar a run terminar) e itens, logs e progresso pendentes
+     * saem sem esperar o throttle. Quem decide quando chamar é o bot — num agente sempre
+     * ligado (`start()`), ao fim de cada rodada que processou itens. Aguarda a entrega com
+     * teto (`timeoutMs`, default 15s) e nunca lança.
+     */
+    flush(timeoutMs?: number): Promise<void>;
     /** Dispara em cancelamento (run cancelada no app), timeout ou shutdown — cancelamento cooperativo */
     readonly signal: AbortSignal;
     /**

package/dist/index.d.ts

@@ -340,6 +340,18 @@ declare class Transaction {
     setTag(key: string, value: string): this;
     setStatus(status: string): this;
     setName(name: string): this;
+    /**
+     * Envia já as steps raiz finalizadas (e todas as descendentes, fechando as que
+     * ficaram abertas) como transactions parciais da mesma run (`op` hobots.run.flush,
+     * `event_id` novo, até 200 steps cada) e as tira da memória. Steps raiz ainda abertas
+     * ficam para o próximo flush ou para o `finish()`. É assim que um agente sempre
+     * ligado (`start()`), cuja run não termina, entrega as etapas enquanto processa.
+     * Devolve quantas steps foram enviadas.
+     */
+    flush(): number;
+    /** Entrega já (com teto) o que está na fila do transport — as transactions parciais inclusive. */
+    drain(timeoutMs: number): Promise<void>;
+    private payload;
     finish(): void;
 }
 
@@ -489,6 +501,14 @@ interface RunContext {
      * medir as etapas (steps); elas aparecem como waterfall na aba de performance da execução.
      */
     readonly transaction: Transaction;
+    /**
+     * Entrega já o que a execução fez: as steps raiz finalizadas viram transactions parciais
+     * (waterfall da Central sem esperar a run terminar) e itens, logs e progresso pendentes
+     * saem sem esperar o throttle. Quem decide quando chamar é o bot — num agente sempre
+     * ligado (`start()`), ao fim de cada rodada que processou itens. Aguarda a entrega com
+     * teto (`timeoutMs`, default 15s) e nunca lança.
+     */
+    flush(timeoutMs?: number): Promise<void>;
     /** Dispara em cancelamento (run cancelada no app), timeout ou shutdown — cancelamento cooperativo */
     readonly signal: AbortSignal;
     /**

package/dist/index.js

@@ -1,6 +1,6 @@
 import {
   WIRE_LIMITS
-} from "./chunk-5WIIACWC.js";
+} from "./chunk-HKCDMUA3.js";
 
 // src/stacktrace.ts
 var MAX_FRAMES = 50;
@@ -57,7 +57,7 @@ function scrubSecrets(text) {
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "4.0.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "4.1.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -1348,7 +1348,6 @@ var MAX_CANCEL_CHECK_INTERVAL_MS = 15e3;
 var MAX_LOG_MESSAGE_CHARS = WIRE_LIMITS.MAX_LOG_MESSAGE_CHARS;
 var MAX_LOGS_PER_PATCH = WIRE_LIMITS.MAX_LOGS_PER_PATCH;
 var FLUSH_AT_BUFFERED = 20;
-var MAX_ITEMS_PER_RUN = WIRE_LIMITS.MAX_ITEMS_PER_RUN;
 var MAX_ITEMS_PER_REQUEST = WIRE_LIMITS.MAX_ITEMS_PER_REQUEST;
 var MAX_ITEM_MESSAGE_CHARS = WIRE_LIMITS.MAX_ITEM_MESSAGE_CHARS;
 var MAX_ITEM_PAYLOAD_BYTES = WIRE_LIMITS.MAX_ITEM_PAYLOAD_BYTES;
@@ -1370,6 +1369,7 @@ var RunReporter = class {
     this.api = api;
     this.runId = runId;
     this.logger = logger;
+    this.tx = tx;
     this.flushIntervalMs = flushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
     this.cancelCheckIntervalMs = Math.min(
       MAX_CANCEL_CHECK_INTERVAL_MS,
@@ -1453,6 +1453,7 @@ var RunReporter = class {
       items,
       progress,
       transaction: tx,
+      flush: (timeoutMs) => this.flush(timeoutMs),
       signal,
       throwIfCanceled: checkCanceled,
       sleep: sleep2,
@@ -1462,6 +1463,7 @@ var RunReporter = class {
   api;
   runId;
   logger;
+  tx;
   context;
   buffer = [];
   dead = false;
@@ -1479,7 +1481,6 @@ var RunReporter = class {
   itemsChain = Promise.resolve();
   itemsTimer;
   itemSeq = 0;
-  itemCount = 0;
   /** Servidor sem o recurso (404) — para de tentar (e de avisar) nesta run. */
   itemsUnsupported = false;
   /** Cap de itens por run atingido (client-side ou 429) — degrada com um aviso só. */
@@ -1602,6 +1603,21 @@ var RunReporter = class {
       this.enqueue({ status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) });
     }
   }
+  /**
+   * `hobots.flush()`: o bot decide quando entregar o que já fez — steps raiz finalizadas
+   * viram transactions parciais da run, e itens, logs e progresso pendentes saem já, sem
+   * esperar o throttle. Aguarda a entrega com teto. Nunca lança (pode ir num `finally`).
+   */
+  async flush(timeoutMs = ITEMS_DRAIN_MS) {
+    this.tx.flush();
+    this.flushItems();
+    if (this.progressDirty) this.flushProgress();
+    else this.flushLogs();
+    await Promise.race([
+      Promise.all([this.itemsChain, this.chain, this.tx.drain(timeoutMs)]).catch(() => void 0),
+      new Promise((resolve2) => unrefTimer(setTimeout(resolve2, timeoutMs)))
+    ]);
+  }
   /** Primeiro PATCH (claimed → running). Retorna false se a run já morreu (cancelada). */
   async reportRunning() {
     this.enqueue({ status: "running" });
@@ -1712,14 +1728,6 @@ var RunReporter = class {
    */
   addItem(status, message, payload, id, image3) {
     if (this.itemsClosed || this.itemsUnsupported) return;
-    if (this.itemCount >= MAX_ITEMS_PER_RUN) {
-      if (!this.itemsQuotaExceeded) {
-        this.itemsQuotaExceeded = true;
-        this.log("warning", `itens descartados: limite de ${MAX_ITEMS_PER_RUN} por execu\xE7\xE3o atingido`);
-      }
-      return;
-    }
-    this.itemCount++;
     let scrubbedPayload;
     if (payload) {
       scrubbedPayload = scrubPayloadValue(payload, 0);
@@ -2014,6 +2022,7 @@ function currentRunReporter() {
 }
 
 // src/transaction.ts
+var FLUSH_TRANSACTION_OP = "hobots.run.flush";
 var MAX_STEP_MESSAGE_CHARS = 2e3;
 function stepMessage(text) {
   return truncate(scrubSecrets(text), MAX_STEP_MESSAGE_CHARS);
@@ -2235,6 +2244,60 @@ var Transaction = class {
     this.name = name;
     return this;
   }
+  /**
+   * Envia já as steps raiz finalizadas (e todas as descendentes, fechando as que
+   * ficaram abertas) como transactions parciais da mesma run (`op` hobots.run.flush,
+   * `event_id` novo, até 200 steps cada) e as tira da memória. Steps raiz ainda abertas
+   * ficam para o próximo flush ou para o `finish()`. É assim que um agente sempre
+   * ligado (`start()`), cuja run não termina, entrega as etapas enquanto processa.
+   * Devolve quantas steps foram enviadas.
+   */
+  flush() {
+    if (this.finished) return 0;
+    const ready = /* @__PURE__ */ new Set();
+    for (const step of this.steps) {
+      if (step.parentStepId === this.stepId && step.endTimestamp) ready.add(step.stepId);
+    }
+    if (ready.size === 0) return 0;
+    const batch = [];
+    const remaining = [];
+    for (const step of this.steps) {
+      if (ready.has(step.stepId) || ready.has(step.parentStepId)) {
+        ready.add(step.stepId);
+        batch.push(step);
+      } else {
+        remaining.push(step);
+      }
+    }
+    for (const step of batch) step.finish();
+    this.steps.splice(0, this.steps.length, ...remaining);
+    if (this.client) {
+      for (let i = 0; i < batch.length; i += MAX_STEPS) {
+        const chunk = batch.slice(i, i + MAX_STEPS);
+        const startTimestamp = chunk.reduce((min, step) => step.startTimestamp < min ? step.startTimestamp : min, chunk[0].startTimestamp);
+        const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
+        this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, startTimestamp, nowISO(), chunk));
+      }
+    }
+    return batch.length;
+  }
+  /** Entrega já (com teto) o que está na fila do transport — as transactions parciais inclusive. */
+  async drain(timeoutMs) {
+    await this.client?.flush(timeoutMs);
+  }
+  payload(eventId, op, status, startTimestamp, timestamp, steps) {
+    return {
+      event_id: eventId,
+      name: this.name,
+      op,
+      status,
+      start_timestamp: startTimestamp,
+      timestamp,
+      steps: steps.map((step) => step.toJSON()),
+      tags: Object.keys(this.tags).length > 0 ? { ...this.tags } : void 0,
+      run_id: this.runId
+    };
+  }
   finish() {
     if (this.finished) return;
     this.finished = true;
@@ -2249,18 +2312,15 @@ var Transaction = class {
       this.status
     );
     if (!this.client) return;
-    const payload = {
-      event_id: this.eventId,
-      name: this.name,
-      op: this.op,
-      status: this.status,
-      start_timestamp: this.startTimestamp,
-      timestamp: endTimestamp,
-      steps: this.steps.map((step) => step.toJSON()),
-      tags: Object.keys(this.tags).length > 0 ? this.tags : void 0,
-      run_id: this.runId
-    };
-    this.client.sendTransaction(payload);
+    const steps = this.steps;
+    let first = 0;
+    while (steps.length - first > MAX_STEPS) {
+      const chunk = steps.slice(first, first + MAX_STEPS);
+      const status = chunk.some((step) => step.status === "error") ? "error" : "ok";
+      this.client.sendTransaction(this.payload(uuid4(), FLUSH_TRANSACTION_OP, status, chunk[0].startTimestamp, endTimestamp, chunk));
+      first += MAX_STEPS;
+    }
+    this.client.sendTransaction(this.payload(this.eventId, this.op, this.status, this.startTimestamp, endTimestamp, steps.slice(first)));
   }
 };
 
@@ -2965,6 +3025,7 @@ var hobots = Object.defineProperties({}, {
   signal: getter("signal", () => neverAborts),
   throwIfCanceled: method(() => resolve("throwIfCanceled")?.throwIfCanceled()),
   sleep: method((ms) => resolve("sleep")?.sleep(ms) ?? sleep(ms)),
+  flush: method((timeoutMs) => resolve("flush")?.flush(timeoutMs) ?? Promise.resolve()),
   retry: method((fn, options) => {
     const reporter = currentReporter();
     return reporter ? reporter.context.retry(fn, options) : retryWithBackoff(fn, options);