hobots 1.5.0 → 1.6.0

package/dist/index.d.ts

@@ -52,11 +52,14 @@ interface Logger {
 }
 
 declare class Client {
-    readonly options: InitOptions;
-    readonly config: ResolvedConfig;
+    #private;
     readonly logger: Logger;
     private readonly transport;
     constructor(options: InitOptions);
+    get options(): InitOptions;
+    get config(): ResolvedConfig;
+    /** Serialização explícita nunca inclui o secret. */
+    toJSON(): Record<string, unknown>;
     captureException(error: unknown, hint: CaptureHint | undefined, scope: Scope): string;
     captureMessage(message: string, level: Severity, hint: CaptureHint | undefined, scope: Scope): string;
     captureEvent(event: EventPayload, hint: CaptureHint | undefined, scope: Scope): string;
@@ -159,6 +162,7 @@ interface RunLogger {
     info(message: string): void;
     warn(message: string): void;
     error(message: string): void;
+    success(message: string): void;
 }
 interface RunContext {
     runId: string;
@@ -286,6 +290,8 @@ declare function stop(timeoutMs?: number): Promise<boolean>;
  */
 declare function close(timeoutMs?: number): Promise<boolean>;
 
+declare function scrubSecrets(text: string): string;
+
 /**
  * Loop de polling do Manager: busca runs pendentes, executa os handlers registrados
  * e reporta status/logs/result. Ao contrário do Monitor, o timer de polling NÃO é
@@ -350,6 +356,8 @@ declare class ManagerApi {
     private headers;
     /** Um request só — o loop de polling é quem decide o backoff entre tentativas. */
     poll(request: ManagerPollRequest, signal?: AbortSignal): Promise<ManagerPollResponse>;
+    /** Nunca confia no shape da resposta: runs malformadas são descartadas e o `max` é respeitado. */
+    private parsePollResponse;
     /**
      * PATCH de status/logs com retry em falha de rede/5xx/429.
      * 4xx é definitivo e vira ManagerApiError imediato (409 = run cancelada/transição inválida).
@@ -363,4 +371,4 @@ declare class ManagerApi {
     updateRunOnce(runId: string, update: ManagerRunUpdateRequest, timeoutMs?: number): Promise<void>;
 }
 
-export { Breadcrumb, type BreadcrumbInput, type CaptureHint, type CheckInOptions, CheckInPayload, CheckInStatus, Client, DEFAULT_BASE_URL, EventPayload, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, ManagerAgent, ManagerApi, ManagerApiError, type ManagerOptions, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest, type ManagerTaskHandler, type ResolvedConfig, type RunContext, Scope, Severity, Span, SpanData, Transaction, TransactionPayload, type WithMonitorOptions, addBreadcrumb, captureException, captureMessage, checkIn, close, flush, getClient, init, register, resolveConfig, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withMonitor, withScope };
+export { Breadcrumb, type BreadcrumbInput, type CaptureHint, type CheckInOptions, CheckInPayload, CheckInStatus, Client, DEFAULT_BASE_URL, EventPayload, EventUser, type HeartbeatOptions, HeartbeatPayload, type InitOptions, ManagerAgent, ManagerApi, ManagerApiError, type ManagerOptions, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest, type ManagerTaskHandler, type ResolvedConfig, type RunContext, Scope, Severity, Span, SpanData, Transaction, TransactionPayload, type WithMonitorOptions, addBreadcrumb, captureException, captureMessage, checkIn, close, flush, getClient, init, register, resolveConfig, scrubSecrets, setContext, setExtra, setTag, setTags, setUser, start, startTransaction, stop, withMonitor, withScope };

package/dist/index.js

@@ -1,20 +1,46 @@
 // src/config.ts
 var DEFAULT_BASE_URL = "https://api2.hobots.app";
+var SECRET_PATTERN = /^(hb_)?[a-f0-9]{64}$/i;
 function envBaseUrl() {
   if (typeof process === "undefined" || !process.env) return void 0;
   return process.env.HOBOTS_API_URL?.trim() || void 0;
 }
+function isLoopbackHost(hostname2) {
+  return hostname2 === "localhost" || hostname2.endsWith(".localhost") || hostname2.startsWith("127.") || hostname2 === "[::1]" || hostname2 === "::1" || hostname2 === "0.0.0.0";
+}
+var warnedInsecureBaseUrl = false;
+function validateBaseUrl(raw, prefix) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new Error(`${prefix} HOBOTS_API_URL inv\xE1lida \u2014 esperado URL http(s), ex.: http://localhost:3001`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`${prefix} HOBOTS_API_URL com esquema "${url.protocol}" n\xE3o suportado \u2014 use http(s)`);
+  }
+  if (url.username || url.password) {
+    throw new Error(`${prefix} HOBOTS_API_URL n\xE3o pode conter credenciais na URL \u2014 a autentica\xE7\xE3o \xE9 s\xF3 pelo Client Secret`);
+  }
+  if (url.protocol === "http:" && !isLoopbackHost(url.hostname) && !warnedInsecureBaseUrl) {
+    warnedInsecureBaseUrl = true;
+    console.warn(
+      `${prefix} HOBOTS_API_URL usa http para o host remoto "${url.hostname}" \u2014 o Client Secret trafega sem TLS`
+    );
+  }
+  return raw.replace(/\/+$/, "");
+}
 function resolveConfig(options, prefix = "[hobots]") {
   const key = options.clientSecret?.trim();
   if (!key) {
     throw new Error(`${prefix} clientSecret ausente \u2014 copie o Client Secret do projeto em Configura\xE7\xF5es \u2192 Projetos`);
   }
-  const baseUrl = (envBaseUrl() ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-  try {
-    new URL(baseUrl);
-  } catch {
-    throw new Error(`${prefix} HOBOTS_API_URL inv\xE1lida: "${baseUrl}" \u2014 esperado ex.: http://localhost:3001`);
+  if (!SECRET_PATTERN.test(key)) {
+    throw new Error(
+      `${prefix} clientSecret com formato inv\xE1lido (${key.length} caracteres) \u2014 esperado "hb_" + 64 hex; copie o Client Secret do projeto em Configura\xE7\xF5es \u2192 Projetos`
+    );
   }
+  const baseUrl = validateBaseUrl(envBaseUrl() ?? DEFAULT_BASE_URL, prefix);
   return {
     key,
     baseUrl,
@@ -56,9 +82,28 @@ function parseStacktrace(stack) {
   return frames;
 }
 
+// src/scrub.ts
+var SECRET_PATTERNS = [
+  // client secret da Hobots
+  [/hb_[a-f0-9]{16,}/gi, "[REDACTED]"],
+  // tokens bearer em headers/mensagens
+  [/\b(authorization:?\s*)?bearer\s+[a-z0-9._~+/=-]{8,}/gi, "Bearer [REDACTED]"],
+  // chaves no formato sk-… (OpenAI e afins)
+  [/\bsk-[a-z0-9_-]{16,}\b/gi, "[REDACTED]"],
+  // credenciais embutidas em URL (https://user:pass@host)
+  [/\/\/[^/\s:@]+:[^/\s@]+@/g, "//[REDACTED]@"]
+];
+function scrubSecrets(text) {
+  let out = text;
+  for (const [pattern, replacement] of SECRET_PATTERNS) {
+    out = out.replace(pattern, replacement);
+  }
+  return out;
+}
+
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "1.5.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "1.6.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -67,6 +112,12 @@ function uuid4() {
   if (cryptoRef && typeof cryptoRef.randomUUID === "function") {
     return cryptoRef.randomUUID().replace(/-/g, "");
   }
+  if (cryptoRef && typeof cryptoRef.getRandomValues === "function") {
+    const bytes = cryptoRef.getRandomValues(new Uint8Array(16));
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
   let out = "";
   for (let i = 0; i < 32; i++) {
     out += Math.floor(Math.random() * 16).toString(16);
@@ -85,7 +136,42 @@ function sleep(ms) {
     unrefTimer(timer);
   });
 }
-var PREFIX = "[hobots-monitor]";
+function jitter(baseMs) {
+  return Math.floor(baseMs / 2 + Math.random() * (baseMs / 2));
+}
+var MAX_RETRY_AFTER_MS = 6e4;
+function retryAfterMs(response) {
+  const header = response.headers.get("retry-after");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  if (Number.isFinite(seconds)) {
+    return Math.min(MAX_RETRY_AFTER_MS, Math.max(0, seconds * 1e3));
+  }
+  const date = Date.parse(header);
+  if (Number.isNaN(date)) return void 0;
+  return Math.min(MAX_RETRY_AFTER_MS, Math.max(0, date - Date.now()));
+}
+function withTimeoutSignal(timeoutMs, external) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort(external?.reason);
+  if (external?.aborted) {
+    onAbort();
+  } else {
+    external?.addEventListener("abort", onAbort, { once: true });
+  }
+  const timer = setTimeout(() => {
+    controller.abort(Object.assign(new Error(`timeout ap\xF3s ${timeoutMs}ms`), { name: "TimeoutError" }));
+  }, timeoutMs);
+  unrefTimer(timer);
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+var PREFIX = "[hobots]";
 function makeLogger(enabled, prefix = PREFIX) {
   return {
     debug: (...args) => enabled && console.debug(colorize(prefix, "gray"), ...args),
@@ -98,7 +184,8 @@ var ANSI = {
   gray: "\x1B[90m",
   cyan: "\x1B[36m",
   yellow: "\x1B[33m",
-  red: "\x1B[31m"
+  red: "\x1B[31m",
+  green: "\x1B[32m"
 };
 function colorEnabled() {
   if (!isNode()) return false;
@@ -125,11 +212,11 @@ function eventFromException(error, level = "error") {
   let frames = [];
   if (error instanceof Error) {
     type = error.name || "Error";
-    value = error.message;
+    value = scrubSecrets(error.message);
     frames = parseStacktrace(error.stack);
   } else {
     type = "NonError";
-    value = safeString(error);
+    value = scrubSecrets(safeString(error));
   }
   return {
     event_id: uuid4(),
@@ -147,12 +234,13 @@ function eventFromMessage(message, level = "info") {
     event_id: uuid4(),
     timestamp: nowISO(),
     level,
-    message
+    message: scrubSecrets(message)
   };
 }
 
 // src/transport.ts
 var RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+var REQUEST_TIMEOUT_MS = 1e4;
 var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
 var DEFAULT_MAX_BATCH_SIZE = 10;
 var DEFAULT_MAX_QUEUE_SIZE = 200;
@@ -219,11 +307,13 @@ var Transport = class {
   }
   async sendWithRetry(envelope) {
     for (let attempt = 0; ; attempt++) {
+      let serverDelay;
       try {
         const response = await fetch(this.endpoint, {
           method: "POST",
           headers: { "content-type": "application/json", authorization: `Bearer ${this.key}` },
-          body: JSON.stringify(envelope)
+          body: JSON.stringify(envelope),
+          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
         });
         if (response.ok) {
           this.logger.debug(`envelope enviado (${envelope.items.length} itens)`);
@@ -233,13 +323,15 @@ var Transport = class {
           this.logger.error(`envelope rejeitado (HTTP ${response.status}), descartado`);
           return;
         }
+        if (response.status === 429) serverDelay = retryAfterMs(response);
         throw new Error(`HTTP ${response.status}`);
       } catch (error) {
-        const delay = RETRY_DELAYS_MS[attempt];
-        if (delay === void 0) {
+        const base = RETRY_DELAYS_MS[attempt];
+        if (base === void 0) {
           this.logger.error("envelope descartado ap\xF3s retries:", error);
           return;
         }
+        const delay = serverDelay ?? jitter(base);
         this.logger.warn(`falha no envio (${String(error)}), retry em ${delay}ms`);
         await sleep(delay);
       }
@@ -269,22 +361,38 @@ function runtimeContexts() {
   return { runtime: { name: "browser" } };
 }
 var Client = class {
-  options;
-  config;
   logger;
+  // campos privados + getters de protótipo: o clientSecret não aparece em
+  // JSON.stringify/serialização enumerável do Client (ex.: um objeto capturado
+  // que referencie o client), mas client.options/config seguem funcionando
+  #options;
+  #config;
   transport;
   constructor(options) {
-    this.options = options;
+    this.#options = options;
     this.logger = makeLogger(!!options.debug);
-    this.config = resolveConfig(options);
+    this.#config = resolveConfig(options);
     this.transport = new Transport({
-      endpoint: this.config.ingestEndpoint,
-      key: this.config.key,
+      endpoint: this.#config.ingestEndpoint,
+      key: this.#config.key,
       logger: this.logger,
       flushIntervalMs: options.flushIntervalMs,
       maxBatchSize: options.maxBatchSize
     });
   }
+  get options() {
+    return this.#options;
+  }
+  get config() {
+    return this.#config;
+  }
+  /** Serialização explícita nunca inclui o secret. */
+  toJSON() {
+    return { sdk: SDK_NAME, version: SDK_VERSION, baseUrl: this.#config.baseUrl };
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Client { baseUrl: '${this.#config.baseUrl}' }`;
+  }
   captureException(error, hint, scope2) {
     return this.captureEvent(eventFromException(error, hint?.level ?? "error"), hint, scope2);
   }
@@ -538,6 +646,15 @@ var Scope = class _Scope {
 function spanId() {
   return uuid4().slice(0, 16);
 }
+function printSpanLog(kind, phase, label, startTs, endTs) {
+  const durationMs = startTs && endTs ? new Date(endTs).getTime() - new Date(startTs).getTime() : void 0;
+  const tag = colorize(`[hobots:${kind}] ${phase.toUpperCase()}`, phase === "finish" ? "green" : "cyan");
+  const suffix = durationMs != null ? ` (${durationMs}ms)` : "";
+  console.log(`${tag} ${label}${suffix}`);
+}
+function spanLabel(op, description) {
+  return [op, description].filter(Boolean).join(" \u2014 ") || "(sem nome)";
+}
 var Span = class {
   constructor(transaction, parentSpanId, op, description) {
     this.transaction = transaction;
@@ -563,7 +680,9 @@ var Span = class {
     return this.transaction.createSpan(this.spanId, op, description);
   }
   finish() {
-    if (!this.endTimestamp) this.endTimestamp = nowISO();
+    if (this.endTimestamp) return;
+    this.endTimestamp = nowISO();
+    printSpanLog("span", "finish", spanLabel(this.op, this.description), this.startTimestamp, this.endTimestamp);
   }
   toJSON() {
     return {
@@ -585,6 +704,7 @@ var Transaction = class {
     this.op = op;
     this.sampled = sampled;
     this.runId = runId;
+    printSpanLog("transaction", "start", op ? `${name} (${op})` : name);
   }
   eventId = uuid4();
   spanId = spanId();
@@ -596,6 +716,7 @@ var Transaction = class {
   createSpan(parentSpanId, op, description) {
     const span = new Span(this, parentSpanId, op, description);
     this.spans.push(span);
+    printSpanLog("span", "start", spanLabel(op, description));
     return span;
   }
   /** Span direto da transaction. */
@@ -618,6 +739,14 @@ var Transaction = class {
     if (this.finished) return;
     this.finished = true;
     for (const span of this.spans) span.finish();
+    const endTimestamp = nowISO();
+    printSpanLog(
+      "transaction",
+      "finish",
+      this.op ? `${this.name} (${this.op})` : this.name,
+      this.startTimestamp,
+      endTimestamp
+    );
     if (!this.sampled || !this.client) return;
     const payload = {
       event_id: this.eventId,
@@ -625,7 +754,7 @@ var Transaction = class {
       op: this.op,
       status: this.status,
       start_timestamp: this.startTimestamp,
-      timestamp: nowISO(),
+      timestamp: endTimestamp,
       spans: this.spans.map((span) => span.toJSON()),
       tags: Object.keys(this.tags).length > 0 ? this.tags : void 0,
       run_id: this.runId
@@ -682,6 +811,8 @@ async function withMonitorImpl(client2, captureError, monitorSlug, fn, options)
 
 // src/manager/api.ts
 var RETRY_DELAYS_MS2 = [1e3, 4e3, 16e3];
+var POLL_TIMEOUT_MS = 3e4;
+var UPDATE_TIMEOUT_MS = 1e4;
 var ManagerApiError = class extends Error {
   constructor(message, status) {
     super(message);
@@ -706,16 +837,39 @@ var ManagerApi = class {
   }
   /** Um request só — o loop de polling é quem decide o backoff entre tentativas. */
   async poll(request, signal) {
-    const response = await fetch(`${this.baseUrl}/poll`, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify(request),
-      signal
-    });
+    const { signal: timeoutSignal, cleanup } = withTimeoutSignal(POLL_TIMEOUT_MS, signal);
+    let response;
+    try {
+      response = await fetch(`${this.baseUrl}/poll`, {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(request),
+        signal: timeoutSignal
+      });
+    } finally {
+      cleanup();
+    }
     if (!response.ok) {
       throw new ManagerApiError(`poll falhou (HTTP ${response.status})`, response.status);
     }
-    return await response.json();
+    return this.parsePollResponse(await response.json(), request.max ?? 1);
+  }
+  /** Nunca confia no shape da resposta: runs malformadas são descartadas e o `max` é respeitado. */
+  parsePollResponse(body, max) {
+    const runs = body?.runs;
+    if (!Array.isArray(runs)) {
+      throw new ManagerApiError("resposta inv\xE1lida do poll (campo runs ausente)", 0);
+    }
+    const valid = [];
+    for (const run of runs.slice(0, Math.max(0, max))) {
+      if (typeof run?.id !== "string" || typeof run.task !== "string") continue;
+      const params = run.params && typeof run.params === "object" && !Array.isArray(run.params) ? run.params : {};
+      valid.push({ ...run, id: run.id, task: run.task, params });
+    }
+    if (valid.length < runs.length) {
+      this.logger.warn(`poll retornou ${runs.length - valid.length} run(s) inv\xE1lida(s)/excedente(s) \u2014 descartadas`);
+    }
+    return { runs: valid };
   }
   /**
    * PATCH de status/logs com retry em falha de rede/5xx/429.
@@ -724,25 +878,29 @@ var ManagerApi = class {
   async updateRun(runId, update) {
     for (let attempt = 0; ; attempt++) {
       let retriable;
+      let serverDelay;
       try {
         const response = await fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
           method: "PATCH",
           headers: this.headers(),
-          body: JSON.stringify(update)
+          body: JSON.stringify(update),
+          signal: AbortSignal.timeout(UPDATE_TIMEOUT_MS)
         });
         if (response.ok) return;
         if (response.status >= 400 && response.status < 500 && response.status !== 429) {
           throw new ManagerApiError(`update rejeitado (HTTP ${response.status})`, response.status);
         }
+        if (response.status === 429) serverDelay = retryAfterMs(response);
         retriable = new Error(`HTTP ${response.status}`);
       } catch (error) {
         if (error instanceof ManagerApiError) throw error;
         retriable = error;
       }
-      const delay = RETRY_DELAYS_MS2[attempt];
-      if (delay === void 0) {
+      const base = RETRY_DELAYS_MS2[attempt];
+      if (base === void 0) {
         throw new Error(`update da run ${runId} descartado ap\xF3s retries: ${String(retriable)}`);
       }
+      const delay = serverDelay ?? jitter(base);
       this.logger.warn(`falha no update da run ${runId} (${String(retriable)}), retry em ${delay}ms`);
       await sleep(delay);
     }
@@ -767,11 +925,12 @@ var LOG_LEVEL_COLOR = {
   debug: "gray",
   info: "cyan",
   warning: "yellow",
-  error: "red"
+  error: "red",
+  success: "green"
 };
 function printRunLog(task, level, message) {
   const line = colorize(`[hobots:${task}] ${level.toUpperCase()}`, LOG_LEVEL_COLOR[level]);
-  const method = level === "warning" ? "warn" : level;
+  const method = level === "warning" ? "warn" : level === "success" ? "info" : level;
   console[method](line, message);
 }
 function runCanceledError() {
@@ -816,7 +975,8 @@ var RunReporter = class {
       debug: (message) => this.log("debug", message),
       info: (message) => this.log("info", message),
       warn: (message) => this.log("warning", message),
-      error: (message) => this.log("error", message)
+      error: (message) => this.log("error", message),
+      success: (message) => this.log("success", message)
     };
     const signal = this.abortController.signal;
     this.context = {
@@ -864,13 +1024,14 @@ var RunReporter = class {
   }
   log(level, message) {
     if (this.dead) return;
-    printRunLog(this.context.task, level, message);
+    const scrubbed = scrubSecrets(message);
+    printRunLog(this.context.task, level, scrubbed);
     if (this.loggedCount >= MAX_LOGS_PER_RUN) {
       this.droppedCount++;
       return;
     }
     this.loggedCount++;
-    const truncated = message.length > MAX_LOG_MESSAGE_CHARS ? `${message.slice(0, MAX_LOG_MESSAGE_CHARS)}\u2026 [truncado]` : message;
+    const truncated = scrubbed.length > MAX_LOG_MESSAGE_CHARS ? `${scrubbed.slice(0, MAX_LOG_MESSAGE_CHARS)}\u2026 [truncado]` : scrubbed;
     this.buffer.push({ ts: nowISO(), level, message: truncated });
     if (this.buffer.length >= FLUSH_AT_BUFFERED) {
       this.flushLogs();
@@ -1054,8 +1215,8 @@ var ManagerAgent = class {
   constructor(options, registry2) {
     this.options = options;
     this.registry = registry2;
-    this.logger = makeLogger(options.debug ?? false, "[hobots-manager]");
-    const config = resolveConfig(options, "[hobots-manager]");
+    this.logger = makeLogger(options.debug ?? false, "[hobots]");
+    const config = resolveConfig(options, "[hobots]");
     this.api = new ManagerApi({ baseUrl: config.managerBaseUrl, key: config.key, logger: this.logger });
     this.client = options.client;
     this.pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
@@ -1089,10 +1250,10 @@ var ManagerAgent = class {
   start() {
     if (this.state === "started") return;
     if (this.state === "stopping") {
-      throw new Error("[hobots-manager] start() chamado durante stop() \u2014 aguarde o stop terminar");
+      throw new Error("[hobots] start() chamado durante stop() \u2014 aguarde o stop terminar");
     }
     if (this.registry.size === 0) {
-      throw new Error("[hobots-manager] nenhuma task registrada \u2014 chame register() antes de start()");
+      throw new Error("[hobots] nenhuma task registrada \u2014 chame register() antes de start()");
     }
     this.state = "started";
     if (this.options.installExitHandlers !== false && !this.uninstallShutdown) {
@@ -1174,6 +1335,7 @@ var ManagerAgent = class {
       this.consecutiveFailures = 0;
       this.consecutiveAuthFailures = 0;
       for (const run of response.runs) {
+        if (this.activeRuns.size >= this.concurrency) break;
         this.dispatch(run);
       }
       this.schedule(response.runs.length > 0 ? 0 : this.pollIntervalMs);
@@ -1194,7 +1356,7 @@ var ManagerAgent = class {
     }
     this.consecutiveFailures++;
     const ladder = POLL_RETRY_DELAYS_MS[Math.min(this.consecutiveFailures - 1, POLL_RETRY_DELAYS_MS.length - 1)];
-    const delay = Math.min(Math.max(ladder, 0), Math.max(this.pollIntervalMs, 16e3));
+    const delay = Math.min(Math.max(jitter(ladder), 0), Math.max(this.pollIntervalMs, 16e3));
     this.logger.warn(`poll falhou (${String(error)}), pr\xF3xima tentativa em ${delay}ms`);
     return delay;
   }
@@ -1206,7 +1368,7 @@ var ManagerAgent = class {
     this.activeRuns.add(promise);
   }
   async executeRun(run) {
-    const tx = new Transaction(this.client, `run:${run.task}`, "manager.run", true, run.id);
+    const tx = new Transaction(this.client, `run:${run.task}`, "hobots.task", true, run.id);
     const reporter = new RunReporter(this.api, run.id, run.task, this.logger, tx, this.logFlushIntervalMs, this.cancelCheckIntervalMs);
     this.reporters.add(reporter);
     try {
@@ -1272,11 +1434,11 @@ function toRunError(error) {
   if (error instanceof Error) {
     return {
       type: error.name,
-      message: truncate(error.message, MAX_ERROR_MESSAGE_CHARS),
-      stack: error.stack ? truncate(error.stack, MAX_ERROR_STACK_CHARS) : void 0
+      message: scrubSecrets(truncate(error.message, MAX_ERROR_MESSAGE_CHARS)),
+      stack: error.stack ? scrubSecrets(truncate(error.stack, MAX_ERROR_STACK_CHARS)) : void 0
     };
   }
-  return { message: truncate(String(error), MAX_ERROR_MESSAGE_CHARS) };
+  return { message: scrubSecrets(truncate(String(error), MAX_ERROR_MESSAGE_CHARS)) };
 }
 
 // src/core.ts
@@ -1420,6 +1582,7 @@ export {
   init,
   register,
   resolveConfig,
+  scrubSecrets,
   setContext,
   setExtra,
   setTag,