hobots 0.3.1 → 1.0.0

package/dist/manager.d.cts

@@ -0,0 +1,118 @@
+import { RunLogLevel, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest } from './manager/protocol.cjs';
+export { ManagerAgentInfo, ManagerRunDescriptor, ManagerRunError, ManagerRunStatus, ManagerRunUpdateResponse, ManagerRunUpdateStatus, RunLogEntry } from './manager/protocol.cjs';
+import { L as Logger } from './utils-LReLqjzN.cjs';
+
+interface ManagerInitOptions {
+    /** Ex.: https://<managerKey>@monitor.hobots.app/<projectSlug> */
+    dsn: string;
+    /** Intervalo entre polls sem trabalho. Default: 5_000 (mínimo 1_000) */
+    pollIntervalMs?: number;
+    /** Runs simultâneas (1..5). Default: 1 (sequencial) */
+    concurrency?: number;
+    /** Nome do agente exibido no dashboard. Default: hostname */
+    agentName?: string;
+    /**
+     * Timeout client-side por run. O handler não é morto — a run é reportada como
+     * falha e o slot é liberado. Default: sem timeout (o servidor é o backstop).
+     */
+    taskTimeoutMs?: number;
+    /** Intervalo do flush incremental de logs. Default: 2_000 */
+    logFlushIntervalMs?: number;
+    /** Loga atividade do SDK no console */
+    debug?: boolean;
+}
+interface RunContext {
+    runId: string;
+    task: string;
+    /** Log bufferizado — enviado ao servidor em PATCHes incrementais com throttle */
+    log(level: RunLogLevel, message: string): void;
+    /** Dispara em cancelamento (run cancelada no app), timeout ou shutdown — cancelamento cooperativo */
+    signal: AbortSignal;
+}
+type ManagerTaskHandler<P = Record<string, unknown>, R = unknown> = (params: P, ctx: RunContext) => R | Promise<R>;
+
+/** Inicializa o agente Manager. Chame uma vez; depois register() e start(). */
+declare function init(options: ManagerInitOptions): void;
+/** Registra o handler de uma task (o task_slug configurado no formulário do app). */
+declare function register<P = Record<string, unknown>, R = unknown>(task: string, handler: ManagerTaskHandler<P, R>): void;
+/**
+ * Inicia o polling. O timer NÃO é unref'd: o processo fica vivo aguardando
+ * trabalho até stop() — o inverso deliberado do Monitor.
+ */
+declare function start(): void;
+/** Para o polling e aguarda a run atual terminar (até timeoutMs). */
+declare function stop(timeoutMs?: number): Promise<boolean>;
+
+/**
+ * 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 é
+ * unref'd — um agente iniciado mantém o processo vivo até stop().
+ */
+declare class ManagerAgent {
+    private readonly options;
+    private readonly registry;
+    readonly logger: Logger;
+    private readonly api;
+    private readonly pollIntervalMs;
+    private readonly concurrency;
+    private readonly agentName?;
+    private readonly taskTimeoutMs?;
+    private readonly logFlushIntervalMs?;
+    private state;
+    private timer;
+    private pollAbort;
+    private consecutiveFailures;
+    private consecutiveAuthFailures;
+    private readonly activeRuns;
+    private readonly reporters;
+    constructor(options: ManagerInitOptions, registry: Map<string, ManagerTaskHandler>);
+    get activeCount(): number;
+    start(): void;
+    /** Para o polling e aguarda as runs ativas (até timeoutMs). Retorna true se tudo terminou a tempo. */
+    stop(timeoutMs?: number): Promise<boolean>;
+    /** Timer intencionalmente NÃO unref'd: o agente é a razão do processo existir. */
+    private schedule;
+    private tick;
+    private delayAfterPollError;
+    private dispatch;
+    private executeRun;
+    private invokeWithTimeout;
+}
+
+declare class ManagerApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+interface ManagerApiOptions {
+    baseUrl: string;
+    key: string;
+    logger: Logger;
+}
+/** Cliente HTTP do agente — bearer auth, retry com backoff nos updates. */
+declare class ManagerApi {
+    private readonly baseUrl;
+    private readonly key;
+    private readonly logger;
+    constructor(options: ManagerApiOptions);
+    private headers;
+    /** Um request só — o loop de polling é quem decide o backoff entre tentativas. */
+    poll(request: ManagerPollRequest, signal?: AbortSignal): Promise<ManagerPollResponse>;
+    /**
+     * 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).
+     */
+    updateRun(runId: string, update: ManagerRunUpdateRequest): Promise<void>;
+}
+
+interface ParsedManagerDsn {
+    /** Chave secreta do agente (enviada como Authorization: Bearer, nunca na URL) */
+    key: string;
+    projectSlug: string;
+    origin: string;
+    /** Base derivada: <origin>/api/manager */
+    baseUrl: string;
+}
+/** Formato: https://<managerKey>@host[:porta]/<projectSlug> */
+declare function parseManagerDsn(dsn: string): ParsedManagerDsn;
+
+export { ManagerAgent, ManagerApi, ManagerApiError, type ManagerInitOptions, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest, type ManagerTaskHandler, type ParsedManagerDsn, type RunContext, RunLogLevel, init, parseManagerDsn, register, start, stop };

package/dist/manager.d.ts

@@ -0,0 +1,118 @@
+import { RunLogLevel, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest } from './manager/protocol.js';
+export { ManagerAgentInfo, ManagerRunDescriptor, ManagerRunError, ManagerRunStatus, ManagerRunUpdateResponse, ManagerRunUpdateStatus, RunLogEntry } from './manager/protocol.js';
+import { L as Logger } from './utils-LReLqjzN.js';
+
+interface ManagerInitOptions {
+    /** Ex.: https://<managerKey>@monitor.hobots.app/<projectSlug> */
+    dsn: string;
+    /** Intervalo entre polls sem trabalho. Default: 5_000 (mínimo 1_000) */
+    pollIntervalMs?: number;
+    /** Runs simultâneas (1..5). Default: 1 (sequencial) */
+    concurrency?: number;
+    /** Nome do agente exibido no dashboard. Default: hostname */
+    agentName?: string;
+    /**
+     * Timeout client-side por run. O handler não é morto — a run é reportada como
+     * falha e o slot é liberado. Default: sem timeout (o servidor é o backstop).
+     */
+    taskTimeoutMs?: number;
+    /** Intervalo do flush incremental de logs. Default: 2_000 */
+    logFlushIntervalMs?: number;
+    /** Loga atividade do SDK no console */
+    debug?: boolean;
+}
+interface RunContext {
+    runId: string;
+    task: string;
+    /** Log bufferizado — enviado ao servidor em PATCHes incrementais com throttle */
+    log(level: RunLogLevel, message: string): void;
+    /** Dispara em cancelamento (run cancelada no app), timeout ou shutdown — cancelamento cooperativo */
+    signal: AbortSignal;
+}
+type ManagerTaskHandler<P = Record<string, unknown>, R = unknown> = (params: P, ctx: RunContext) => R | Promise<R>;
+
+/** Inicializa o agente Manager. Chame uma vez; depois register() e start(). */
+declare function init(options: ManagerInitOptions): void;
+/** Registra o handler de uma task (o task_slug configurado no formulário do app). */
+declare function register<P = Record<string, unknown>, R = unknown>(task: string, handler: ManagerTaskHandler<P, R>): void;
+/**
+ * Inicia o polling. O timer NÃO é unref'd: o processo fica vivo aguardando
+ * trabalho até stop() — o inverso deliberado do Monitor.
+ */
+declare function start(): void;
+/** Para o polling e aguarda a run atual terminar (até timeoutMs). */
+declare function stop(timeoutMs?: number): Promise<boolean>;
+
+/**
+ * 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 é
+ * unref'd — um agente iniciado mantém o processo vivo até stop().
+ */
+declare class ManagerAgent {
+    private readonly options;
+    private readonly registry;
+    readonly logger: Logger;
+    private readonly api;
+    private readonly pollIntervalMs;
+    private readonly concurrency;
+    private readonly agentName?;
+    private readonly taskTimeoutMs?;
+    private readonly logFlushIntervalMs?;
+    private state;
+    private timer;
+    private pollAbort;
+    private consecutiveFailures;
+    private consecutiveAuthFailures;
+    private readonly activeRuns;
+    private readonly reporters;
+    constructor(options: ManagerInitOptions, registry: Map<string, ManagerTaskHandler>);
+    get activeCount(): number;
+    start(): void;
+    /** Para o polling e aguarda as runs ativas (até timeoutMs). Retorna true se tudo terminou a tempo. */
+    stop(timeoutMs?: number): Promise<boolean>;
+    /** Timer intencionalmente NÃO unref'd: o agente é a razão do processo existir. */
+    private schedule;
+    private tick;
+    private delayAfterPollError;
+    private dispatch;
+    private executeRun;
+    private invokeWithTimeout;
+}
+
+declare class ManagerApiError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+interface ManagerApiOptions {
+    baseUrl: string;
+    key: string;
+    logger: Logger;
+}
+/** Cliente HTTP do agente — bearer auth, retry com backoff nos updates. */
+declare class ManagerApi {
+    private readonly baseUrl;
+    private readonly key;
+    private readonly logger;
+    constructor(options: ManagerApiOptions);
+    private headers;
+    /** Um request só — o loop de polling é quem decide o backoff entre tentativas. */
+    poll(request: ManagerPollRequest, signal?: AbortSignal): Promise<ManagerPollResponse>;
+    /**
+     * 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).
+     */
+    updateRun(runId: string, update: ManagerRunUpdateRequest): Promise<void>;
+}
+
+interface ParsedManagerDsn {
+    /** Chave secreta do agente (enviada como Authorization: Bearer, nunca na URL) */
+    key: string;
+    projectSlug: string;
+    origin: string;
+    /** Base derivada: <origin>/api/manager */
+    baseUrl: string;
+}
+/** Formato: https://<managerKey>@host[:porta]/<projectSlug> */
+declare function parseManagerDsn(dsn: string): ParsedManagerDsn;
+
+export { ManagerAgent, ManagerApi, ManagerApiError, type ManagerInitOptions, ManagerPollRequest, ManagerPollResponse, ManagerRunUpdateRequest, type ManagerTaskHandler, type ParsedManagerDsn, type RunContext, RunLogLevel, init, parseManagerDsn, register, start, stop };

package/dist/manager.js

@@ -0,0 +1,464 @@
+import {
+  SDK_VERSION,
+  isNode,
+  makeLogger,
+  nowISO,
+  parseDsnUrl,
+  sleep,
+  unrefTimer
+} from "./chunk-FW32OR7V.js";
+
+// src/manager/api.ts
+var RETRY_DELAYS_MS = [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_MS[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 MAX_RESULT_CHARS = 1e5;
+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(result) {
+    this.clearFlushTimer();
+    this.enqueue({ status: "succeeded", result: serializeResult(result, this.logger), 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);
+      }
+    });
+  }
+};
+function serializeResult(result, logger) {
+  if (result === void 0) return void 0;
+  let json;
+  try {
+    json = JSON.stringify(result);
+  } catch {
+    logger.warn("result n\xE3o serializ\xE1vel (circular/BigInt?) \u2014 descartado");
+    return { __truncated: true, message: "resultado n\xE3o serializ\xE1vel e foi descartado pelo SDK" };
+  }
+  if (json === void 0) return void 0;
+  if (json.length > MAX_RESULT_CHARS) {
+    logger.warn(`result excede ${MAX_RESULT_CHARS} chars \u2014 descartado`);
+    return { __truncated: true, message: "resultado excede 100KB e foi descartado pelo SDK" };
+  }
+  return result;
+}
+
+// src/manager/dsn.ts
+function parseManagerDsn(dsn) {
+  const { key, path, origin } = parseDsnUrl(dsn, "[hobots-manager]");
+  return {
+    key,
+    projectSlug: path,
+    origin,
+    baseUrl: `${origin}/api/manager`
+  };
+}
+
+// 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 defaultAgentName() {
+  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 = parseManagerDsn(options.dsn);
+    this.api = new ManagerApi({ baseUrl: dsn.baseUrl, 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.agentName = options.agentName ?? defaultAgentName();
+    this.taskTimeoutMs = options.taskTimeoutMs;
+    this.logFlushIntervalMs = options.logFlushIntervalMs;
+    this.logger.debug("agente configurado", { baseUrl: dsn.baseUrl, projectSlug: dsn.projectSlug });
+  }
+  logger;
+  api;
+  pollIntervalMs;
+  concurrency;
+  agentName;
+  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: {
+            name: this.agentName,
+            version: SDK_VERSION,
+            host: defaultAgentName(),
+            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 do agente rejeitada (401) \u2014 verifique a chave em /manager/agents");
+      }
+      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 {
+        const result = await this.invokeWithTimeout(handler, run, reporter);
+        reporter.reportSuccess(result);
+        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) return invocation;
+    const timeoutMs = this.taskTimeoutMs;
+    const timeout = sleep(timeoutMs).then(() => TIMEOUT_SENTINEL);
+    const outcome = await Promise.race([invocation, timeout]);
+    if (outcome !== TIMEOUT_SENTINEL) return outcome;
+    reporter.abort();
+    invocation.then(() => this.logger.warn(`run ${run.id} terminou depois do timeout de ${timeoutMs}ms (resultado descartado)`)).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/manager/core.ts
+var agent;
+var registry = /* @__PURE__ */ new Map();
+function init(options) {
+  if (agent) {
+    agent.logger.warn("init() chamado mais de uma vez \u2014 substituindo o agente anterior");
+    void agent.stop(0);
+  }
+  agent = new ManagerAgent(options, registry);
+}
+function register(task, handler) {
+  if (registry.has(task)) {
+    agent?.logger.warn(`register('${task}') sobrescreveu um handler existente`);
+  }
+  registry.set(task, handler);
+}
+function start() {
+  if (!agent) {
+    throw new Error("[hobots-manager] init() precisa ser chamado antes de start()");
+  }
+  agent.start();
+}
+function stop(timeoutMs) {
+  return agent ? agent.stop(timeoutMs) : Promise.resolve(true);
+}
+export {
+  ManagerAgent,
+  ManagerApi,
+  ManagerApiError,
+  init,
+  parseManagerDsn,
+  register,
+  start,
+  stop
+};
+//# sourceMappingURL=manager.js.map