hobots 4.5.0 → 5.0.0

package/README.md

@@ -58,9 +58,7 @@ hobots.start(async () => {
   while (true) {
     await hobots.sleep(60_000); // cancelável
     for (const arquivo of await novosArquivos()) {
-      const step = hobots.transaction.start('arquivo', arquivo);
-      await processar(arquivo);
-      step.succeeded();
+      await hobots.step(`arquivo ${arquivo}`, () => processar(arquivo)); // etapa no waterfall, com 1 nova tentativa
       hobots.items.succeeded({ arquivo });
     }
     hobots.log.info('ciclo ok');
@@ -69,7 +67,7 @@ hobots.start(async () => {
 });
 ```
 
-O objeto **`hobots`** é global: `hobots.log`, `hobots.items`, `hobots.progress`, `hobots.transaction`… resolvem a execução **atual** de qualquer módulo do programa — sem passar contexto de mão em mão, mesmo com várias execuções em paralelo. Depois do `register()`/`start()` ele também existe como `globalThis.hobots`.
+O objeto **`hobots`** é global: `hobots.log`, `hobots.items`, `hobots.progress`, `hobots.step`… resolvem a execução **atual** de qualquer módulo do programa — sem passar contexto de mão em mão, mesmo com várias execuções em paralelo. Depois do `register()`/`start()` ele também existe como `globalThis.hobots`.
 
 ---
 
@@ -82,6 +80,8 @@ O objeto **`hobots`** é global: `hobots.log`, `hobots.items`, `hobots.progress`
 | `HOBOTS_RUN_ID` | `runId` | Definida por quem lança o processo (o Studio): o `register()` não faz poll — inicia essa run, executa o handler uma vez e sai. O código do bot não muda. |
 | `HOBOTS_ENVIRONMENT` | `environment` | Ambiente lógico do robô (`development` \| `testing` \| `staging` \| `production`). Sem ela, `production`. |
 | `HOBOTS_API_URL` | — | Só em desenvolvimento: aponta o SDK para outro host (`http://localhost:3001`). Em produção é sempre `https://api2.hobots.app`. |
+| `HOBOTS_LOCAL_RUN` | — | `1` liga o **modo local** (teste sem a Central): sem secret, sem rede; o handler roda uma vez com os params de `HOBOTS_RUN_PARAMS` e o processo encerra com o exit code do desfecho. `npx hobots run bot.js …` define as duas por você. Ver [Execuções → Modo local](./docs/runs.md#modo-local-teste-sem-a-central). |
+| `HOBOTS_RUN_PARAMS` | — | Modo local: objeto JSON dos params do handler (ausente = `{}`). |
 
 A opção passada em `register()`/`start()` tem precedência sobre a env — útil para copiar e colar o snippet do app.
 
@@ -112,11 +112,11 @@ A opção passada em `register()`/`start()` tem precedência sobre a env — út
 | --- | --- |
 | `hobots.log.debug/info/warn/error/success(msg, ...rest)` | Log da execução, enviado incrementalmente ao app (e ecoado no terminal como `[hobots] INFO …`). Aceita vários argumentos como `console.log` — `hobots.log.info('nota', numero, 'ok')` — cada um vira texto, unidos por espaço. Um `hobots.image(...)` como **último** argumento pendura um print na linha. **Nunca lança** — pode ir em `finally`. |
 | `hobots.items.succeeded(payload?, { id, image }?)` · `.failed(msg, payload?, …)` · `.occurrence(msg, payload?, …)` · `.add({...})` | **A entrega do robô**: cada item processado, com status e atributos (viram colunas no app — declare-as com a opção `items: { columns: [...] }` do `register`/`start`). `image` pendura um print no item. Bufferizado, em lotes. |
-| `hobots.items.each(lista, async (el, item) => …, { id, payload }?)` | **Loop com o contrato garantido**: cada elemento vira step + item; exceção no handler = item `failed` com a mensagem e o loop **segue** até o fim; progresso automático. Só cancelamento/timeout interrompem. |
+| `hobots.items.each(lista, async (el, item) => …, { id, payload }?)` | **Loop com o contrato garantido**: cada elemento vira etapa + item; exceção no handler = item `failed` com a mensagem e o loop **segue** até o fim; progresso automático; `hobots.flush()` ao fim de cada ciclo (`flush: false` desliga). Só cancelamento/timeout interrompem. |
 | `hobots.progress.total(n)` · `.advance(k = 1)` · `.set(atual, total?)` · `.current` · `.snapshot` | Barra, percentual e tempo restante na execução. Sem `total()` nada é enviado. |
-| `hobots.flush(timeoutMs?)` | **Entrega já** o que a execução fez: as steps raiz finalizadas viram transactions parciais (waterfall na Central sem esperar a run terminar) e itens, logs e progresso pendentes saem sem esperar o throttle. O bot decide quando — num agente `start()`, ao fim de cada rodada que processou itens. Aguarda com teto (15 s) e nunca lança. |
-| `hobots.transaction.start(op, descrição)` | Uma **step** no waterfall de performance da execução. A transaction da execução (`run`) já existe e é finalizada pelo SDK. `step.setStatus(status, msg?, { image })` / `failed(err, msg?, { image })` penduram um print na step. |
-| `hobots.image(bytes \| caminho, { caption?, contentType? })` | Embrulha um **print** (PNG/JPEG/WEBP, até 5 MB, 20 por execução) para ir junto de um log, item ou step. Puro: o upload roda em segundo plano quando o evento é registrado; nunca lança nem bloqueia. |
+| `hobots.flush(timeoutMs?)` | **Entrega já** o que a execução fez: as etapas raiz finalizadas viram transactions parciais (waterfall na Central sem esperar a run terminar) e itens, logs e progresso pendentes saem sem esperar o throttle. `step` (raiz) e cada ciclo do `items.each` já chamam sozinhos; à mão, para o resto da rodada de um agente `start()`. Aguarda com teto (15 s) e nunca lança. |
+| `hobots.step(nome, async etapa => …, { retries = 1, retryDelayMs = 5_000, flush = true }?)` | Uma **etapa** no waterfall de performance da execução: roda a função, **tenta de novo** se ela lançar (`retries: 0` desliga — use em etapas não idempotentes) e fecha a etapa. Resolve com o retorno da função. `hobots.step` dentro de outra vira sub-etapa. A etapa raiz faz `flush()` ao terminar (`flush: false` desliga). O handle `etapa` tem `warning(motivo, { image }?)`, `image(png)` e `data(chave, valor)`. |
+| `hobots.image(bytes \| caminho, { caption?, contentType? })` | Embrulha um **print** (PNG/JPEG/WEBP, até 5 MB, 20 por execução) para ir junto de um log, item ou etapa. Puro: o upload roda em segundo plano quando o evento é registrado; nunca lança nem bloqueia. |
 | `hobots.captureException(erro, hint?)` | Abre uma **issue** (módulo Issues). `hint.attachment` anexa um print à linha de log correspondente. |
 | `hobots.retry(fn, { retries = 3, delayMs = 1_000, shouldRetry? })` | async-retry ciente do cancelamento da execução. `delayMs` aceita função `(tentativa) => ms`. |
 | `hobots.sleep(ms)` | Espera **cancelável**: rejeita com `RunCanceled` se a execução for cancelada. |
@@ -162,7 +162,7 @@ hobots.register(async () => {
 
 Uma execução cancelada no app **não mata** o handler — o SDK dispara `hobots.signal` e o próximo ponto de parada lança **`RunCanceled`**:
 
-- `hobots.items.*`, `hobots.progress.total/advance/set`, `hobots.transaction.start()`, `hobots.sleep()` e cada tentativa de `hobots.retry()`.
+- `hobots.items.*`, `hobots.progress.total/advance/set`, `hobots.step()`, `hobots.sleep()` e cada tentativa de `hobots.retry()`.
 - **Nunca `hobots.log.*`** — um log dentro de um `finally` de limpeza não pode explodir.
 
 Num loop de itens, isso costuma bastar: registrar o item processado já é o ponto de parada. Para controle fino, `hobots.throwIfCanceled()` e `hobots.signal` continuam disponíveis. Quando o cancelamento veio do app, o `RunCanceled` é **suprimido** — a execução já está `cancelada` no servidor e nada é reportado por cima. Limpeza (fechar navegador, desfazer estado) vai em `try/finally`.
@@ -231,17 +231,20 @@ Sem handler próprio de sinal, um `SIGINT`/`SIGTERM` (ou erro fatal) com execuç
 
 ## Changelog resumido
 
+- **5.0.0** — **uma API só de etapas** (breaking): `hobots.step(nome, fn, { retries, retryDelayMs }?)` abre a etapa, tenta de novo quando `fn` lança (default 1 tentativa extra) e fecha; `fn` recebe o handle `etapa` (`warning`/`image`/`data`); `hobots.step` dentro de outra (ou do handler do `items.each`) vira sub-etapa. `hobots.transaction`, `ctx.transaction` e os tipos `Transaction`/`Step`/`StepOutcomeOptions` foram removidos; `item.step` é o handle novo. Modo local ecoa `[hobots:step] FINISH …`. Nomes de etapa são recortados em 2048 no cliente. Flush automático ao fim da etapa raiz e de cada ciclo do `items.each` (`flush: false` desliga). Antes/depois no [CHANGELOG](./CHANGELOG.md).
+- **4.6.0** — **modo local** (`HOBOTS_LOCAL_RUN=1`): `register()`/`start()` rodam o handler uma vez sem Central, sem secret e sem rede, com params de `HOBOTS_RUN_PARAMS`; itens viram linhas `[hobots:item]` + `[hobots:summary]` no stdout, exit code 0/1/130; CLI `npx hobots run <entry.js> [--params] [--param] [--file] [--reset-ledger]`; `FileRef` local aceita `path` no modo local; eco `[hobots:progress] c/t` no stdout (paridade com o SDK Python).
+
 - **4.3.0** — `register()` com env `HOBOTS_RUN_ID` (ou opção `runId`) executa só essa run: `POST /v1/runs/{id}/start` no lugar do poll, handler uma vez e `close()`; tipos `RunStartRequest`/`RunStartResponse` em `hobots/protocol`; itens recusados por armazenamento cheio (`402 storage_limit`) viram um aviso só por episódio, sem parar os envios.
 - **4.2.0** — **arquivos do formulário**: `hobots.files` (`list`, `get`, `download`, `downloadAll`, `read`) e `isFileRef`; tipos `FileRef`, `FileStorage`, `FileDownloadResponse` em `hobots/protocol`.
 - **4.0.0** — **o agente é a própria tarefa** (breaking): `register(handler, options?)`/`start(handler, options?)` **sem slug**; **uma chamada por processo** (a segunda lança); `hobots.task`/`ctx.task` removidos; tipos `TaskHandler`→`RunHandler`, `TaskOptions`→`RunOptions`, `TaskItemsOptions`→`ItemsOptions`; wire: `InstanceInfo.mode` (`on_demand` \| `always_on`) e `InstanceInfo.items` no lugar de `tasks`/`task_items`, endpoints em `/v1/runs/*`; eco no terminal `[hobots] INFO …`. Guia de migração no [CHANGELOG](./CHANGELOG.md).
-- **3.4.0** — `hobots.attach()` removido; o print vai junto do evento: `hobots.image(...)` no último argumento de `log.*`, `{ image }` em itens e steps.
+- **3.4.0** — `hobots.attach()` removido; o print vai junto do evento: `hobots.image(...)` no último argumento de `log.*`, `{ image }` em itens e etapas.
 - **3.1.0** — `hobots.log.*` aceita vários argumentos (como `console.log`); `retries` inválido (`NaN`) cai no default em vez de tentar para sempre; 429 de itens e 429/501/503 de anexo são definitivos (sem esperar a ladder — `quota`/`unsupported` passam a funcionar de fato); timeout **por requisição** nos anexos; truncamento nos limites do servidor (tag 512, fingerprint 10×255, nome de transaction 500, 200 steps, `exception.value` 8192, `filename` 1024); PNG acima de 20 000 px não declara dimensões; PATCH terminal nunca passa de 100 logs.
 
 ## Documentação
 
 - [Getting started](./docs/getting-started.md) — instalação, envs, o primeiro agente nos dois modos.
 - [Execuções](./docs/runs.md) — handler, `hobots.*`, itens, progresso, anexos, cancelamento, retry, concorrência, idempotência.
-- [Conceitos](./docs/concepts.md) — o vocabulário: agente, execução, evento, transaction, step, heartbeat, instância, claim…
+- [Conceitos](./docs/concepts.md) — o vocabulário: agente, execução, evento, etapa, heartbeat, instância, claim…
 - [Referência de API](./docs/api-reference.md) — assinaturas, tabelas de opções e tempos.
 - [Protocolo & transporte](./docs/protocol.md) — endpoints, envelope, retries, claim.
 - Exemplos runnable em [`packages/hobots-sdk-demos`](../hobots-sdk-demos).

package/dist/cli.cjs

@@ -0,0 +1,250 @@
+#!/usr/bin/env node
+"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/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  CliError: () => CliError,
+  LEDGER_RESET_ENV: () => LEDGER_RESET_ENV,
+  USAGE: () => USAGE,
+  childEnv: () => childEnv,
+  contentTypeFor: () => contentTypeFor,
+  makeLocalFileRef: () => makeLocalFileRef,
+  parseParamValue: () => parseParamValue,
+  parseRunArgs: () => parseRunArgs,
+  runCli: () => runCli,
+  signalExitCode: () => signalExitCode,
+  wantsHelp: () => wantsHelp
+});
+module.exports = __toCommonJS(cli_exports);
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+
+// src/env.ts
+var LOCAL_RUN_ENV = "HOBOTS_LOCAL_RUN";
+var RUN_PARAMS_ENV = "HOBOTS_RUN_PARAMS";
+
+// src/cli.ts
+var LEDGER_RESET_ENV = "HOBOTS_LEDGER_RESET";
+var USAGE = "uso: hobots run <entry.js> [--params <arquivo.json>] [--param <chave>=<valor>]... [--file <campo>=<caminho>]... [--reset-ledger] [-- <args do bot>]";
+var CONTENT_TYPES = {
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  xls: "application/vnd.ms-excel",
+  csv: "text/csv",
+  ods: "application/vnd.oasis.opendocument.spreadsheet",
+  pdf: "application/pdf",
+  json: "application/json",
+  txt: "text/plain",
+  xml: "application/xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  zip: "application/zip"
+};
+function contentTypeFor(name) {
+  return CONTENT_TYPES[(0, import_node_path.extname)(name).slice(1).toLowerCase()] ?? "application/octet-stream";
+}
+var CliError = class extends Error {
+  constructor(message, usage = false) {
+    super(message);
+    this.usage = usage;
+    this.name = "CliError";
+  }
+  usage;
+};
+function parseParamValue(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+}
+function splitAssignment(flag, raw) {
+  const at = raw.indexOf("=");
+  if (at <= 0) throw new CliError(`${flag} espera <chave>=<valor>`, true);
+  return [raw.slice(0, at), raw.slice(at + 1)];
+}
+function isRegularFile(path) {
+  try {
+    return (0, import_node_fs.statSync)(path).isFile();
+  } catch {
+    return false;
+  }
+}
+function readParamsFile(given, path) {
+  if (!isRegularFile(path)) throw new CliError(`--params: arquivo n\xE3o encontrado: ${given}`);
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+  } catch {
+    throw new CliError("--params: n\xE3o \xE9 JSON v\xE1lido");
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliError("--params: esperado um objeto JSON");
+  }
+  return parsed;
+}
+function makeLocalFileRef(path, cwd) {
+  const absolute = (0, import_node_path.resolve)(cwd, path);
+  if (!isRegularFile(absolute)) throw new CliError(`arquivo n\xE3o encontrado: ${path}`);
+  return {
+    id: (0, import_node_crypto.randomUUID)(),
+    name: (0, import_node_path.basename)(absolute),
+    size: (0, import_node_fs.statSync)(absolute).size,
+    contentType: contentTypeFor(absolute),
+    storage: "local",
+    path: absolute
+  };
+}
+function wantsHelp(argv) {
+  const end = argv.indexOf("--");
+  return (end === -1 ? argv : argv.slice(0, end)).some((arg) => arg === "-h" || arg === "--help");
+}
+function parseRunArgs(argv, cwd = process.cwd()) {
+  if (argv[0] !== "run") {
+    throw new CliError(argv[0] === void 0 ? "comando ausente" : `comando desconhecido: ${argv[0]}`, true);
+  }
+  let entry;
+  let fromFile = {};
+  const fromFlags = {};
+  const fileFields = /* @__PURE__ */ new Map();
+  let resetLedger = false;
+  let botArgs = [];
+  const args = argv.slice(1);
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      botArgs = args.slice(i + 1);
+      break;
+    }
+    if (arg === "--reset-ledger") {
+      resetLedger = true;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      const flag = eq === -1 ? arg : arg.slice(0, eq);
+      if (flag !== "--params" && flag !== "--param" && flag !== "--file") throw new CliError(`flag desconhecida: ${flag}`, true);
+      const value = eq === -1 ? args[++i] : arg.slice(eq + 1);
+      if (value === void 0) throw new CliError(`${flag} espera um valor`, true);
+      if (flag === "--params") {
+        fromFile = readParamsFile(value, (0, import_node_path.resolve)(cwd, value));
+      } else if (flag === "--param") {
+        const [key, raw] = splitAssignment(flag, value);
+        fromFlags[key] = parseParamValue(raw);
+      } else {
+        const [field, path] = splitAssignment(flag, value);
+        const refs = fileFields.get(field) ?? [];
+        refs.push(makeLocalFileRef(path, cwd));
+        fileFields.set(field, refs);
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg !== "-") throw new CliError(`flag desconhecida: ${arg}`, true);
+    if (entry !== void 0) throw new CliError(`argumento inesperado: ${arg} (use -- antes dos argumentos do bot)`, true);
+    entry = arg;
+  }
+  if (entry === void 0) throw new CliError("entry do bot ausente", true);
+  const entryPath = (0, import_node_path.resolve)(cwd, entry);
+  if (!isRegularFile(entryPath)) throw new CliError(`arquivo n\xE3o encontrado: ${entry}`);
+  const params = { ...fromFile, ...fromFlags };
+  for (const [field, refs] of fileFields) params[field] = refs.length === 1 ? refs[0] : refs;
+  return { entry: entryPath, params, resetLedger, botArgs };
+}
+function childEnv(command, base = process.env) {
+  const env = { ...base, [LOCAL_RUN_ENV]: "1", [RUN_PARAMS_ENV]: JSON.stringify(command.params) };
+  if (command.resetLedger) env[LEDGER_RESET_ENV] = "1";
+  return env;
+}
+function signalExitCode(signal) {
+  const number = signal ? import_node_os.constants.signals[signal] : void 0;
+  return number === void 0 ? 1 : 128 + number;
+}
+var defaultDeps = () => ({
+  spawn: import_node_child_process.spawn,
+  stdout: (line) => console.log(line),
+  stderr: (line) => console.error(line),
+  execPath: process.execPath,
+  cwd: process.cwd(),
+  env: process.env,
+  signals: process
+});
+async function runCli(argv, overrides = {}) {
+  const deps = { ...defaultDeps(), ...overrides };
+  if (wantsHelp(argv)) {
+    deps.stdout(USAGE);
+    return 0;
+  }
+  let command;
+  try {
+    command = parseRunArgs(argv, deps.cwd);
+  } catch (error) {
+    if (!(error instanceof CliError)) throw error;
+    deps.stderr(`[hobots] ERROR ${error.message}`);
+    if (error.usage) deps.stderr(USAGE);
+    return 2;
+  }
+  return new Promise((resolveCode) => {
+    const child = deps.spawn(deps.execPath, [command.entry, ...command.botArgs], {
+      stdio: "inherit",
+      env: childEnv(command, deps.env),
+      cwd: deps.cwd
+    });
+    const forward = (signal) => () => void child.kill(signal);
+    const onInt = forward("SIGINT");
+    const onTerm = forward("SIGTERM");
+    deps.signals.on("SIGINT", onInt);
+    deps.signals.on("SIGTERM", onTerm);
+    const cleanup = () => {
+      deps.signals.off("SIGINT", onInt);
+      deps.signals.off("SIGTERM", onTerm);
+    };
+    child.once("error", (error) => {
+      cleanup();
+      deps.stderr(`[hobots] ERROR n\xE3o foi poss\xEDvel executar ${command.entry}: ${error.message}`);
+      resolveCode(2);
+    });
+    child.once("exit", (code, signal) => {
+      cleanup();
+      resolveCode(code ?? signalExitCode(signal));
+    });
+  });
+}
+if (typeof require !== "undefined" && typeof module !== "undefined" && require.main === module) {
+  void runCli(process.argv.slice(2)).then((code) => process.exit(code));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CliError,
+  LEDGER_RESET_ENV,
+  USAGE,
+  childEnv,
+  contentTypeFor,
+  makeLocalFileRef,
+  parseParamValue,
+  parseRunArgs,
+  runCli,
+  signalExitCode,
+  wantsHelp
+});
+//# sourceMappingURL=cli.cjs.map

package/dist/cli.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli.ts","../src/env.ts"],"sourcesContent":["/**\n * `npx hobots run <entry.js> [opções] [-- args do bot]` — executa o bot em MODO LOCAL (teste sem a\n * Central): monta os params (`--params`, `--param`, `--file`), define `HOBOTS_LOCAL_RUN=1` e\n * `HOBOTS_RUN_PARAMS` e roda o entry com o mesmo Node (`process.execPath`), herdando o terminal.\n * O exit code do bot é o da CLI. Espelho da `python -m hobots run` do SDK Python.\n */\nimport { spawn as nodeSpawn, type ChildProcess } from 'node:child_process';\nimport { randomUUID } from 'node:crypto';\nimport { readFileSync, statSync } from 'node:fs';\nimport { constants as osConstants } from 'node:os';\nimport { basename, extname, resolve } from 'node:path';\nimport { LOCAL_RUN_ENV, RUN_PARAMS_ENV } from './env';\nimport type { FileRef } from './tasks/protocol';\n\n/** `--reset-ledger`: o scaffold do bot (não o SDK) lê esta env e zera o ledger antes de começar. */\nexport const LEDGER_RESET_ENV = 'HOBOTS_LEDGER_RESET';\n\nexport const USAGE =\n  'uso: hobots run <entry.js> [--params <arquivo.json>] [--param <chave>=<valor>]... [--file <campo>=<caminho>]... [--reset-ledger] [-- <args do bot>]';\n\nconst CONTENT_TYPES: Record<string, string> = {\n  xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',\n  xls: 'application/vnd.ms-excel',\n  csv: 'text/csv',\n  ods: 'application/vnd.oasis.opendocument.spreadsheet',\n  pdf: 'application/pdf',\n  json: 'application/json',\n  txt: 'text/plain',\n  xml: 'application/xml',\n  png: 'image/png',\n  jpg: 'image/jpeg',\n  jpeg: 'image/jpeg',\n  zip: 'application/zip',\n};\n\n/** Content-type pela extensão (minúsculas); desconhecida → `application/octet-stream`. */\nexport function contentTypeFor(name: string): string {\n  return CONTENT_TYPES[extname(name).slice(1).toLowerCase()] ?? 'application/octet-stream';\n}\n\n/** Erro de uso ou de ambiente da CLI: mensagem curta no stderr e exit 2. `usage` acrescenta a linha de uso. */\nexport class CliError extends Error {\n  constructor(\n    message: string,\n    readonly usage = false\n  ) {\n    super(message);\n    this.name = 'CliError';\n  }\n}\n\n/** FileRef `local` do modo local: a chave extra `path` aponta para o arquivo (preservado no download). */\nexport interface LocalFileRef extends FileRef {\n  storage: 'local';\n  path: string;\n}\n\nexport interface RunCommand {\n  /** Caminho absoluto do entry do bot. */\n  entry: string;\n  params: Record<string, unknown>;\n  resetLedger: boolean;\n  /** Argumentos depois de `--`, repassados ao bot. */\n  botArgs: string[];\n}\n\n/** `--param chave=valor`: JSON válido vira o valor parseado (`3`, `true`, `\"x\"`, `[1]`); senão, a string crua. */\nexport function parseParamValue(raw: string): unknown {\n  try {\n    return JSON.parse(raw);\n  } catch {\n    return raw;\n  }\n}\n\nfunction splitAssignment(flag: string, raw: string): [string, string] {\n  const at = raw.indexOf('=');\n  if (at <= 0) throw new CliError(`${flag} espera <chave>=<valor>`, true);\n  return [raw.slice(0, at), raw.slice(at + 1)];\n}\n\nfunction isRegularFile(path: string): boolean {\n  try {\n    return statSync(path).isFile();\n  } catch {\n    return false;\n  }\n}\n\nfunction readParamsFile(given: string, path: string): Record<string, unknown> {\n  if (!isRegularFile(path)) throw new CliError(`--params: arquivo não encontrado: ${given}`);\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(path, 'utf8'));\n  } catch {\n    throw new CliError('--params: não é JSON válido');\n  }\n  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {\n    throw new CliError('--params: esperado um objeto JSON');\n  }\n  return parsed as Record<string, unknown>;\n}\n\nexport function makeLocalFileRef(path: string, cwd: string): LocalFileRef {\n  const absolute = resolve(cwd, path);\n  if (!isRegularFile(absolute)) throw new CliError(`arquivo não encontrado: ${path}`);\n  return {\n    id: randomUUID(),\n    name: basename(absolute),\n    size: statSync(absolute).size,\n    contentType: contentTypeFor(absolute),\n    storage: 'local',\n    path: absolute,\n  };\n}\n\n/**\n * `hobots run <entry> …`. Precedência dos params: `--params` < `--param` < `--file`; o mesmo\n * campo repetido em `--file` vira uma lista de FileRefs. Flags aceitam `--flag valor` e `--flag=valor`.\n */\n/** `true` quando a linha pede ajuda (`-h`/`--help` em qualquer posição antes do `--`). */\nexport function wantsHelp(argv: string[]): boolean {\n  const end = argv.indexOf('--');\n  return (end === -1 ? argv : argv.slice(0, end)).some(arg => arg === '-h' || arg === '--help');\n}\n\nexport function parseRunArgs(argv: string[], cwd = process.cwd()): RunCommand {\n  if (argv[0] !== 'run') {\n    throw new CliError(argv[0] === undefined ? 'comando ausente' : `comando desconhecido: ${argv[0]}`, true);\n  }\n  let entry: string | undefined;\n  let fromFile: Record<string, unknown> = {};\n  const fromFlags: Record<string, unknown> = {};\n  const fileFields = new Map<string, LocalFileRef[]>();\n  let resetLedger = false;\n  let botArgs: string[] = [];\n\n  const args = argv.slice(1);\n  for (let i = 0; i < args.length; i++) {\n    const arg = args[i]!;\n    if (arg === '--') {\n      botArgs = args.slice(i + 1);\n      break;\n    }\n    if (arg === '--reset-ledger') {\n      resetLedger = true;\n      continue;\n    }\n    if (arg.startsWith('--')) {\n      const eq = arg.indexOf('=');\n      const flag = eq === -1 ? arg : arg.slice(0, eq);\n      if (flag !== '--params' && flag !== '--param' && flag !== '--file') throw new CliError(`flag desconhecida: ${flag}`, true);\n      const value = eq === -1 ? args[++i] : arg.slice(eq + 1);\n      if (value === undefined) throw new CliError(`${flag} espera um valor`, true);\n      if (flag === '--params') {\n        fromFile = readParamsFile(value, resolve(cwd, value));\n      } else if (flag === '--param') {\n        const [key, raw] = splitAssignment(flag, value);\n        fromFlags[key] = parseParamValue(raw);\n      } else {\n        const [field, path] = splitAssignment(flag, value);\n        const refs = fileFields.get(field) ?? [];\n        refs.push(makeLocalFileRef(path, cwd));\n        fileFields.set(field, refs);\n      }\n      continue;\n    }\n    if (arg.startsWith('-') && arg !== '-') throw new CliError(`flag desconhecida: ${arg}`, true);\n    if (entry !== undefined) throw new CliError(`argumento inesperado: ${arg} (use -- antes dos argumentos do bot)`, true);\n    entry = arg;\n  }\n  if (entry === undefined) throw new CliError('entry do bot ausente', true);\n  const entryPath = resolve(cwd, entry);\n  if (!isRegularFile(entryPath)) throw new CliError(`arquivo não encontrado: ${entry}`);\n\n  const params: Record<string, unknown> = { ...fromFile, ...fromFlags };\n  for (const [field, refs] of fileFields) params[field] = refs.length === 1 ? refs[0] : refs;\n  return { entry: entryPath, params, resetLedger, botArgs };\n}\n\n/** Env do processo do bot: a do pai + o gatilho do modo local, os params e (opcional) o reset do ledger. */\nexport function childEnv(command: RunCommand, base: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = { ...base, [LOCAL_RUN_ENV]: '1', [RUN_PARAMS_ENV]: JSON.stringify(command.params) };\n  if (command.resetLedger) env[LEDGER_RESET_ENV] = '1';\n  return env;\n}\n\n/** Filho morto por sinal: 128 + número do sinal (SIGINT → 130, SIGTERM → 143), como o shell. */\nexport function signalExitCode(signal: NodeJS.Signals | null): number {\n  const number: number | undefined = signal ? (osConstants.signals as Record<string, number | undefined>)[signal] : undefined;\n  return number === undefined ? 1 : 128 + number;\n}\n\nexport type Spawn = (command: string, args: string[], options: { stdio: 'inherit'; env: NodeJS.ProcessEnv; cwd: string }) => ChildProcess;\n\nexport interface CliDeps {\n  spawn: Spawn;\n  stdout: (line: string) => void;\n  stderr: (line: string) => void;\n  execPath: string;\n  cwd: string;\n  env: NodeJS.ProcessEnv;\n  /** Onde instalar o repasse de SIGINT/SIGTERM ao filho (o `process`). */\n  signals: Pick<NodeJS.Process, 'on' | 'off'>;\n}\n\nconst defaultDeps = (): CliDeps => ({\n  spawn: nodeSpawn,\n  stdout: line => console.log(line),\n  stderr: line => console.error(line),\n  execPath: process.execPath,\n  cwd: process.cwd(),\n  env: process.env,\n  signals: process,\n});\n\n/** Roda a CLI e resolve com o exit code (2 em erro de uso/ambiente; senão o do bot). Nunca chama `process.exit`. */\nexport async function runCli(argv: string[], overrides: Partial<CliDeps> = {}): Promise<number> {\n  const deps = { ...defaultDeps(), ...overrides };\n  if (wantsHelp(argv)) {\n    deps.stdout(USAGE);\n    return 0;\n  }\n  let command: RunCommand;\n  try {\n    command = parseRunArgs(argv, deps.cwd);\n  } catch (error) {\n    if (!(error instanceof CliError)) throw error;\n    deps.stderr(`[hobots] ERROR ${error.message}`);\n    if (error.usage) deps.stderr(USAGE);\n    return 2;\n  }\n\n  return new Promise<number>(resolveCode => {\n    const child = deps.spawn(deps.execPath, [command.entry, ...command.botArgs], {\n      stdio: 'inherit',\n      env: childEnv(command, deps.env),\n      cwd: deps.cwd,\n    });\n    // Ctrl+C chega aos dois pelo terminal; repassar cobre o `kill` só no pai — e o pai espera o\n    // bot imprimir o `[hobots:summary]` e sair com 130 em vez de morrer na frente dele. A CLI\n    // nunca mata o filho por conta própria: quem decide o fim é o bot (graça de 4 s do SDK)\n    const forward = (signal: NodeJS.Signals) => (): void => void child.kill(signal);\n    const onInt = forward('SIGINT');\n    const onTerm = forward('SIGTERM');\n    deps.signals.on('SIGINT', onInt);\n    deps.signals.on('SIGTERM', onTerm);\n    const cleanup = (): void => {\n      deps.signals.off('SIGINT', onInt);\n      deps.signals.off('SIGTERM', onTerm);\n    };\n    child.once('error', error => {\n      cleanup();\n      deps.stderr(`[hobots] ERROR não foi possível executar ${command.entry}: ${error.message}`);\n      resolveCode(2);\n    });\n    child.once('exit', (code, signal) => {\n      cleanup();\n      resolveCode(code ?? signalExitCode(signal));\n    });\n  });\n}\n\n/* v8 ignore start -- ponto de entrada do binário (dist/cli.cjs executado diretamente); a suíte importa o módulo */\nif (typeof require !== 'undefined' && typeof module !== 'undefined' && require.main === module) {\n  void runCli(process.argv.slice(2)).then(code => process.exit(code));\n}\n/* v8 ignore stop */\n","import type { EnvironmentInput } from './environment-protocol';\nimport { isNode } from './utils';\n\nexport const INSTANCE_ID_ENV = 'HOBOTS_INSTANCE_ID';\nexport const ENVIRONMENT_ENV = 'HOBOTS_ENVIRONMENT';\nexport const RUN_ID_ENV = 'HOBOTS_RUN_ID';\n/** Modo local (teste sem a Central): `HOBOTS_LOCAL_RUN=1` — handler uma vez, sem rede, params de `HOBOTS_RUN_PARAMS`. */\nexport const LOCAL_RUN_ENV = 'HOBOTS_LOCAL_RUN';\n/** Params da execução no modo local: um objeto JSON (ausente/vazio = `{}`). */\nexport const RUN_PARAMS_ENV = 'HOBOTS_RUN_PARAMS';\n\nlet dotenvLoaded = false;\n\n/**\n * Carrega o `.env` da pasta de trabalho (`process.cwd()`) em `process.env`, uma vez por\n * processo: o bot não precisa de `dotenv` nem de `--env-file` para o SDK (e o próprio\n * código do bot) acharem `HOBOTS_CLIENT_SECRET` & cia. Usa o parser nativo do Node\n * (`process.loadEnvFile`, Node ≥ 20.12) — síncrono, porque `register()`/`start()` resolvem\n * as credenciais na hora. A env já definida no ambiente **vence** o arquivo. Sem `.env`\n * (ou em runtime sem `loadEnvFile`), não faz nada; erro de leitura vira um aviso que cita\n * só o código do erro, nunca o conteúdo do arquivo.\n */\nexport function loadDotenv(): void {\n  if (dotenvLoaded) return;\n  dotenvLoaded = true;\n  if (!isNode() || typeof process.loadEnvFile !== 'function') return;\n  try {\n    process.loadEnvFile('.env');\n  } catch (err) {\n    const code = (err as { code?: unknown } | null)?.code;\n    if (code === 'ENOENT') return;\n    console.warn(`[hobots] não foi possível ler o .env da pasta de trabalho (${typeof code === 'string' ? code : 'erro desconhecido'}) — seguindo só com as variáveis do ambiente`);\n  }\n}\n\n/** Só para testes: permite carregar o `.env` de novo. */\nexport function _resetDotenvForTesting(): void {\n  dotenvLoaded = false;\n}\n\n/** instanceId da opção ou da env — sem os dois, `undefined` (o fallback é o hostname, assíncrono). */\nexport function resolveInstanceId(option: string | undefined): string | undefined {\n  const fromOption = option?.trim();\n  if (fromOption) return fromOption;\n  if (typeof process === 'undefined' || !process.env) return undefined;\n  return process.env[INSTANCE_ID_ENV]?.trim() || undefined;\n}\n\n/**\n * Run a que o register() se anexa (opção → env HOBOTS_RUN_ID). Sem as duas, `undefined`:\n * o agente segue no poll de sempre.\n */\nexport function resolveRunId(option: string | undefined): string | undefined {\n  const fromOption = option?.trim();\n  if (fromOption) return fromOption;\n  if (typeof process === 'undefined' || !process.env) return undefined;\n  return process.env[RUN_ID_ENV]?.trim() || undefined;\n}\n\n/** Modo local ligado (`HOBOTS_LOCAL_RUN=1`): sem Central, sem secret, sem rede. */\nexport function isLocalRun(): boolean {\n  if (typeof process === 'undefined' || !process.env) return false;\n  return process.env[LOCAL_RUN_ENV]?.trim() === '1';\n}\n\n/**\n * Params do modo local: JSON de `HOBOTS_RUN_PARAMS` (ausente ou vazio = `{}`). Lança com o\n * motivo quando o valor não é um objeto JSON válido — quem chama imprime e encerra com código 2.\n */\nexport function resolveLocalRunParams(): Record<string, unknown> {\n  const raw = process.env[RUN_PARAMS_ENV]?.trim();\n  if (!raw) return {};\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    throw new Error(`${RUN_PARAMS_ENV} inválido: não é JSON válido`);\n  }\n  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {\n    throw new Error(`${RUN_PARAMS_ENV} inválido: esperado um objeto JSON`);\n  }\n  return parsed as Record<string, unknown>;\n}\n\n/** environment da opção ou da env — sem os dois, `undefined` (quem decide o default 'production' é o Client). */\nexport function resolveEnvironmentOption(option: EnvironmentInput | undefined): EnvironmentInput | undefined {\n  const fromOption = option?.trim();\n  if (fromOption) return fromOption;\n  if (typeof process === 'undefined' || !process.env) return undefined;\n  return process.env[ENVIRONMENT_ENV]?.trim() || undefined;\n}\n\n/**\n * Último recurso para a identidade da instância: o hostname da máquina. Import dinâmico\n * de node:os (o bundle é neutro); fora de Node, 'browser'.\n */\nexport async function fallbackInstanceId(): Promise<string> {\n  if (!isNode()) return 'browser';\n  try {\n    const os = await import('node:os');\n    return os.hostname() || 'unknown-host';\n  } catch {\n    return 'unknown-host';\n  }\n}\n"],"mappings":"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","names":["osConstants","nodeSpawn"]}