@jaimevalasek/aioson 1.4.0 → 1.5.1

package/src/commands/squad-daemon.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { SquadDaemon } = require('../squad-daemon');
+const { openRuntimeDb } = require('../runtime-store');
+
+async function handleStart(projectDir, squadSlug, options, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  let squadConfig = {};
+  try {
+    const squadJsonPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'squad.json');
+    squadConfig = JSON.parse(await fs.readFile(squadJsonPath, 'utf8'));
+  } catch { /* squad.json is optional */ }
+
+  const daemon = new SquadDaemon(projectDir, squadSlug, {
+    port: options.port ? Number(options.port) : 0,
+    poll: options.poll ? Number(options.poll) : 10000,
+    config: squadConfig
+  });
+
+  try {
+    const info = await daemon.start();
+    logger.log(t('squad_daemon.started', {
+      squad: squadSlug,
+      port: info.port,
+      workers: info.workers,
+      cron: info.cronJobs
+    }));
+    logger.log(t('squad_daemon.webhook_hint', { port: info.port }));
+    logger.log(t('squad_daemon.stop_hint'));
+
+    // Keep alive until signal
+    await new Promise((resolve) => {
+      process.on('SIGINT', resolve);
+      process.on('SIGTERM', resolve);
+    });
+
+    logger.log(t('squad_daemon.stopping'));
+    await daemon.stop();
+    return { ok: true, ...info };
+  } catch (err) {
+    logger.error(t('squad_daemon.start_failed', { error: err.message }));
+    return { ok: false, error: err.message };
+  }
+}
+
+async function handleStatus(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    // List all daemons
+    const handle = await openRuntimeDb(projectDir, { mustExist: true });
+    if (!handle) {
+      logger.error(t('squad_daemon.no_runtime'));
+      return { ok: false };
+    }
+    const { db } = handle;
+    try {
+      const daemons = db.prepare('SELECT * FROM squad_daemons ORDER BY squad_slug').all();
+      if (daemons.length === 0) {
+        logger.log(t('squad_daemon.no_daemons'));
+        return { ok: true, daemons: [] };
+      }
+      logger.log(`Daemons (${daemons.length}):`);
+      for (const d of daemons) {
+        const icon = d.status === 'running' ? '[*]' : '[ ]';
+        logger.log(`  ${icon} ${d.squad_slug} (${d.status}) port:${d.port || '-'} pid:${d.pid || '-'} heartbeat:${d.last_heartbeat || '-'}`);
+      }
+      return { ok: true, daemons };
+    } finally {
+      db.close();
+    }
+  }
+
+  // Specific squad daemon status
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const record = db.prepare('SELECT * FROM squad_daemons WHERE squad_slug = ?').get(squadSlug);
+    if (!record) {
+      logger.log(t('squad_daemon.not_found', { squad: squadSlug }));
+      return { ok: true, daemon: null };
+    }
+    logger.log(`Daemon: ${record.squad_slug}`);
+    logger.log(`  Status: ${record.status}`);
+    logger.log(`  PID: ${record.pid || '-'}`);
+    logger.log(`  Port: ${record.port || '-'}`);
+    logger.log(`  Started: ${record.started_at || '-'}`);
+    logger.log(`  Heartbeat: ${record.last_heartbeat || '-'}`);
+    if (record.error_message) logger.log(`  Error: ${record.error_message}`);
+    if (record.config_json) {
+      try {
+        const config = JSON.parse(record.config_json);
+        if (config.cronJobs && config.cronJobs.length > 0) {
+          logger.log(`  Cron Jobs:`);
+          for (const job of config.cronJobs) {
+            logger.log(`    - ${job.worker} (${job.cron})`);
+          }
+        }
+      } catch { /* ignore */ }
+    }
+    return { ok: true, daemon: record };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleStop(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const record = db.prepare('SELECT * FROM squad_daemons WHERE squad_slug = ?').get(squadSlug);
+    if (!record || record.status !== 'running') {
+      logger.log(t('squad_daemon.not_running', { squad: squadSlug }));
+      return { ok: true };
+    }
+
+    // Try to kill the process
+    if (record.pid) {
+      try {
+        process.kill(record.pid, 'SIGTERM');
+        logger.log(t('squad_daemon.signal_sent', { squad: squadSlug, pid: record.pid }));
+      } catch {
+        logger.log(t('squad_daemon.process_gone', { squad: squadSlug }));
+      }
+    }
+
+    // Update record
+    db.prepare(
+      "UPDATE squad_daemons SET status = 'stopped' WHERE squad_slug = ?"
+    ).run(squadSlug);
+
+    return { ok: true };
+  } finally {
+    db.close();
+  }
+}
+
+async function handleLogs(projectDir, squadSlug, { logger, t }) {
+  if (!squadSlug) {
+    logger.error(t('squad_daemon.squad_required'));
+    return { ok: false };
+  }
+
+  // Show recent worker runs as daemon logs
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) {
+    logger.error(t('squad_daemon.no_runtime'));
+    return { ok: false };
+  }
+  const { db } = handle;
+  try {
+    const runs = db.prepare(
+      'SELECT * FROM worker_runs WHERE squad_slug = ? ORDER BY created_at DESC LIMIT 30'
+    ).all(squadSlug);
+    if (runs.length === 0) {
+      logger.log(t('squad_daemon.no_logs'));
+      return { ok: true, runs: [] };
+    }
+    logger.log(`Recent daemon activity for "${squadSlug}" (${runs.length}):`);
+    for (const r of runs) {
+      const icon = r.status === 'completed' ? '[ok]' : r.status === 'failed' ? '[!!]' : '[..]';
+      const ms = r.duration_ms ? `${r.duration_ms}ms` : '-';
+      logger.log(`  ${icon} ${r.created_at} ${r.worker_slug} (${r.trigger_type}) ${ms}`);
+      if (r.error_message) logger.log(`       ${r.error_message}`);
+    }
+    return { ok: true, runs };
+  } finally {
+    db.close();
+  }
+}
+
+async function runSquadDaemon({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const sub = options.sub || 'status';
+  const squadSlug = options.squad;
+
+  switch (sub) {
+    case 'start':
+      return handleStart(targetDir, squadSlug, options, { logger, t });
+    case 'status':
+      return handleStatus(targetDir, squadSlug, { logger, t });
+    case 'stop':
+      return handleStop(targetDir, squadSlug, { logger, t });
+    case 'logs':
+      return handleLogs(targetDir, squadSlug, { logger, t });
+    default:
+      logger.error(t('squad_daemon.unknown_sub', { sub }));
+      return { ok: false };
+  }
+}
+
+module.exports = { runSquadDaemon };

package/src/commands/squad-dashboard.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const path = require('node:path');
+const { createDashboardServer } = require('../squad-dashboard/server');
+
+async function runSquadDashboard({ args, options, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const port = Number(options.port) || 4180;
+  const filterSquad = options.squad || null;
+
+  const dashboard = createDashboardServer(targetDir, { port, squad: filterSquad });
+
+  try {
+    const info = await dashboard.start();
+    logger.log(t('squad_dashboard.started', { url: info.url, port: info.port }));
+    if (filterSquad) {
+      logger.log(t('squad_dashboard.filtered', { squad: filterSquad }));
+    }
+    logger.log(t('squad_dashboard.stop_hint'));
+
+    // Keep the process alive until SIGINT/SIGTERM
+    await new Promise((resolve) => {
+      process.on('SIGINT', resolve);
+      process.on('SIGTERM', resolve);
+    });
+
+    logger.log(t('squad_dashboard.stopping'));
+    await dashboard.stop();
+    return { ok: true, port: info.port, url: info.url };
+  } catch (err) {
+    if (err.code === 'EADDRINUSE') {
+      logger.error(t('squad_dashboard.port_in_use', { port }));
+      return { ok: false, error: `Port ${port} already in use` };
+    }
+    throw err;
+  }
+}
+
+module.exports = { runSquadDashboard };

package/src/commands/squad-deploy.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+async function runSquadDeploy({ args, options, logger }) {
+  const squadSlug = args[0] || options.squad;
+  const projectDir = path.resolve(args[1] || options.path || '.');
+  const provider = options.provider || 'cloudpanel';
+
+  if (!squadSlug) {
+    logger.log('Uso: aioson squad:deploy <squad> [dir] --provider=cloudpanel');
+    return { ok: false };
+  }
+
+  const squadJsonPath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'squad.json');
+  let squadConfig;
+  try {
+    squadConfig = JSON.parse(await fs.readFile(squadJsonPath, 'utf8'));
+  } catch {
+    logger.log(`Squad "${squadSlug}" não encontrado em ${squadJsonPath}`);
+    return { ok: false, error: 'squad_not_found' };
+  }
+
+  const port = squadConfig.port || 3001;
+  const deployDir = path.join(projectDir, '.aioson', 'squads', squadSlug, 'deploy');
+  await fs.mkdir(deployDir, { recursive: true });
+
+  const nginxConf = generateNginxConf(squadSlug, port, provider);
+  const outPath = path.join(deployDir, 'nginx.conf');
+  await fs.writeFile(outPath, nginxConf);
+
+  logger.log(`✓ Configuração nginx gerada: ${outPath}`);
+  logger.log('');
+  logger.log('Instruções CloudPanel:');
+  logger.log('  1. Acesse CloudPanel → Websites → [seu site] → Nginx');
+  logger.log('  2. Cole o conteúdo do arquivo nginx.conf em "Custom Nginx Directives"');
+  logger.log('  3. Salve e aguarde o reload automático do nginx');
+  logger.log(`  4. Certifique-se que o daemon está rodando: aioson squad:daemon ${squadSlug} start`);
+
+  return { ok: true, path: outPath };
+}
+
+function generateNginxConf(slug, port, provider) {
+  return [
+    `# Squad: ${slug} — gerado por aioson squad:deploy`,
+    `# Provider: ${provider}`,
+    `# Cole em: CloudPanel → Website → Nginx → Custom Nginx Directives`,
+    `#`,
+    `# Pré-requisito: aioson squad:daemon ${slug} start`,
+    ``,
+    `location /${slug}/webhook/ {`,
+    `    proxy_pass http://127.0.0.1:${port}/webhook/;`,
+    `    proxy_http_version 1.1;`,
+    `    proxy_set_header Host $host;`,
+    `    proxy_set_header X-Real-IP $remote_addr;`,
+    `    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;`,
+    `    proxy_read_timeout 30s;`,
+    `    proxy_connect_timeout 5s;`,
+    `}`,
+  ].join('\n');
+}
+
+module.exports = { runSquadDeploy, generateNginxConf };

package/src/commands/squad-doctor.js

@@ -5,6 +5,7 @@ const path = require('node:path');
 const { openRuntimeDb } = require('../runtime-store');
 const { exists } = require('../utils');
 const { runSquadValidate } = require('./squad-validate');
+const { scoreCompletude, scoreProfundidade, scoreQualidadeEstrutural, scorePotencial, gradeFromScore } = require('./squad-score');
 
 function normalizeRel(value) {
   return String(value || '')
@@ -259,6 +260,36 @@ async function runSquadDoctor({ args, options = {}, logger, t }) {
     ));
   }
 
+  // Webhook production checks (from squad.json, optional file)
+  const squadJsonPath = path.join(paths.packageDir, 'squad.json');
+  let squadConfig = null;
+  try {
+    const raw = await fs.readFile(squadJsonPath, 'utf8');
+    squadConfig = JSON.parse(raw);
+  } catch { /* squad.json is optional */ }
+
+  if (squadConfig && squadConfig.webhook?.validate_signature) {
+    const envKey = squadConfig.webhook.signature_env || 'WEBHOOK_SECRET';
+    const defined = Boolean(process.env[envKey]);
+    checks.push(makeCheck(
+      `webhook_env_${envKey}`,
+      defined,
+      defined ? 'info' : 'error',
+      defined
+        ? `Env ${envKey} definida (HMAC validation enabled)`
+        : `Env ${envKey} não definida — webhook HMAC validation está ativo mas a variável está ausente`
+    ));
+  }
+
+  if (squadConfig && squadConfig.webhook?.public) {
+    checks.push(makeCheck(
+      'webhook_public_deploy',
+      null,
+      'warn',
+      'Config nginx: execute aioson squad:deploy para gerar nginx.conf'
+    ));
+  }
+
   const runtimeHandle = await openRuntimeDb(targetDir, { mustExist: true });
   if (!runtimeHandle) {
     checks.push(makeCheck('runtime_store', false, 'warn', t('squad_doctor.check_runtime_missing')));
@@ -347,6 +378,27 @@ async function runSquadDoctor({ args, options = {}, logger, t }) {
     checks.push(makeCheck('formal_validation', true, 'info', 'Manifest formally valid'));
   }
 
+  // Quality score
+  try {
+    const d1 = scoreCompletude(manifest);
+    const d2 = scoreProfundidade(manifest);
+    const d3 = scoreQualidadeEstrutural(manifest);
+    const d4 = scorePotencial(manifest);
+    const total = d1.score + d2.score + d3.score + d4.score;
+    const maxTotal = d1.max + d2.max + d3.max + d4.max;
+    const grade = gradeFromScore(total);
+    const isLow = total < 50;
+    checks.push(
+      makeCheck(
+        'quality_score',
+        !isLow,
+        'info',
+        `Quality score: ${total}/${maxTotal} — ${grade}`,
+        { qualityScore: { total, max: maxTotal, grade } }
+      )
+    );
+  } catch { /* scoring not critical */ }
+
   const summary = {
     failed: checks.filter((check) => check.severity === 'error' && !check.ok).length,
     warned: checks.filter((check) => check.severity === 'warn' && !check.ok).length,

package/src/commands/squad-mcp.js

@@ -0,0 +1,270 @@
+'use strict';
+
+const path = require('node:path');
+const { openRuntimeDb, upsertMcpStatus, listMcpStatus, getMcpStatus } = require('../runtime-store');
+const {
+  listBuiltInConnectors,
+  getBuiltInConnector,
+  loadIntegrationConfig,
+  saveIntegrationConfig,
+  listIntegrations,
+  resolveConnectorEnv,
+  runHealthCheck,
+  runAction
+} = require('../mcp-connectors/registry');
+
+async function runSquadMcp({ args, options, logger, t }) {
+  const projectDir = path.resolve(args[0] || options.path || '.');
+  const squadSlug = options.squad;
+  const sub = options.sub || 'status';
+
+  if (!squadSlug) {
+    logger.log(t('squad_mcp.squad_required'));
+    return { ok: false, error: 'squad_required' };
+  }
+
+  if (sub === 'connectors') {
+    return handleConnectors({ logger, t });
+  }
+  if (sub === 'status') {
+    return handleStatus({ projectDir, squadSlug, logger, t });
+  }
+  if (sub === 'configure') {
+    return handleConfigure({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'test') {
+    return handleTest({ projectDir, squadSlug, options, logger, t });
+  }
+  if (sub === 'call') {
+    return handleCall({ projectDir, squadSlug, options, logger, t });
+  }
+
+  logger.log(t('squad_mcp.unknown_sub', { sub }));
+  return { ok: false, error: 'unknown_sub' };
+}
+
+function handleConnectors({ logger, t }) {
+  const connectors = listBuiltInConnectors();
+  logger.log(t('squad_mcp.connectors_title'));
+  for (const c of connectors) {
+    logger.log(`  ${c.id} — ${c.name}`);
+    logger.log(`    ${t('squad_mcp.actions')}: ${c.actions.join(', ')}`);
+    logger.log(`    ${t('squad_mcp.required_config')}: ${c.requiredConfig.join(', ') || 'none'}`);
+    logger.log('');
+  }
+  return { ok: true, connectors };
+}
+
+async function handleStatus({ projectDir, squadSlug, logger, t }) {
+  const integrations = await listIntegrations(projectDir, squadSlug);
+
+  if (integrations.length === 0) {
+    logger.log(t('squad_mcp.no_integrations', { squad: squadSlug }));
+    return { ok: true, integrations: [] };
+  }
+
+  let handle;
+  try {
+    handle = await openRuntimeDb(projectDir);
+  } catch {
+    handle = null;
+  }
+
+  const results = [];
+  for (const integ of integrations) {
+    const connectorDef = getBuiltInConnector(integ.connector);
+    let status = 'unknown';
+    let missing = [];
+    if (connectorDef) {
+      const env = resolveConnectorEnv(connectorDef, integ.config);
+      status = env.status;
+      missing = env.missing;
+    }
+
+    let dbStatus = null;
+    if (handle) {
+      dbStatus = getMcpStatus(handle.db, squadSlug, integ.slug);
+    }
+
+    const entry = {
+      slug: integ.slug,
+      connector: integ.connector,
+      status: dbStatus ? dbStatus.status : status,
+      missing,
+      calls_total: dbStatus ? dbStatus.calls_total : 0,
+      calls_failed: dbStatus ? dbStatus.calls_failed : 0
+    };
+    results.push(entry);
+
+    const statusIcon = entry.status === 'connected' ? '+' : entry.status === 'configured' ? '~' : '-';
+    logger.log(`  [${statusIcon}] ${integ.slug} (${integ.connector}) — ${entry.status}`);
+    if (missing.length > 0) {
+      logger.log(`      ${t('squad_mcp.missing_config')}: ${missing.join(', ')}`);
+    }
+    if (entry.calls_total > 0) {
+      logger.log(`      ${t('squad_mcp.calls')}: ${entry.calls_total} (${entry.calls_failed} failed)`);
+    }
+  }
+
+  if (handle) handle.db.close();
+  return { ok: true, integrations: results };
+}
+
+async function handleConfigure({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  const connector = options.connector;
+
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+  if (!connector) {
+    logger.log(t('squad_mcp.connector_required'));
+    return { ok: false, error: 'connector_required' };
+  }
+
+  const connectorDef = getBuiltInConnector(connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  // Build config from --key=value options
+  const config = {};
+  for (const [key] of Object.entries(connectorDef.configSchema)) {
+    if (options[key] !== undefined) {
+      config[key] = options[key];
+    }
+  }
+
+  const integrationConfig = { connector, config };
+  await saveIntegrationConfig(projectDir, squadSlug, mcpSlug, integrationConfig);
+
+  // Check resolution
+  const { status, missing } = resolveConnectorEnv(connectorDef, config);
+
+  // Update SQLite status
+  try {
+    const handle = await openRuntimeDb(projectDir);
+    upsertMcpStatus(handle.db, { squadSlug, mcpSlug, connector, status, lastError: null });
+    handle.db.close();
+  } catch { /* SQLite optional */ }
+
+  logger.log(t('squad_mcp.configured', { mcp: mcpSlug, connector, status }));
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.still_missing', { keys: missing.join(', ') }));
+  }
+  return { ok: true, slug: mcpSlug, connector, status, missing };
+}
+
+async function handleTest({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+
+  const config = await loadIntegrationConfig(projectDir, squadSlug, mcpSlug);
+  if (!config) {
+    logger.log(t('squad_mcp.not_configured', { mcp: mcpSlug }));
+    return { ok: false, error: 'not_configured' };
+  }
+
+  const connectorDef = getBuiltInConnector(config.connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector: config.connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  const { resolved, missing, status } = resolveConnectorEnv(connectorDef, config.config);
+
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.test_missing', { mcp: mcpSlug, keys: missing.join(', ') }));
+
+    try {
+      const handle = await openRuntimeDb(projectDir);
+      upsertMcpStatus(handle.db, { squadSlug, mcpSlug, connector: config.connector, status: 'unconfigured', lastError: `Missing: ${missing.join(', ')}` });
+      handle.db.close();
+    } catch { /* optional */ }
+
+    return { ok: false, error: 'missing_config', missing };
+  }
+
+  logger.log(t('squad_mcp.testing_connection'));
+  const health = await runHealthCheck(config.connector, resolved);
+
+  const healthStatus = health.ok ? 'connected' : 'error';
+  try {
+    const handle = await openRuntimeDb(projectDir);
+    upsertMcpStatus(handle.db, {
+      squadSlug, mcpSlug,
+      connector: config.connector,
+      status: healthStatus,
+      lastCheck: new Date().toISOString(),
+      lastError: health.ok ? null : (health.error || String(health.statusCode))
+    });
+    handle.db.close();
+  } catch { /* optional */ }
+
+  if (health.skipped) {
+    logger.log(t('squad_mcp.health_skipped'));
+    return { ok: true, slug: mcpSlug, status: 'skipped' };
+  }
+  if (health.ok) {
+    logger.log(t('squad_mcp.health_ok', { statusCode: health.statusCode }));
+    return { ok: true, slug: mcpSlug, status: 'connected', statusCode: health.statusCode };
+  }
+  logger.log(t('squad_mcp.health_error', { error: health.error || health.statusCode }));
+  return { ok: false, slug: mcpSlug, status: 'error', error: health.error };
+}
+
+async function handleCall({ projectDir, squadSlug, options, logger, t }) {
+  const mcpSlug = options.mcp;
+  const actionSlug = options.action;
+
+  if (!mcpSlug) {
+    logger.log(t('squad_mcp.mcp_required'));
+    return { ok: false, error: 'mcp_required' };
+  }
+  if (!actionSlug) {
+    logger.log(t('squad_mcp.action_required'));
+    return { ok: false, error: 'action_required' };
+  }
+
+  let input;
+  try {
+    input = JSON.parse(options.input || '{}');
+  } catch {
+    logger.log(t('squad_mcp.invalid_input'));
+    return { ok: false, error: 'invalid_input' };
+  }
+
+  const config = await loadIntegrationConfig(projectDir, squadSlug, mcpSlug);
+  if (!config) {
+    logger.log(t('squad_mcp.not_configured', { mcp: mcpSlug }));
+    return { ok: false, error: 'not_configured' };
+  }
+
+  const connectorDef = getBuiltInConnector(config.connector);
+  if (!connectorDef) {
+    logger.log(t('squad_mcp.unknown_connector', { connector: config.connector }));
+    return { ok: false, error: 'unknown_connector' };
+  }
+
+  const { resolved, missing } = resolveConnectorEnv(connectorDef, config.config);
+  if (missing.length > 0) {
+    logger.log(t('squad_mcp.test_missing', { mcp: mcpSlug, keys: missing.join(', ') }));
+    return { ok: false, error: 'missing_config', missing };
+  }
+
+  const result = await runAction(config.connector, actionSlug, input, resolved);
+
+  if (result.ok) {
+    logger.log(JSON.stringify(result.result, null, 2));
+  } else {
+    logger.log(`Error: ${result.error}`);
+  }
+  return result;
+}
+
+module.exports = { runSquadMcp };