@jaimevalasek/aioson 1.4.0 → 1.5.1

package/src/i18n/messages/pt-BR.js

@@ -59,6 +59,10 @@ module.exports = {
       'aioson qa:scan [path] [--url=<app-url>] [--depth=3] [--max-pages=50] [--headed] [--html] [--json] [--locale=pt-BR]',
     help_qa_report:
       'aioson qa:report [path] [--html] [--json] [--locale=pt-BR]',
+    help_web_map:
+      'aioson web:map [path] --url=<url> [--depth=<N>] [--max-pages=<N>] [--include-external] [--json] [--locale=pt-BR]',
+    help_web_scrape:
+      'aioson web:scrape [path] --url=<url> [--format=markdown|text|html|links] [--json] [--locale=pt-BR]',
     help_scan_project:
       'aioson scan:project [path] --folder=<pasta[,pasta2]> [--summary-mode=titles|summaries|raw] [--context-mode=merge|rewrite] [--with-llm] [--provider=<name>] [--llm-model=<name>] [--dry-run] [--json] [--locale=pt-BR]',
     help_config:
@@ -85,6 +89,18 @@ module.exports = {
       'aioson squad:investigate [path] [--sub=list|show|score|link|register] [--investigation=<slug>] [--squad=<slug>] [--locale=pt-BR]',
     help_squad_learning:
       'aioson squad:learning [path] [--sub=list|stats|archive|promote|export] [--squad=<slug>] [--status=<status>] [--locale=pt-BR]',
+    help_squad_dashboard:
+      'aioson squad:dashboard [path] [--port=4180] [--squad=<slug>] [--locale=pt-BR]',
+    help_squad_worker:
+      'aioson squad:worker [path] [--sub=list|run|test|logs|scaffold] [--squad=<slug>] [--worker=<slug>] [--input=<json>] [--locale=pt-BR]',
+    help_squad_daemon:
+      'aioson squad:daemon [path] [--sub=start|status|stop|logs] [--squad=<slug>] [--port=<N>] [--locale=pt-BR]',
+    help_squad_mcp:
+      'aioson squad:mcp [path] [--sub=status|connectors|configure|test] [--squad=<slug>] [--mcp=<slug>] [--connector=<id>]',
+    help_squad_roi:
+      'aioson squad:roi [path] [--sub=config|metric|report|export] [--squad=<slug>] [--key=<metrica>] [--value=<N>]',
+    help_squad_score:
+      'aioson squad:score [path] --squad=<slug> [--locale=pt-BR]',
     help_learning:
       'aioson learning [path] [--sub=list|stats|promote] [--status=<status>] [--id=<learning-id>] [--locale=pt-BR]',
     help_runtime_init:
@@ -758,6 +774,23 @@ module.exports = {
     not_found: 'Nenhum relatorio QA encontrado. Execute: aioson qa:run ou aioson qa:scan',
     html_report_written: 'Relatorio HTML escrito: {path}'
   },
+  web_map: {
+    url_missing: 'Opcao obrigatoria ausente: --url=<url>.',
+    starting: 'Mapeando site: {url}',
+    pages_found: 'Paginas descobertas: {count}',
+    page_line: '- {url} | profundidade={depth} | status={status} | links={links}',
+    done: 'Mapa web concluido.',
+    failed: 'Falha no mapa web: {error}'
+  },
+  web_scrape: {
+    url_missing: 'Opcao obrigatoria ausente: --url=<url>.',
+    invalid_format: 'Valor invalido para --format: {format}. Use markdown, text, html ou links.',
+    fetching: 'Buscando pagina: {url}',
+    title_line: 'Titulo: {title}',
+    status_line: 'Status: {status} | Content-Type: {type}',
+    done: 'Web scrape concluido ({format}).',
+    failed: 'Falha no web scrape: {error}'
+  },
   config: {
     usage_error:
       'Uso: aioson config <set KEY=value|show|get KEY> [--json] [--locale=pt-BR]',
@@ -841,7 +874,9 @@ module.exports = {
     sessions: '    Sessoes     : {count} ({path})',
     latest_html: '    Latest HTML : {value}',
     logs: '    Logs        : {count} ({path})',
-    genomes: '    Genomes     : {count} no squad / {agent_count} vinculos por agente'
+    genomes: '    Genomes     : {count} no squad / {agent_count} vinculos por agente',
+    model_tiers: '    Model Tiers : {value}',
+    estimated_cost: '    Custo Est.  : ~${value}/run'
   },
   squad_agent_create: {
     no_name: 'Uso: aioson squad:agent-create [path] --name=<nome-agente> [--type=agent|assistant|clone|worker] [--scope=my-agents|squad] [--squad=<slug>]',
@@ -965,6 +1000,96 @@ module.exports = {
     registered: 'Investigacao registrada: {slug} ({path})',
     unknown_sub: 'Subcomando desconhecido: {sub}. Use: list, show, score, link, register.'
   },
+  squad_daemon: {
+    squad_required: 'Slug do squad e obrigatorio. Use --squad=<slug>.',
+    started: 'Daemon iniciado para squad "{squad}" na porta {port} ({workers} workers, {cron} cron jobs)',
+    webhook_hint: 'Endpoint webhook: POST http://127.0.0.1:{port}/webhook/<worker-slug>',
+    stop_hint: 'Pressione Ctrl+C para parar.',
+    stopping: 'Parando daemon...',
+    start_failed: 'Falha ao iniciar daemon: {error}',
+    no_runtime: 'Runtime store nao encontrado. Execute aioson runtime:init primeiro.',
+    no_daemons: 'Nenhum registro de daemon encontrado.',
+    not_found: 'Nenhum registro de daemon para o squad: {squad}',
+    not_running: 'O daemon do squad "{squad}" nao esta rodando.',
+    signal_sent: 'SIGTERM enviado ao daemon de "{squad}" (pid {pid}).',
+    process_gone: 'O processo do daemon de "{squad}" nao esta mais rodando.',
+    no_logs: 'Nenhum log de atividade do daemon encontrado.',
+    unknown_sub: 'Subcomando desconhecido: {sub}. Use: start, status, stop, logs.'
+  },
+
+  squad_mcp: {
+    squad_required: 'Slug do squad e obrigatorio. Use --squad=<slug>.',
+    connectors_title: 'Conectores MCP Integrados:',
+    actions: 'Acoes',
+    required_config: 'Obrigatorio',
+    no_integrations: 'Nenhuma integracao configurada para o squad "{squad}".',
+    missing_config: 'Config ausente',
+    calls: 'Chamadas',
+    mcp_required: 'Slug do MCP e obrigatorio. Use --mcp=<slug>.',
+    connector_required: 'ID do conector e obrigatorio. Use --connector=<id>.',
+    unknown_connector: 'Conector desconhecido: {connector}. Use --sub=connectors para listar.',
+    configured: 'Integracao "{mcp}" configurada com conector "{connector}" (status: {status}).',
+    still_missing: 'Ainda faltam env/config: {keys}',
+    not_configured: 'Integracao "{mcp}" nao esta configurada.',
+    test_missing: 'Integracao "{mcp}" tem config ausente: {keys}',
+    test_ok: 'Integracao "{mcp}" ({connector}) — config OK.',
+    health_url: 'URL de health check: {url}',
+    testing_connection: 'Testando conexao...',
+    health_ok: 'Conexao OK (HTTP {statusCode})',
+    health_error: 'Erro na conexao: {error}',
+    health_skipped: 'Verificacao de saude nao disponivel para este connector',
+    action_required: 'Slug da acao e obrigatorio. Use --action=<slug>.',
+    invalid_input: 'JSON invalido. Forneca JSON valido com --input.',
+    unknown_sub: 'Subcomando desconhecido: {sub}. Use: status, connectors, configure, test, call.'
+  },
+
+  squad_roi: {
+    squad_required: 'Slug do squad e obrigatorio. Use --squad=<slug>.',
+    config_saved: 'Config de ROI salva para o squad "{squad}".',
+    pricing_model: 'Modelo de precificacao',
+    setup_fee: 'Taxa de implantacao',
+    monthly_fee: 'Mensalidade',
+    percentage: 'Percentual',
+    contract: 'Contrato',
+    metric_required: 'Chave e valor da metrica sao obrigatorios. Use --key=<nome> --value=<N>.',
+    metric_saved: 'Metrica "{key}" = {value} salva para o squad "{squad}".',
+    no_metrics: 'Nenhuma metrica encontrada para o squad "{squad}".',
+    report_title: 'Relatorio de ROI — {squad}',
+    baseline: 'Baseline',
+    actual: 'Atual',
+    target: 'Meta',
+    period: 'Periodo',
+    cost_section: 'Resumo de Custos:',
+    monthly_cost: 'Custo mensal efetivo',
+    exported: 'Relatorio exportado para {file} ({format}).',
+    unknown_sub: 'Subcomando desconhecido: {sub}. Use: config, metric, report, export.'
+  },
+
+  squad_worker: {
+    squad_required: 'Slug do squad e obrigatorio. Use --squad=<slug>.',
+    no_workers: 'Nenhum worker encontrado para este squad.',
+    run_usage: 'Uso: aioson squad:worker --sub=run --squad=<slug> --worker=<slug> [--input=<json>]',
+    test_usage: 'Uso: aioson squad:worker --sub=test --squad=<slug> --worker=<slug>',
+    scaffold_usage: 'Uso: aioson squad:worker --sub=scaffold --squad=<slug> --worker=<slug> [--trigger=manual|event|scheduled]',
+    not_found: 'Worker nao encontrado: {worker}',
+    invalid_input: 'JSON invalido. Forneca JSON valido com --input.',
+    run_success: 'Worker "{worker}" concluido com sucesso.',
+    run_failed: 'Worker "{worker}" falhou: {error}',
+    test_passed: 'Worker "{worker}" teste aprovado.',
+    test_failed: 'Worker "{worker}" teste falhou: {error}',
+    scaffold_created: 'Worker "{worker}" criado em {path}',
+    no_runtime: 'Runtime store nao encontrado. Execute aioson runtime:init primeiro.',
+    no_logs: 'Nenhuma execucao de worker encontrada.',
+    unknown_sub: 'Subcomando desconhecido: {sub}. Use: list, run, test, logs, scaffold.'
+  },
+
+  squad_dashboard: {
+    started: 'Squad Dashboard rodando em {url} (porta {port})',
+    filtered: 'Filtrando para squad: {squad}',
+    stop_hint: 'Pressione Ctrl+C para parar.',
+    stopping: 'Parando Squad Dashboard...',
+    port_in_use: 'Porta {port} ja esta em uso. Tente --port=<outra>'
+  },
   implementation_plan: {
     not_found: 'Plano de implementacao nao encontrado: {file}',
     no_runtime: 'Runtime store nao encontrado. Execute aioson runtime:init primeiro.',

package/src/lib/webhook-server.js

@@ -0,0 +1,328 @@
+'use strict';
+
+const http = require('node:http');
+const https = require('node:https');
+const { randomBytes } = require('node:crypto');
+
+function generateRunId() {
+  return randomBytes(8).toString('hex');
+}
+
+function sendJSON(res, statusCode, data) {
+  const body = JSON.stringify(data);
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+
+function parseBody(req) {
+  return new Promise((resolve, reject) => {
+    let data = '';
+    req.on('data', chunk => { data += chunk; });
+    req.on('end', () => {
+      try {
+        resolve(data ? JSON.parse(data) : {});
+      } catch {
+        reject(new Error('Invalid JSON body'));
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+async function postCallback(url, payload, maxRetries = 3) {
+  const delays = [30000, 60000, 120000];
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      await new Promise((resolve, reject) => {
+        const body = JSON.stringify(payload);
+        let parsed;
+        try { parsed = new URL(url); } catch { return reject(new Error('Invalid callback URL')); }
+        const isHttps = parsed.protocol === 'https:';
+        const mod = isHttps ? https : http;
+        const opts = {
+          hostname: parsed.hostname,
+          port: parsed.port ? parseInt(parsed.port, 10) : (isHttps ? 443 : 80),
+          path: parsed.pathname + parsed.search,
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(body)
+          }
+        };
+        const req = mod.request(opts, res => {
+          res.resume();
+          if (res.statusCode >= 200 && res.statusCode < 300) resolve();
+          else reject(new Error(`Callback returned HTTP ${res.statusCode}`));
+        });
+        req.on('error', reject);
+        req.setTimeout(10000, () => { req.destroy(new Error('Callback timeout')); });
+        req.write(body);
+        req.end();
+      });
+      return; // success — stop retrying
+    } catch {
+      if (attempt < maxRetries) {
+        await new Promise(r => setTimeout(r, delays[attempt] || 120000));
+      }
+    }
+  }
+}
+
+class WebhookServer {
+  /**
+   * @param {object} options
+   * @param {number}   [options.port=3210]
+   * @param {string}   [options.token='']       Bearer token (empty = no auth)
+   * @param {number}   [options.rateLimit=60]   Max req/min per IP
+   * @param {Array}    [options.squads=[]]       [{name, timeout_ms}] — empty = all allowed
+   * @param {Function} [options.onTrigger]       async ({squad,input,session_id,metadata,run_id}) -> {response}
+   * @param {Function} [options.onQuery]         async ({squad,query,max_results}) -> {results}
+   * @param {string}   [options.version='0.0.0']
+   */
+  constructor(options = {}) {
+    this.port = options.port || 3210;
+    this.token = options.token || '';
+    this.rateLimit = options.rateLimit || 60;
+    this.allowedSquads = options.squads || [];
+    this.onTrigger = options.onTrigger || null;
+    this.onQuery = options.onQuery || null;
+    this.version = options.version || '0.0.0';
+
+    this._runs = new Map();       // run_id -> {status, response, error, session_id, metadata}
+    this._ipCounters = new Map(); // ip -> {count, windowStart}
+    this._server = null;
+  }
+
+  _checkRateLimit(ip) {
+    const now = Date.now();
+    const window = 60_000;
+    const entry = this._ipCounters.get(ip) || { count: 0, windowStart: now };
+    if (now - entry.windowStart > window) {
+      entry.count = 0;
+      entry.windowStart = now;
+    }
+    entry.count++;
+    this._ipCounters.set(ip, entry);
+    return entry.count <= this.rateLimit;
+  }
+
+  _validateToken(req) {
+    if (!this.token) return true;
+    const auth = req.headers['authorization'] || '';
+    const spaceIdx = auth.indexOf(' ');
+    if (spaceIdx === -1) return false;
+    const scheme = auth.slice(0, spaceIdx);
+    const tok = auth.slice(spaceIdx + 1);
+    return scheme === 'Bearer' && tok === this.token;
+  }
+
+  _getSquadNames() {
+    return this.allowedSquads.map(s => (typeof s === 'string' ? s : s.name));
+  }
+
+  _isSquadAllowed(squadName) {
+    if (this.allowedSquads.length === 0) return true;
+    return this._getSquadNames().includes(squadName);
+  }
+
+  _getSquadTimeout(squadName) {
+    const entry = this.allowedSquads.find(s => (typeof s === 'string' ? s : s.name) === squadName);
+    return (entry && entry.timeout_ms) || 120000;
+  }
+
+  async _handleTrigger(req, res) {
+    let body;
+    try {
+      body = await parseBody(req);
+    } catch {
+      return sendJSON(res, 400, { ok: false, error: 'Invalid JSON body' });
+    }
+
+    const { squad, input, session_id, callback_url, metadata } = body;
+
+    if (!squad) return sendJSON(res, 400, { ok: false, error: 'squad is required' });
+    if (!input) return sendJSON(res, 400, { ok: false, error: 'input is required' });
+
+    if (!this._isSquadAllowed(squad)) {
+      return sendJSON(res, 404, {
+        ok: false,
+        error: `Squad "${squad}" not found`,
+        available_squads: this._getSquadNames()
+      });
+    }
+
+    const run_id = generateRunId();
+    this._runs.set(run_id, { status: 'queued', response: null, error: null, session_id, metadata });
+
+    sendJSON(res, 202, { run_id, status: 'queued' });
+
+    setImmediate(async () => {
+      const run = this._runs.get(run_id);
+      run.status = 'running';
+
+      const timeoutMs = this._getSquadTimeout(squad);
+
+      let timeoutHandle;
+      try {
+        const execPromise = this.onTrigger
+          ? this.onTrigger({ squad, input, session_id, metadata, run_id })
+          : Promise.resolve({ response: `Squad ${squad} queued: ${input}` });
+
+        const timeoutPromise = new Promise((_, reject) => {
+          timeoutHandle = setTimeout(() => reject(new Error('Squad execution timed out')), timeoutMs);
+        });
+
+        const result = await Promise.race([execPromise, timeoutPromise]);
+        clearTimeout(timeoutHandle);
+        run.status = 'completed';
+        run.response = result.response || '';
+      } catch (err) {
+        clearTimeout(timeoutHandle);
+        run.status = 'failed';
+        run.error = err.message;
+      }
+
+      if (callback_url) {
+        const callbackPayload = {
+          run_id,
+          session_id,
+          response: run.response,
+          status: run.status,
+          metadata
+        };
+        postCallback(callback_url, callbackPayload).catch(() => {});
+      }
+    });
+  }
+
+  _handleStatus(runId, res) {
+    const run = this._runs.get(runId);
+    if (!run) return sendJSON(res, 404, { ok: false, error: 'Run not found' });
+    return sendJSON(res, 200, {
+      run_id: runId,
+      status: run.status,
+      response: run.response || null,
+      error: run.error || null
+    });
+  }
+
+  async _handleQuery(req, res) {
+    let body;
+    try {
+      body = await parseBody(req);
+    } catch {
+      return sendJSON(res, 400, { ok: false, error: 'Invalid JSON body' });
+    }
+
+    const { squad, query, max_results } = body;
+
+    if (!squad) return sendJSON(res, 400, { ok: false, error: 'squad is required' });
+    if (!query) return sendJSON(res, 400, { ok: false, error: 'query is required' });
+
+    if (!this._isSquadAllowed(squad)) {
+      return sendJSON(res, 404, {
+        ok: false,
+        error: `Squad "${squad}" not found`,
+        available_squads: this._getSquadNames()
+      });
+    }
+
+    const t0 = Date.now();
+    const QUERY_TIMEOUT_MS = 10_000;
+
+    let timeoutHandle;
+    try {
+      const execPromise = this.onQuery
+        ? this.onQuery({ squad, query, max_results: max_results || 10 })
+        : Promise.resolve({ results: [] });
+
+      const timeoutPromise = new Promise((_, reject) => {
+        timeoutHandle = setTimeout(() => reject(new Error('Query timed out')), QUERY_TIMEOUT_MS);
+      });
+
+      const result = await Promise.race([execPromise, timeoutPromise]);
+      clearTimeout(timeoutHandle);
+      const latency_ms = Date.now() - t0;
+
+      return sendJSON(res, 200, {
+        results: result.results || [],
+        squad,
+        latency_ms
+      });
+    } catch (err) {
+      clearTimeout(timeoutHandle);
+      const latency_ms = Date.now() - t0;
+      return sendJSON(res, 504, { ok: false, error: err.message, squad, latency_ms });
+    }
+  }
+
+  _handleHealth(res) {
+    return sendJSON(res, 200, {
+      ok: true,
+      version: this.version,
+      squads: this._getSquadNames()
+    });
+  }
+
+  async _handleRequest(req, res) {
+    const ip = req.socket.remoteAddress || '0.0.0.0';
+    const url = req.url || '/';
+    const method = req.method || 'GET';
+
+    if (!this._checkRateLimit(ip)) {
+      return sendJSON(res, 429, { ok: false, error: 'Too many requests' });
+    }
+
+    // Health check — no auth required
+    if (method === 'GET' && url === '/health') {
+      return this._handleHealth(res);
+    }
+
+    if (!this._validateToken(req)) {
+      return sendJSON(res, 401, { ok: false, error: 'Unauthorized' });
+    }
+
+    if (method === 'POST' && url === '/trigger') {
+      return this._handleTrigger(req, res);
+    }
+
+    if (method === 'POST' && url === '/query') {
+      return this._handleQuery(req, res);
+    }
+
+    const statusMatch = method === 'GET' && url.match(/^\/status\/([^/?]+)/);
+    if (statusMatch) {
+      return this._handleStatus(statusMatch[1], res);
+    }
+
+    return sendJSON(res, 404, { ok: false, error: 'Not found' });
+  }
+
+  start() {
+    return new Promise((resolve, reject) => {
+      this._server = http.createServer((req, res) => {
+        this._handleRequest(req, res).catch(() => {
+          sendJSON(res, 500, { ok: false, error: 'Internal server error' });
+        });
+      });
+      this._server.listen(this.port, () => resolve(this._server));
+      this._server.once('error', reject);
+    });
+  }
+
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (!this._server) return resolve();
+      // Close idle keep-alive connections so server.close() callback fires promptly
+      if (typeof this._server.closeIdleConnections === 'function') {
+        this._server.closeIdleConnections();
+      }
+      this._server.close(err => (err ? reject(err) : resolve()));
+    });
+  }
+}
+
+module.exports = { WebhookServer, postCallback };