hobots 1.6.0 → 1.7.0

package/dist/index.js

@@ -1,6 +1,6 @@
 // src/config.ts
 var DEFAULT_BASE_URL = "https://api2.hobots.app";
-var SECRET_PATTERN = /^(hb_)?[a-f0-9]{64}$/i;
+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;
@@ -45,7 +45,7 @@ function resolveConfig(options, prefix = "[hobots]") {
     key,
     baseUrl,
     ingestEndpoint: `${baseUrl}/v1/ingest`,
-    managerBaseUrl: `${baseUrl}/v1/manager`
+    tasksBaseUrl: `${baseUrl}/v1/tasks`
   };
 }
 
@@ -103,7 +103,7 @@ function scrubSecrets(text) {
 
 // src/utils.ts
 var SDK_NAME = "hobots";
-var SDK_VERSION = true ? "1.6.0" : "0.0.0-dev";
+var SDK_VERSION = true ? "2.0.0" : "0.0.0-dev";
 function isNode() {
   return typeof process !== "undefined" && typeof process.versions?.node === "string";
 }
@@ -139,6 +139,33 @@ function sleep(ms) {
 function jitter(baseMs) {
   return Math.floor(baseMs / 2 + Math.random() * (baseMs / 2));
 }
+function truncate(value, max) {
+  return value.length > max ? `${value.slice(0, max)}\u2026 [truncado]` : value;
+}
+var DEFAULT_RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+async function fetchWithRetry(send, options) {
+  const delays = options.delays ?? DEFAULT_RETRY_DELAYS_MS;
+  for (let attempt = 0; ; attempt++) {
+    let retriable;
+    let serverDelay;
+    try {
+      const response = await send();
+      if (response.ok) return response;
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) return response;
+      if (response.status === 429) serverDelay = retryAfterMs(response);
+      retriable = new Error(`HTTP ${response.status}`);
+    } catch (error) {
+      retriable = error;
+    }
+    const base = delays[attempt];
+    if (base === void 0) {
+      throw retriable instanceof Error ? retriable : new Error(String(retriable));
+    }
+    const delay = serverDelay ?? jitter(base);
+    options.logger.warn(`${options.label}: falha (${String(retriable)}), retry em ${delay}ms`);
+    await sleep(delay);
+  }
+}
 var MAX_RETRY_AFTER_MS = 6e4;
 function retryAfterMs(response) {
   const header = response.headers.get("retry-after");
@@ -239,7 +266,6 @@ function eventFromMessage(message, level = "info") {
 }
 
 // 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;
@@ -306,36 +332,26 @@ var Transport = class {
     return request;
   }
   async sendWithRetry(envelope) {
-    for (let attempt = 0; ; attempt++) {
-      let serverDelay;
-      try {
-        const response = await fetch(this.endpoint, {
+    let response;
+    try {
+      response = await fetchWithRetry(
+        () => fetch(this.endpoint, {
           method: "POST",
           headers: { "content-type": "application/json", authorization: `Bearer ${this.key}` },
           body: JSON.stringify(envelope),
           signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-        });
-        if (response.ok) {
-          this.logger.debug(`envelope enviado (${envelope.items.length} itens)`);
-          return;
-        }
-        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
-          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 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);
-      }
+        }),
+        { logger: this.logger, label: "envio de envelope" }
+      );
+    } catch (error) {
+      this.logger.error("envelope descartado ap\xF3s retries:", error);
+      return;
     }
+    if (response.ok) {
+      this.logger.debug(`envelope enviado (${envelope.items.length} itens)`);
+      return;
+    }
+    this.logger.error(`envelope rejeitado (HTTP ${response.status}), descartado`);
   }
   /** Envia o que estiver na fila e aguarda envios em andamento (até timeoutMs). */
   async flush(timeoutMs = 5e3) {
@@ -368,10 +384,10 @@ var Client = class {
   #options;
   #config;
   transport;
-  constructor(options) {
+  constructor(options, config = resolveConfig(options)) {
     this.#options = options;
     this.logger = makeLogger(!!options.debug);
-    this.#config = resolveConfig(options);
+    this.#config = config;
     this.transport = new Transport({
       endpoint: this.#config.ingestEndpoint,
       key: this.#config.key,
@@ -777,50 +793,31 @@ function sendCheckIn(client2, options) {
   return checkInId;
 }
 async function withMonitorImpl(client2, captureError, monitorSlug, fn, options) {
-  const checkInId = sendCheckIn(client2, {
-    monitorSlug,
-    status: "in_progress",
-    schedule: options?.schedule,
-    timezone: options?.timezone
-  });
+  const base = { monitorSlug, schedule: options?.schedule, timezone: options?.timezone };
+  const checkInId = sendCheckIn(client2, { ...base, status: "in_progress" });
   const startedAt = Date.now();
   try {
     const result = await fn();
-    sendCheckIn(client2, {
-      monitorSlug,
-      status: "ok",
-      checkInId,
-      durationMs: Date.now() - startedAt,
-      schedule: options?.schedule,
-      timezone: options?.timezone
-    });
+    sendCheckIn(client2, { ...base, status: "ok", checkInId, durationMs: Date.now() - startedAt });
     return result;
   } catch (error) {
-    sendCheckIn(client2, {
-      monitorSlug,
-      status: "error",
-      checkInId,
-      durationMs: Date.now() - startedAt,
-      schedule: options?.schedule,
-      timezone: options?.timezone
-    });
+    sendCheckIn(client2, { ...base, status: "error", checkInId, durationMs: Date.now() - startedAt });
     captureError(error);
     throw error;
   }
 }
 
-// src/manager/api.ts
-var RETRY_DELAYS_MS2 = [1e3, 4e3, 16e3];
+// src/tasks/api.ts
 var POLL_TIMEOUT_MS = 3e4;
 var UPDATE_TIMEOUT_MS = 1e4;
-var ManagerApiError = class extends Error {
+var TasksApiError = class extends Error {
   constructor(message, status) {
     super(message);
     this.status = status;
-    this.name = "ManagerApiError";
+    this.name = "TasksApiError";
   }
 };
-var ManagerApi = class {
+var TasksApi = class {
   baseUrl;
   key;
   logger;
@@ -850,7 +847,7 @@ var ManagerApi = class {
       cleanup();
     }
     if (!response.ok) {
-      throw new ManagerApiError(`poll falhou (HTTP ${response.status})`, response.status);
+      throw new TasksApiError(`poll falhou (HTTP ${response.status})`, response.status);
     }
     return this.parsePollResponse(await response.json(), request.max ?? 1);
   }
@@ -858,7 +855,7 @@ var ManagerApi = class {
   parsePollResponse(body, max) {
     const runs = body?.runs;
     if (!Array.isArray(runs)) {
-      throw new ManagerApiError("resposta inv\xE1lida do poll (campo runs ausente)", 0);
+      throw new TasksApiError("resposta inv\xE1lida do poll (campo runs ausente)", 0);
     }
     const valid = [];
     for (const run of runs.slice(0, Math.max(0, max))) {
@@ -873,36 +870,25 @@ var ManagerApi = class {
   }
   /**
    * 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).
+   * 4xx é definitivo e vira TasksApiError imediato (409 = run cancelada/transição inválida).
    */
   async updateRun(runId, update) {
-    for (let attempt = 0; ; attempt++) {
-      let retriable;
-      let serverDelay;
-      try {
-        const response = await fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
+    let response;
+    try {
+      response = await fetchWithRetry(
+        () => fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
           method: "PATCH",
           headers: this.headers(),
           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 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);
+        }),
+        { logger: this.logger, label: `update da run ${runId}` }
+      );
+    } catch (error) {
+      throw new Error(`update da run ${runId} descartado ap\xF3s retries: ${String(error)}`);
+    }
+    if (!response.ok) {
+      throw new TasksApiError(`update rejeitado (HTTP ${response.status})`, response.status);
     }
   }
   /**
@@ -920,7 +906,7 @@ var ManagerApi = class {
   }
 };
 
-// src/manager/context.ts
+// src/tasks/context.ts
 var LOG_LEVEL_COLOR = {
   debug: "gray",
   info: "cyan",
@@ -1031,8 +1017,7 @@ var RunReporter = class {
       return;
     }
     this.loggedCount++;
-    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 });
+    this.buffer.push({ ts: nowISO(), level, message: truncate(scrubbed, MAX_LOG_MESSAGE_CHARS) });
     if (this.buffer.length >= FLUSH_AT_BUFFERED) {
       this.flushLogs();
     } else {
@@ -1123,7 +1108,7 @@ var RunReporter = class {
       try {
         await this.api.updateRun(this.runId, payload);
       } catch (error) {
-        if (error instanceof ManagerApiError && (error.status === 409 || error.status === 404)) {
+        if (error instanceof TasksApiError && (error.status === 409 || error.status === 404)) {
           this.dead = true;
           this.stopCancelWatch();
           this.abort();
@@ -1139,7 +1124,7 @@ var RunReporter = class {
   }
 };
 
-// src/manager/run-context-store.ts
+// src/tasks/run-context-store.ts
 var storage;
 var initPromise;
 async function ensureStorage() {
@@ -1149,15 +1134,15 @@ async function ensureStorage() {
   });
   await initPromise;
 }
-async function runWithRunId(runId, fn) {
+async function runWithRunContext(store, fn) {
   await ensureStorage();
-  return storage ? storage.run({ runId }, fn) : fn();
+  return storage ? storage.run(store, fn) : fn();
 }
-function currentRunId() {
-  return storage?.getStore()?.runId;
+function currentRunTransaction() {
+  return storage?.getStore()?.tx;
 }
 
-// src/manager/shutdown.ts
+// src/tasks/shutdown.ts
 var WATCHED_SIGNALS = ["SIGINT", "SIGTERM"];
 function installShutdownHandlers(agent2) {
   if (!isNode()) return () => {
@@ -1201,7 +1186,7 @@ function installShutdownHandlers(agent2) {
   };
 }
 
-// src/manager/agent.ts
+// src/tasks/agent.ts
 var DEFAULT_POLL_INTERVAL_MS = 5e3;
 var MIN_POLL_INTERVAL_MS = 1e3;
 var MAX_CONCURRENCY = 5;
@@ -1211,13 +1196,13 @@ function hostname() {
   if (!isNode()) return void 0;
   return process.env.HOSTNAME || process.env.COMPUTERNAME || void 0;
 }
-var ManagerAgent = class {
+var TaskAgent = class {
   constructor(options, registry2) {
     this.options = options;
     this.registry = registry2;
-    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.logger = makeLogger(options.debug ?? false);
+    const config = options.config;
+    this.api = new TasksApi({ baseUrl: config.tasksBaseUrl, key: config.key, logger: this.logger });
     this.client = options.client;
     this.pollIntervalMs = Math.max(MIN_POLL_INTERVAL_MS, options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS);
     this.concurrency = Math.min(MAX_CONCURRENCY, Math.max(1, options.concurrency ?? 1));
@@ -1225,7 +1210,7 @@ var ManagerAgent = class {
     this.taskTimeoutMs = options.taskTimeoutMs;
     this.logFlushIntervalMs = options.logFlushIntervalMs;
     this.cancelCheckIntervalMs = options.cancelCheckIntervalMs;
-    this.logger.debug("agente configurado", { baseUrl: config.managerBaseUrl });
+    this.logger.debug("agente configurado", { baseUrl: config.tasksBaseUrl });
   }
   logger;
   api;
@@ -1347,7 +1332,7 @@ var ManagerAgent = class {
     }
   }
   delayAfterPollError(error) {
-    if (error instanceof ManagerApiError && error.status === 401) {
+    if (error instanceof TasksApiError && error.status === 401) {
       this.consecutiveAuthFailures++;
       if (this.consecutiveAuthFailures === 1 || this.consecutiveAuthFailures % 10 === 0) {
         this.logger.error("chave rejeitada (401) \u2014 verifique o Client Secret do projeto em Configura\xE7\xF5es \u2192 Projetos");
@@ -1392,7 +1377,7 @@ var ManagerAgent = class {
       }
       this.logger.debug(`executando run ${run.id} (${run.task})`);
       try {
-        await runWithRunId(run.id, () => this.invokeWithTimeout(handler, run, reporter));
+        await runWithRunContext({ runId: run.id, tx }, () => this.invokeWithTimeout(handler, run, reporter));
         reporter.reportSuccess();
         tx.setStatus("ok");
         this.logger.debug(`run ${run.id} conclu\xEDda`);
@@ -1427,9 +1412,6 @@ var ManagerAgent = class {
 var TIMEOUT_SENTINEL = /* @__PURE__ */ Symbol("task-timeout");
 var MAX_ERROR_MESSAGE_CHARS = 1e4;
 var MAX_ERROR_STACK_CHARS = 2e4;
-function truncate(value, max) {
-  return value.length > max ? `${value.slice(0, max)}\u2026 [truncado]` : value;
-}
 function toRunError(error) {
   if (error instanceof Error) {
     return {
@@ -1448,7 +1430,7 @@ var scope = new Scope();
 var heartbeat;
 var agent;
 var registry = /* @__PURE__ */ new Map();
-var warnedManagerDisabled = false;
+var warnedTasksDisabled = false;
 function init(options) {
   if (client) {
     client.logger.warn("init() chamado mais de uma vez \u2014 substituindo o client anterior");
@@ -1459,8 +1441,9 @@ function init(options) {
     void agent.stop(0);
     agent = void 0;
   }
-  warnedManagerDisabled = false;
-  client = new Client(options);
+  warnedTasksDisabled = false;
+  const config = resolveConfig(options);
+  client = new Client(options, config);
   if (options.captureUnhandled !== false) {
     installGlobalHandlers(client, () => scope);
   }
@@ -1469,10 +1452,10 @@ function init(options) {
     heartbeat = new Heartbeat(client, heartbeatOptions, options.instanceId);
     heartbeat.start();
   }
-  if (options.manager) {
-    const managerOptions = options.manager === true ? {} : options.manager;
-    agent = new ManagerAgent(
-      { ...managerOptions, clientSecret: options.clientSecret, instanceId: options.instanceId, debug: options.debug, client },
+  if (options.tasks) {
+    const tasksOptions = options.tasks === true ? {} : options.tasks;
+    agent = new TaskAgent(
+      { ...tasksOptions, config, instanceId: options.instanceId, debug: options.debug, client },
       registry
     );
   }
@@ -1515,9 +1498,14 @@ function withScope(callback) {
   }
 }
 function startTransaction(name, op) {
+  const active = currentRunTransaction();
+  if (active) {
+    client?.logger.debug(`startTransaction('${name}') dentro de uma execu\xE7\xE3o \u2014 reutilizando a transaction da run`);
+    return active;
+  }
   const rate = client?.options.tracesSampleRate ?? 1;
   const sampled = rate >= 1 || Math.random() < rate;
-  return new Transaction(client, name, op, sampled, currentRunId());
+  return new Transaction(client, name, op, sampled);
 }
 function checkIn(options) {
   return client ? sendCheckIn(client, options) : void 0;
@@ -1539,17 +1527,17 @@ function register(task, handler) {
   if (registry.has(task)) {
     (agent?.logger ?? client?.logger)?.warn(`register('${task}') sobrescreveu um handler existente`);
   }
-  if (client && !agent && !warnedManagerDisabled) {
-    warnedManagerDisabled = true;
+  if (client && !agent && !warnedTasksDisabled) {
+    warnedTasksDisabled = true;
     client.logger.warn(
-      `register('${task}') com o Manager desabilitado \u2014 passe manager: true (ou op\xE7\xF5es) no init()`
+      `register('${task}') com tasks desabilitadas \u2014 passe tasks: true (ou op\xE7\xF5es) no init()`
     );
   }
   registry.set(task, handler);
 }
 function start() {
   if (!agent) {
-    throw new Error("[hobots] Manager n\xE3o configurado \u2014 passe manager: true (ou op\xE7\xF5es) no init() antes de start()");
+    throw new Error("[hobots] tasks n\xE3o configuradas \u2014 passe tasks: true (ou op\xE7\xF5es) no init() antes de start()");
   }
   agent.start();
 }
@@ -1566,9 +1554,6 @@ async function close(timeoutMs) {
 export {
   Client,
   DEFAULT_BASE_URL,
-  ManagerAgent,
-  ManagerApi,
-  ManagerApiError,
   Scope,
   Span,
   Transaction,
@@ -1581,7 +1566,6 @@ export {
   getClient,
   init,
   register,
-  resolveConfig,
   scrubSecrets,
   setContext,
   setExtra,