hobots 0.3.1 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,1203 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Client: () => Client,
+  ManagerAgent: () => ManagerAgent,
+  ManagerApi: () => ManagerApi,
+  ManagerApiError: () => ManagerApiError,
+  Scope: () => Scope,
+  Span: () => Span,
+  Transaction: () => Transaction,
+  addBreadcrumb: () => addBreadcrumb,
+  captureException: () => captureException,
+  captureMessage: () => captureMessage,
+  checkIn: () => checkIn,
+  close: () => close,
+  flush: () => flush,
+  getClient: () => getClient,
+  init: () => init,
+  parseDsn: () => parseDsn,
+  register: () => register,
+  setContext: () => setContext,
+  setExtra: () => setExtra,
+  setTag: () => setTag,
+  setTags: () => setTags,
+  setUser: () => setUser,
+  start: () => start,
+  startTransaction: () => startTransaction,
+  stop: () => stop,
+  withMonitor: () => withMonitor,
+  withScope: () => withScope
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/dsn.ts
+function parseDsnUrl(dsn, prefix) {
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}"`);
+  }
+  const key = url.username;
+  const path = url.pathname.replace(/^\/+/, "");
+  if (!key || !path) {
+    throw new Error(`${prefix} DSN inv\xE1lido: "${dsn}" \u2014 esperado https://<key>@host/<projeto>`);
+  }
+  return { key, path, origin: `${url.protocol}//${url.host}` };
+}
+function parseDsn(dsn) {
+  const { key, path, origin } = parseDsnUrl(dsn, "[hobots]");
+  return {
+    key,
+    projectSlug: path,
+    origin,
+    ingestEndpoint: `${origin}/api/ingest`,
+    managerBaseUrl: `${origin}/api/manager`
+  };
+}
+
+// src/stacktrace.ts
+var MAX_FRAMES = 50;
+var FRAME_RE = /^\s*at\s+(?:async\s+)?(?:(.+?)\s+\()?(.+?)\)?$/;
+var LOCATION_RE = /^(.*?):(\d+):(\d+)$/;
+function isInApp(filename) {
+  if (!filename) return false;
+  if (filename.startsWith("node:")) return false;
+  if (filename.startsWith("internal/")) return false;
+  if (filename.includes("node_modules")) return false;
+  if (filename === "<anonymous>") return false;
+  return true;
+}
+function parseStacktrace(stack) {
+  if (!stack) return [];
+  const frames = [];
+  for (const line of stack.split("\n")) {
+    if (frames.length >= MAX_FRAMES) break;
+    const match = FRAME_RE.exec(line);
+    if (!match || !line.trimStart().startsWith("at ")) continue;
+    const [, fn, location] = match;
+    const loc = LOCATION_RE.exec(location ?? "");
+    const filename = loc ? loc[1] : location;
+    frames.push({
+      function: fn || "<anonymous>",
+      filename: filename || void 0,
+      lineno: loc?.[2] ? Number(loc[2]) : void 0,
+      colno: loc?.[3] ? Number(loc[3]) : void 0,
+      in_app: isInApp(filename)
+    });
+  }
+  return frames;
+}
+
+// src/utils.ts
+var SDK_NAME = "hobots";
+var SDK_VERSION = "1.0.0";
+function isNode() {
+  return typeof process !== "undefined" && typeof process.versions?.node === "string";
+}
+function uuid4() {
+  const cryptoRef = globalThis.crypto;
+  if (cryptoRef && typeof cryptoRef.randomUUID === "function") {
+    return cryptoRef.randomUUID().replace(/-/g, "");
+  }
+  let out = "";
+  for (let i = 0; i < 32; i++) {
+    out += Math.floor(Math.random() * 16).toString(16);
+  }
+  return out;
+}
+function nowISO() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function unrefTimer(timer) {
+  timer?.unref?.();
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    unrefTimer(timer);
+  });
+}
+var PREFIX = "[hobots-monitor]";
+function makeLogger(enabled, prefix = PREFIX) {
+  return {
+    debug: (...args) => enabled && console.debug(prefix, ...args),
+    warn: (...args) => enabled && console.warn(prefix, ...args),
+    error: (...args) => console.error(prefix, ...args)
+  };
+}
+
+// src/eventbuilder.ts
+function safeString(value) {
+  if (typeof value === "string") return value;
+  try {
+    const json = JSON.stringify(value);
+    if (json && json !== "{}") return json;
+  } catch {
+  }
+  return String(value);
+}
+function eventFromException(error, level = "error") {
+  let type;
+  let value;
+  let frames = [];
+  if (error instanceof Error) {
+    type = error.name || "Error";
+    value = error.message;
+    frames = parseStacktrace(error.stack);
+  } else {
+    type = "NonError";
+    value = safeString(error);
+  }
+  return {
+    event_id: uuid4(),
+    timestamp: nowISO(),
+    level,
+    exception: {
+      type,
+      value,
+      ...frames.length > 0 ? { stacktrace: { frames } } : {}
+    }
+  };
+}
+function eventFromMessage(message, level = "info") {
+  return {
+    event_id: uuid4(),
+    timestamp: nowISO(),
+    level,
+    message
+  };
+}
+
+// src/transport.ts
+var RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+var DEFAULT_FLUSH_INTERVAL_MS = 2e3;
+var DEFAULT_MAX_BATCH_SIZE = 10;
+var DEFAULT_MAX_QUEUE_SIZE = 200;
+var Transport = class {
+  endpoint;
+  key;
+  logger;
+  flushIntervalMs;
+  maxBatchSize;
+  maxQueueSize;
+  buffer = [];
+  timer;
+  pending = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(options) {
+    this.endpoint = options.endpoint;
+    this.key = options.key;
+    this.logger = options.logger;
+    this.flushIntervalMs = options.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS;
+    this.maxBatchSize = options.maxBatchSize ?? DEFAULT_MAX_BATCH_SIZE;
+    this.maxQueueSize = options.maxQueueSize ?? DEFAULT_MAX_QUEUE_SIZE;
+  }
+  enqueue(item) {
+    if (this.closed) {
+      this.logger.warn("transport fechado, item descartado:", item.type);
+      return;
+    }
+    if (this.buffer.length >= this.maxQueueSize) {
+      this.buffer.shift();
+      this.logger.warn("fila cheia, item mais antigo descartado");
+    }
+    this.buffer.push(item);
+    if (this.buffer.length >= this.maxBatchSize) {
+      void this.flushBuffer();
+    } else {
+      this.schedule();
+    }
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.flushBuffer();
+    }, this.flushIntervalMs);
+    unrefTimer(this.timer);
+  }
+  flushBuffer() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    if (this.buffer.length === 0) return Promise.resolve();
+    const items = this.buffer.splice(0, this.buffer.length);
+    const envelope = {
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      sent_at: nowISO(),
+      items
+    };
+    const request = this.sendWithRetry(envelope).finally(() => {
+      this.pending.delete(request);
+    });
+    this.pending.add(request);
+    return request;
+  }
+  async sendWithRetry(envelope) {
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const response = await fetch(this.endpoint, {
+          method: "POST",
+          headers: { "content-type": "application/json", authorization: `Bearer ${this.key}` },
+          body: JSON.stringify(envelope)
+        });
+        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;
+        }
+        throw new Error(`HTTP ${response.status}`);
+      } catch (error) {
+        const delay = RETRY_DELAYS_MS[attempt];
+        if (delay === void 0) {
+          this.logger.error("envelope descartado ap\xF3s retries:", error);
+          return;
+        }
+        this.logger.warn(`falha no envio (${String(error)}), retry em ${delay}ms`);
+        await sleep(delay);
+      }
+    }
+  }
+  /** Envia o que estiver na fila e aguarda envios em andamento (até timeoutMs). */
+  async flush(timeoutMs = 5e3) {
+    void this.flushBuffer();
+    const all = Promise.allSettled([...this.pending]).then(() => true);
+    return Promise.race([all, sleep(timeoutMs).then(() => false)]);
+  }
+  async close(timeoutMs = 5e3) {
+    const result = await this.flush(timeoutMs);
+    this.closed = true;
+    return result;
+  }
+};
+
+// src/client.ts
+function runtimeContexts() {
+  if (isNode()) {
+    return {
+      runtime: { name: "node", version: process.version },
+      os: { name: process.platform, arch: process.arch }
+    };
+  }
+  return { runtime: { name: "browser" } };
+}
+var Client = class {
+  options;
+  dsn;
+  logger;
+  transport;
+  constructor(options) {
+    this.options = options;
+    this.logger = makeLogger(!!options.debug);
+    this.dsn = parseDsn(options.dsn);
+    this.transport = new Transport({
+      endpoint: this.dsn.ingestEndpoint,
+      key: this.dsn.key,
+      logger: this.logger,
+      flushIntervalMs: options.flushIntervalMs,
+      maxBatchSize: options.maxBatchSize
+    });
+  }
+  captureException(error, hint, scope2) {
+    return this.captureEvent(eventFromException(error, hint?.level ?? "error"), hint, scope2);
+  }
+  captureMessage(message, level, hint, scope2) {
+    return this.captureEvent(eventFromMessage(message, level), hint, scope2);
+  }
+  captureEvent(event, hint, scope2) {
+    const sampleRate = this.options.sampleRate ?? 1;
+    if (sampleRate < 1 && Math.random() >= sampleRate) {
+      this.logger.debug("evento descartado por sampleRate");
+      return event.event_id;
+    }
+    const prepared = this.prepareEvent(event, hint, scope2);
+    const final = this.options.beforeSend ? this.options.beforeSend(prepared) : prepared;
+    if (!final) {
+      this.logger.debug("evento descartado por beforeSend");
+      return event.event_id;
+    }
+    this.transport.enqueue({ type: "event", payload: final });
+    return final.event_id;
+  }
+  prepareEvent(event, hint, scope2) {
+    const tags = { ...this.options.tags, ...scope2.tags, ...event.tags, ...hint?.tags };
+    const extra = { ...scope2.extra, ...event.extra, ...hint?.extra };
+    return {
+      ...event,
+      level: hint?.level ?? event.level ?? scope2.level ?? "error",
+      release: event.release ?? this.options.release,
+      environment: event.environment ?? this.options.environment ?? "production",
+      tags: Object.keys(tags).length > 0 ? tags : void 0,
+      extra: Object.keys(extra).length > 0 ? extra : void 0,
+      user: event.user ?? scope2.user,
+      contexts: { ...runtimeContexts(), ...scope2.contexts, ...event.contexts },
+      breadcrumbs: scope2.breadcrumbs.length > 0 ? [...scope2.breadcrumbs] : event.breadcrumbs,
+      fingerprint: hint?.fingerprint ?? event.fingerprint ?? scope2.fingerprint
+    };
+  }
+  sendTransaction(payload) {
+    this.transport.enqueue({
+      type: "transaction",
+      payload: {
+        ...payload,
+        release: payload.release ?? this.options.release,
+        environment: payload.environment ?? this.options.environment ?? "production",
+        tags: { ...this.options.tags, ...payload.tags }
+      }
+    });
+  }
+  sendCheckIn(payload) {
+    this.transport.enqueue({
+      type: "check_in",
+      payload: {
+        ...payload,
+        release: payload.release ?? this.options.release,
+        environment: payload.environment ?? this.options.environment ?? "production"
+      }
+    });
+  }
+  sendHeartbeat(payload) {
+    this.transport.enqueue({
+      type: "heartbeat",
+      payload: { ...payload, release: payload.release ?? this.options.release }
+    });
+  }
+  flush(timeoutMs) {
+    return this.transport.flush(timeoutMs);
+  }
+  close(timeoutMs) {
+    return this.transport.close(timeoutMs);
+  }
+};
+
+// src/heartbeat.ts
+var DEFAULT_INTERVAL_MS = 3e4;
+var Heartbeat = class {
+  constructor(client2, options = {}, instanceId) {
+    this.client = client2;
+    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    this.instanceId = instanceId;
+    this.name = options.name ?? instanceId;
+    this.metadata = options.metadata;
+  }
+  intervalMs;
+  instanceId;
+  name;
+  metadata;
+  timer;
+  start() {
+    if (this.timer) return;
+    this.beat();
+    this.timer = setInterval(() => this.beat(), this.intervalMs);
+    unrefTimer(this.timer);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  beat() {
+    this.client.sendHeartbeat({
+      instance_id: this.instanceId,
+      name: this.name,
+      interval_ms: this.intervalMs,
+      timestamp: nowISO(),
+      metadata: this.metadata
+    });
+  }
+};
+
+// src/instrument.ts
+var installed = false;
+function installGlobalHandlers(client2, getScope) {
+  if (installed) return;
+  installed = true;
+  if (isNode()) {
+    process.on("uncaughtException", (error) => {
+      client2.captureException(error, { level: "fatal", tags: { mechanism: "uncaughtException" } }, getScope());
+      void client2.flush(2e3).then(() => {
+        if (process.listenerCount("uncaughtException") <= 1) {
+          console.error(error);
+          process.exit(1);
+        }
+      });
+    });
+    process.on("unhandledRejection", (reason) => {
+      client2.captureException(reason, { level: "error", tags: { mechanism: "unhandledRejection" } }, getScope());
+      void client2.flush(2e3);
+    });
+    process.on("beforeExit", () => {
+      void client2.flush(2e3);
+    });
+    return;
+  }
+  if (typeof window !== "undefined") {
+    window.addEventListener("error", (event) => {
+      client2.captureException(event.error ?? event.message, { tags: { mechanism: "onerror" } }, getScope());
+    });
+    window.addEventListener("unhandledrejection", (event) => {
+      client2.captureException(event.reason, { tags: { mechanism: "onunhandledrejection" } }, getScope());
+    });
+    window.addEventListener("pagehide", () => {
+      void client2.flush(1e3);
+    });
+  }
+}
+
+// src/scope.ts
+var Scope = class _Scope {
+  tags = {};
+  user;
+  contexts = {};
+  extra = {};
+  level;
+  fingerprint;
+  breadcrumbs = [];
+  setTag(key, value) {
+    this.tags[key] = value;
+    return this;
+  }
+  setTags(tags) {
+    Object.assign(this.tags, tags);
+    return this;
+  }
+  setUser(user) {
+    this.user = user ?? void 0;
+    return this;
+  }
+  setContext(name, context) {
+    if (context === null) {
+      delete this.contexts[name];
+    } else {
+      this.contexts[name] = context;
+    }
+    return this;
+  }
+  setExtra(key, value) {
+    this.extra[key] = value;
+    return this;
+  }
+  setExtras(extras) {
+    Object.assign(this.extra, extras);
+    return this;
+  }
+  setLevel(level) {
+    this.level = level;
+    return this;
+  }
+  setFingerprint(fingerprint) {
+    this.fingerprint = fingerprint;
+    return this;
+  }
+  addBreadcrumb(crumb, maxBreadcrumbs) {
+    this.breadcrumbs.push({ timestamp: nowISO(), ...crumb });
+    if (this.breadcrumbs.length > maxBreadcrumbs) {
+      this.breadcrumbs.splice(0, this.breadcrumbs.length - maxBreadcrumbs);
+    }
+    return this;
+  }
+  clearBreadcrumbs() {
+    this.breadcrumbs = [];
+    return this;
+  }
+  clone() {
+    const next = new _Scope();
+    next.tags = { ...this.tags };
+    next.user = this.user ? { ...this.user } : void 0;
+    next.contexts = Object.fromEntries(Object.entries(this.contexts).map(([k, v]) => [k, { ...v }]));
+    next.extra = { ...this.extra };
+    next.level = this.level;
+    next.fingerprint = this.fingerprint ? [...this.fingerprint] : void 0;
+    next.breadcrumbs = [...this.breadcrumbs];
+    return next;
+  }
+};
+
+// src/transaction.ts
+function spanId() {
+  return uuid4().slice(0, 16);
+}
+var Span = class {
+  constructor(transaction, parentSpanId, op, description) {
+    this.transaction = transaction;
+    this.parentSpanId = parentSpanId;
+    this.op = op;
+    this.description = description;
+  }
+  spanId = spanId();
+  startTimestamp = nowISO();
+  status = "ok";
+  endTimestamp;
+  data;
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  setData(key, value) {
+    this.data = { ...this.data, [key]: value };
+    return this;
+  }
+  /** Span aninhado (filho deste span). */
+  startChild(op, description) {
+    return this.transaction.createSpan(this.spanId, op, description);
+  }
+  finish() {
+    if (!this.endTimestamp) this.endTimestamp = nowISO();
+  }
+  toJSON() {
+    return {
+      span_id: this.spanId,
+      parent_span_id: this.parentSpanId,
+      op: this.op,
+      description: this.description,
+      status: this.status,
+      start_timestamp: this.startTimestamp,
+      timestamp: this.endTimestamp ?? nowISO(),
+      data: this.data
+    };
+  }
+};
+var Transaction = class {
+  constructor(client2, name, op, sampled = true) {
+    this.client = client2;
+    this.name = name;
+    this.op = op;
+    this.sampled = sampled;
+  }
+  eventId = uuid4();
+  spanId = spanId();
+  startTimestamp = nowISO();
+  status = "ok";
+  spans = [];
+  tags = {};
+  finished = false;
+  createSpan(parentSpanId, op, description) {
+    const span = new Span(this, parentSpanId, op, description);
+    this.spans.push(span);
+    return span;
+  }
+  /** Span direto da transaction. */
+  startChild(op, description) {
+    return this.createSpan(this.spanId, op, description);
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+    return this;
+  }
+  setStatus(status) {
+    this.status = status;
+    return this;
+  }
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+  finish() {
+    if (this.finished) return;
+    this.finished = true;
+    for (const span of this.spans) span.finish();
+    if (!this.sampled || !this.client) return;
+    const payload = {
+      event_id: this.eventId,
+      name: this.name,
+      op: this.op,
+      status: this.status,
+      start_timestamp: this.startTimestamp,
+      timestamp: nowISO(),
+      spans: this.spans.map((span) => span.toJSON()),
+      tags: Object.keys(this.tags).length > 0 ? this.tags : void 0
+    };
+    this.client.sendTransaction(payload);
+  }
+};
+
+// src/checkin.ts
+function sendCheckIn(client2, options) {
+  const checkInId = options.checkInId ?? uuid4();
+  client2.sendCheckIn({
+    check_in_id: checkInId,
+    monitor_slug: options.monitorSlug,
+    status: options.status,
+    duration_ms: options.durationMs,
+    schedule: options.schedule,
+    timezone: options.timezone
+  });
+  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 startedAt = Date.now();
+  try {
+    const result = await fn();
+    sendCheckIn(client2, {
+      monitorSlug,
+      status: "ok",
+      checkInId,
+      durationMs: Date.now() - startedAt,
+      schedule: options?.schedule,
+      timezone: options?.timezone
+    });
+    return result;
+  } catch (error) {
+    sendCheckIn(client2, {
+      monitorSlug,
+      status: "error",
+      checkInId,
+      durationMs: Date.now() - startedAt,
+      schedule: options?.schedule,
+      timezone: options?.timezone
+    });
+    captureError(error);
+    throw error;
+  }
+}
+
+// src/manager/api.ts
+var RETRY_DELAYS_MS2 = [1e3, 4e3, 16e3];
+var ManagerApiError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "ManagerApiError";
+  }
+};
+var ManagerApi = class {
+  baseUrl;
+  key;
+  logger;
+  constructor(options) {
+    this.baseUrl = options.baseUrl;
+    this.key = options.key;
+    this.logger = options.logger;
+  }
+  headers() {
+    return {
+      "content-type": "application/json",
+      authorization: `Bearer ${this.key}`
+    };
+  }
+  /** 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
+    });
+    if (!response.ok) {
+      throw new ManagerApiError(`poll falhou (HTTP ${response.status})`, response.status);
+    }
+    return await response.json();
+  }
+  /**
+   * 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).
+   */
+  async updateRun(runId, update) {
+    for (let attempt = 0; ; attempt++) {
+      let retriable;
+      try {
+        const response = await fetch(`${this.baseUrl}/runs/${encodeURIComponent(runId)}`, {
+          method: "PATCH",
+          headers: this.headers(),
+          body: JSON.stringify(update)
+        });
+        if (response.ok) return;
+        if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+          throw new ManagerApiError(`update rejeitado (HTTP ${response.status})`, response.status);
+        }
+        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) {
+        throw new Error(`update da run ${runId} descartado ap\xF3s retries: ${String(retriable)}`);
+      }
+      this.logger.warn(`falha no update da run ${runId} (${String(retriable)}), retry em ${delay}ms`);
+      await sleep(delay);
+    }
+  }
+};
+
+// src/manager/context.ts
+var DEFAULT_LOG_FLUSH_INTERVAL_MS = 2e3;
+var MAX_LOG_MESSAGE_CHARS = 1e4;
+var MAX_LOGS_PER_RUN = 500;
+var MAX_LOGS_PER_PATCH = 100;
+var FLUSH_AT_BUFFERED = 20;
+var RunReporter = class {
+  constructor(api, runId, task, logger, flushIntervalMs) {
+    this.api = api;
+    this.runId = runId;
+    this.logger = logger;
+    this.flushIntervalMs = flushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
+    this.context = {
+      runId,
+      task,
+      log: (level, message) => this.log(level, message),
+      signal: this.abortController.signal
+    };
+  }
+  context;
+  buffer = [];
+  loggedCount = 0;
+  droppedCount = 0;
+  dead = false;
+  chain = Promise.resolve();
+  timer;
+  abortController = new AbortController();
+  flushIntervalMs;
+  get isDead() {
+    return this.dead;
+  }
+  /** Aborta o ctx.signal sem matar o reporter (timeout/shutdown ainda reportam o terminal). */
+  abort() {
+    if (!this.abortController.signal.aborted) this.abortController.abort();
+  }
+  log(level, message) {
+    if (this.dead) return;
+    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;
+    this.buffer.push({ ts: nowISO(), level, message: truncated });
+    if (this.buffer.length >= FLUSH_AT_BUFFERED) {
+      this.flushLogs();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  scheduleFlush() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.flushLogs();
+    }, this.flushIntervalMs);
+    unrefTimer(this.timer);
+  }
+  clearFlushTimer() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+  takeLogs() {
+    const logs = this.buffer.splice(0, this.buffer.length);
+    if (this.droppedCount > 0) {
+      logs.push({
+        ts: nowISO(),
+        level: "warning",
+        message: `${this.droppedCount} logs descartados (limite de ${MAX_LOGS_PER_RUN} por execu\xE7\xE3o)`
+      });
+      this.droppedCount = 0;
+    }
+    return logs;
+  }
+  /** Flush incremental: envia o buffer como status 'running' (em chunks). */
+  flushLogs() {
+    this.clearFlushTimer();
+    if (this.dead || this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    for (let i = 0; i < logs.length; i += MAX_LOGS_PER_PATCH) {
+      this.enqueue({ status: "running", logs: logs.slice(i, i + MAX_LOGS_PER_PATCH) });
+    }
+  }
+  /** Primeiro PATCH (claimed → running). Retorna false se a run já morreu (cancelada). */
+  async reportRunning() {
+    this.enqueue({ status: "running" });
+    await this.chain;
+    return !this.dead;
+  }
+  reportSuccess() {
+    this.clearFlushTimer();
+    this.enqueue({ status: "succeeded", logs: this.takeLogs() });
+  }
+  reportFailure(error) {
+    this.clearFlushTimer();
+    this.enqueue({ status: "failed", error, logs: this.takeLogs() });
+  }
+  /** Aguarda a fila de PATCHes esvaziar (chame depois do terminal). */
+  finalize() {
+    return this.chain;
+  }
+  enqueue(update) {
+    if (this.dead) return;
+    this.chain = this.chain.then(async () => {
+      if (this.dead) return;
+      const payload = update.logs && update.logs.length === 0 ? { ...update, logs: void 0 } : update;
+      try {
+        await this.api.updateRun(this.runId, payload);
+      } catch (error) {
+        if (error instanceof ManagerApiError && (error.status === 409 || error.status === 404)) {
+          this.dead = true;
+          this.abort();
+          this.buffer = [];
+          this.logger.warn(`run ${this.runId} cancelada/removida no servidor \u2014 reporte suprimido`);
+          return;
+        }
+        this.logger.error(`update da run ${this.runId} perdido:`, error);
+      }
+    });
+  }
+};
+
+// src/manager/agent.ts
+var DEFAULT_POLL_INTERVAL_MS = 5e3;
+var MIN_POLL_INTERVAL_MS = 1e3;
+var MAX_CONCURRENCY = 5;
+var POLL_RETRY_DELAYS_MS = [1e3, 4e3, 16e3];
+var AUTH_FAILURE_INTERVAL_MS = 3e4;
+function hostname() {
+  if (!isNode()) return void 0;
+  return process.env.HOSTNAME || process.env.COMPUTERNAME || void 0;
+}
+var ManagerAgent = class {
+  constructor(options, registry2) {
+    this.options = options;
+    this.registry = registry2;
+    this.logger = makeLogger(options.debug ?? false, "[hobots-manager]");
+    const dsn = parseDsn(options.dsn);
+    this.api = new ManagerApi({ baseUrl: dsn.managerBaseUrl, key: dsn.key, logger: this.logger });
+    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));
+    this.instanceId = options.instanceId;
+    this.taskTimeoutMs = options.taskTimeoutMs;
+    this.logFlushIntervalMs = options.logFlushIntervalMs;
+    this.logger.debug("agente configurado", { baseUrl: dsn.managerBaseUrl, projectSlug: dsn.projectSlug });
+  }
+  logger;
+  api;
+  pollIntervalMs;
+  concurrency;
+  instanceId;
+  taskTimeoutMs;
+  logFlushIntervalMs;
+  state = "idle";
+  timer;
+  pollAbort;
+  consecutiveFailures = 0;
+  consecutiveAuthFailures = 0;
+  activeRuns = /* @__PURE__ */ new Set();
+  reporters = /* @__PURE__ */ new Set();
+  get activeCount() {
+    return this.activeRuns.size;
+  }
+  start() {
+    if (this.state === "started") return;
+    if (this.state === "stopping") {
+      throw new Error("[hobots-manager] 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()");
+    }
+    this.state = "started";
+    this.logger.debug(`polling iniciado (tasks: ${[...this.registry.keys()].join(", ")})`);
+    this.schedule(0);
+  }
+  /** Para o polling e aguarda as runs ativas (até timeoutMs). Retorna true se tudo terminou a tempo. */
+  async stop(timeoutMs = 3e4) {
+    if (this.state === "idle") return true;
+    this.state = "stopping";
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+    this.pollAbort?.abort();
+    const all = Promise.allSettled([...this.activeRuns]).then(() => true);
+    const finished = timeoutMs > 0 ? await Promise.race([all, sleep(timeoutMs).then(() => false)]) : false;
+    if (!finished && this.activeRuns.size > 0) {
+      this.logger.warn(`${this.activeRuns.size} run(s) ainda em execu\xE7\xE3o ap\xF3s ${timeoutMs}ms \u2014 abandonando a espera`);
+      for (const reporter of this.reporters) reporter.abort();
+    }
+    this.state = "idle";
+    return finished;
+  }
+  /** Timer intencionalmente NÃO unref'd: o agente é a razão do processo existir. */
+  schedule(delayMs) {
+    if (this.state !== "started" || this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      void this.tick();
+    }, delayMs);
+  }
+  async tick() {
+    if (this.state !== "started") return;
+    if (this.activeRuns.size >= this.concurrency) {
+      this.schedule(this.pollIntervalMs);
+      return;
+    }
+    this.pollAbort = new AbortController();
+    try {
+      const response = await this.api.poll(
+        {
+          agent: {
+            // identidade canônica do agente no painel — o mesmo instanceId do
+            // heartbeat do Monitor, então os dois canais convergem em um agente
+            instance_id: this.instanceId,
+            version: SDK_VERSION,
+            host: hostname(),
+            tasks: [...this.registry.keys()]
+          },
+          max: Math.min(MAX_CONCURRENCY, this.concurrency - this.activeRuns.size),
+          tasks: [...this.registry.keys()]
+        },
+        this.pollAbort.signal
+      );
+      this.consecutiveFailures = 0;
+      this.consecutiveAuthFailures = 0;
+      for (const run of response.runs) {
+        this.dispatch(run);
+      }
+      this.schedule(response.runs.length > 0 ? 0 : this.pollIntervalMs);
+    } catch (error) {
+      if (this.state !== "started") return;
+      this.schedule(this.delayAfterPollError(error));
+    } finally {
+      this.pollAbort = void 0;
+    }
+  }
+  delayAfterPollError(error) {
+    if (error instanceof ManagerApiError && error.status === 401) {
+      this.consecutiveAuthFailures++;
+      if (this.consecutiveAuthFailures === 1 || this.consecutiveAuthFailures % 10 === 0) {
+        this.logger.error("chave rejeitada (401) \u2014 verifique a DSN do projeto em Configura\xE7\xF5es \u2192 Agentes");
+      }
+      return Math.max(this.pollIntervalMs, AUTH_FAILURE_INTERVAL_MS);
+    }
+    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));
+    this.logger.warn(`poll falhou (${String(error)}), pr\xF3xima tentativa em ${delay}ms`);
+    return delay;
+  }
+  dispatch(run) {
+    const promise = this.executeRun(run).catch((error) => this.logger.error(`erro inesperado na run ${run.id}:`, error)).finally(() => {
+      this.activeRuns.delete(promise);
+      if (this.state === "started") this.schedule(0);
+    });
+    this.activeRuns.add(promise);
+  }
+  async executeRun(run) {
+    const reporter = new RunReporter(this.api, run.id, run.task, this.logger, this.logFlushIntervalMs);
+    this.reporters.add(reporter);
+    try {
+      const handler = this.registry.get(run.task);
+      if (!handler) {
+        reporter.reportFailure({
+          type: "HandlerNotFound",
+          message: `tarefa n\xE3o registrada no agente: ${run.task}`
+        });
+        await reporter.finalize();
+        return;
+      }
+      const ok = await reporter.reportRunning();
+      if (!ok) {
+        this.logger.debug(`run ${run.id} cancelada antes de iniciar \u2014 handler n\xE3o executado`);
+        return;
+      }
+      this.logger.debug(`executando run ${run.id} (${run.task})`);
+      try {
+        await this.invokeWithTimeout(handler, run, reporter);
+        reporter.reportSuccess();
+        this.logger.debug(`run ${run.id} conclu\xEDda`);
+      } catch (error) {
+        reporter.reportFailure(toRunError(error));
+        this.logger.debug(`run ${run.id} falhou: ${String(error)}`);
+      }
+      await reporter.finalize();
+    } finally {
+      this.reporters.delete(reporter);
+    }
+  }
+  async invokeWithTimeout(handler, run, reporter) {
+    const invocation = Promise.resolve().then(() => handler(run.params, reporter.context));
+    if (!this.taskTimeoutMs || this.taskTimeoutMs <= 0) {
+      await invocation;
+      return;
+    }
+    const timeoutMs = this.taskTimeoutMs;
+    const timeout = sleep(timeoutMs).then(() => TIMEOUT_SENTINEL);
+    const outcome = await Promise.race([invocation, timeout]);
+    if (outcome !== TIMEOUT_SENTINEL) return;
+    reporter.abort();
+    invocation.then(() => this.logger.warn(`run ${run.id} terminou depois do timeout de ${timeoutMs}ms`)).catch(() => this.logger.warn(`run ${run.id} falhou depois do timeout de ${timeoutMs}ms (erro descartado)`));
+    throw Object.assign(new Error(`timeout ap\xF3s ${timeoutMs}ms (o handler pode continuar em background)`), {
+      name: "TaskTimeout"
+    });
+  }
+};
+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 {
+      type: error.name,
+      message: truncate(error.message, MAX_ERROR_MESSAGE_CHARS),
+      stack: error.stack ? truncate(error.stack, MAX_ERROR_STACK_CHARS) : void 0
+    };
+  }
+  return { message: truncate(String(error), MAX_ERROR_MESSAGE_CHARS) };
+}
+
+// src/core.ts
+var DEFAULT_MAX_BREADCRUMBS = 100;
+var client;
+var scope = new Scope();
+var heartbeat;
+var agent;
+var registry = /* @__PURE__ */ new Map();
+var warnedManagerDisabled = false;
+function init(options) {
+  if (client) {
+    client.logger.warn("init() chamado mais de uma vez \u2014 substituindo o client anterior");
+    heartbeat?.stop();
+    heartbeat = void 0;
+  }
+  if (agent) {
+    void agent.stop(0);
+    agent = void 0;
+  }
+  warnedManagerDisabled = false;
+  client = new Client(options);
+  if (options.captureUnhandled !== false) {
+    installGlobalHandlers(client, () => scope);
+  }
+  if (options.heartbeat) {
+    const heartbeatOptions = options.heartbeat === true ? {} : options.heartbeat;
+    heartbeat = new Heartbeat(client, heartbeatOptions, options.instanceId);
+    heartbeat.start();
+  }
+  if (options.manager) {
+    const managerOptions = options.manager === true ? {} : options.manager;
+    agent = new ManagerAgent(
+      { ...managerOptions, dsn: options.dsn, instanceId: options.instanceId, debug: options.debug },
+      registry
+    );
+  }
+  client.logger.debug("inicializado", { endpoint: client.dsn.ingestEndpoint });
+}
+function getClient() {
+  return client;
+}
+function captureException(error, hint) {
+  return client?.captureException(error, hint, scope);
+}
+function captureMessage(message, level = "info", hint) {
+  return client?.captureMessage(message, level, hint, scope);
+}
+function addBreadcrumb(crumb) {
+  scope.addBreadcrumb(crumb, client?.options.maxBreadcrumbs ?? DEFAULT_MAX_BREADCRUMBS);
+}
+function setTag(key, value) {
+  scope.setTag(key, value);
+}
+function setTags(tags) {
+  scope.setTags(tags);
+}
+function setUser(user) {
+  scope.setUser(user);
+}
+function setContext(name, context) {
+  scope.setContext(name, context);
+}
+function setExtra(key, value) {
+  scope.setExtra(key, value);
+}
+function withScope(callback) {
+  const previous = scope;
+  scope = previous.clone();
+  try {
+    return callback(scope);
+  } finally {
+    scope = previous;
+  }
+}
+function startTransaction(name, op) {
+  const rate = client?.options.tracesSampleRate ?? 1;
+  const sampled = rate >= 1 || Math.random() < rate;
+  return new Transaction(client, name, op, sampled);
+}
+function checkIn(options) {
+  return client ? sendCheckIn(client, options) : void 0;
+}
+async function withMonitor(monitorSlug, fn, options) {
+  if (!client) return fn();
+  return withMonitorImpl(
+    client,
+    (error) => captureException(error, { tags: { monitor: monitorSlug } }),
+    monitorSlug,
+    fn,
+    options
+  );
+}
+function flush(timeoutMs) {
+  return client ? client.flush(timeoutMs) : Promise.resolve(true);
+}
+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;
+    client.logger.warn(
+      `register('${task}') com o Manager desabilitado \u2014 passe manager: 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()");
+  }
+  agent.start();
+}
+function stop(timeoutMs) {
+  return agent ? agent.stop(timeoutMs) : Promise.resolve(true);
+}
+async function close(timeoutMs) {
+  const agentStopped = agent ? await agent.stop(timeoutMs) : true;
+  heartbeat?.stop();
+  heartbeat = void 0;
+  const clientClosed = client ? await client.close(timeoutMs) : true;
+  return agentStopped && clientClosed;
+}
+//# sourceMappingURL=index.cjs.map