@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/commands/skill.js

@@ -16,6 +16,47 @@ function resolveTargetDir(args) {
   return path.resolve(process.cwd(), args[0] || '.');
 }
 
+async function copyRecursive(src, dest) {
+  const stat = await fs.stat(src);
+  if (stat.isDirectory()) {
+    await ensureDir(dest);
+    const entries = await fs.readdir(src);
+    for (const entry of entries) {
+      await copyRecursive(path.join(src, entry), path.join(dest, entry));
+    }
+    return;
+  }
+
+  await ensureDir(path.dirname(dest));
+  await fs.copyFile(src, dest);
+}
+
+async function replaceDirectory(srcDir, destDir) {
+  await fs.rm(destDir, { recursive: true, force: true });
+  await copyRecursive(srcDir, destDir);
+}
+
+async function readJsonIfExists(filePath) {
+  if (!(await exists(filePath))) return null;
+  try {
+    return JSON.parse(await fs.readFile(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+async function writeSkillMeta(destDir, patch) {
+  const metaPath = path.join(destDir, '.skill-meta.json');
+  const existing = await readJsonIfExists(metaPath) || {};
+  const merged = {
+    ...existing,
+    ...patch
+  };
+
+  await fs.writeFile(metaPath, JSON.stringify(merged, null, 2), 'utf8');
+  return merged;
+}
+
 /**
  * Parse YAML frontmatter from a SKILL.md file.
  */
@@ -44,17 +85,7 @@ async function distributeToTool(targetDir, slug, skillDir) {
   for (const toolPath of TOOL_TARGETS) {
     const toolSkillDir = path.join(targetDir, toolPath, slug);
     try {
-      await ensureDir(toolSkillDir);
-      // Copy all files from the installed skill dir
-      const entries = await fs.readdir(skillDir);
-      for (const entry of entries) {
-        const src = path.join(skillDir, entry);
-        const dest = path.join(toolSkillDir, entry);
-        const stat = await fs.stat(src);
-        if (stat.isFile()) {
-          await fs.copyFile(src, dest);
-        }
-      }
+      await replaceDirectory(skillDir, toolSkillDir);
       results.push({ tool: toolPath, ok: true });
     } catch (err) {
       results.push({ tool: toolPath, ok: false, error: err.message });
@@ -187,12 +218,13 @@ async function installFromNpm(targetDir, slug, options, logger) {
 
       // Copy to .aioson/installed-skills/{slug}/
       const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
-      await ensureDir(destDir);
-
-      const entries = await fs.readdir(sourceDir);
-      for (const entry of entries) {
-        await fs.copyFile(path.join(sourceDir, entry), path.join(destDir, entry));
-      }
+      await replaceDirectory(sourceDir, destDir);
+      await writeSkillMeta(destDir, {
+        source: 'npm',
+        sourcePackage: '@tech-leads-club/agent-skills',
+        sourcePath: path.relative(targetDir, sourceDir),
+        installedAt: new Date().toISOString()
+      });
 
       resolve({ ok: true, sourceDir, destDir });
     });
@@ -248,15 +280,16 @@ async function installFromCloud(targetDir, slug, options, logger) {
   ].join('\n');
 
   const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
+  await fs.rm(destDir, { recursive: true, force: true });
   await ensureDir(destDir);
   await fs.writeFile(path.join(destDir, 'SKILL.md'), fm, 'utf8');
 
   // Write meta
-  await fs.writeFile(path.join(destDir, '.skill-meta.json'), JSON.stringify({
+  await writeSkillMeta(destDir, {
     source: 'cloud',
     cloudSlug: snapshot.skill.slug,
     installedAt: new Date().toISOString()
-  }, null, 2), 'utf8');
+  });
 
   return { ok: true, destDir };
 }
@@ -271,30 +304,32 @@ async function installFromLocal(targetDir, slug, filePath, logger) {
   }
 
   const destDir = path.join(targetDir, INSTALLED_SKILLS_DIR, slug);
-  await ensureDir(destDir);
-
   const stat = await fs.stat(absPath);
+  const samePath = path.resolve(absPath) === path.resolve(destDir);
+
+  if (!samePath) {
+    await fs.rm(destDir, { recursive: true, force: true });
+    await ensureDir(destDir);
+  } else if (!stat.isDirectory()) {
+    return { ok: false, error: 'Local self-install only supports skill directories' };
+  }
+
   if (stat.isDirectory()) {
-    // Copy entire directory
-    const entries = await fs.readdir(absPath);
-    for (const entry of entries) {
-      const src = path.join(absPath, entry);
-      const srcStat = await fs.stat(src);
-      if (srcStat.isFile()) {
-        await fs.copyFile(src, path.join(destDir, entry));
-      }
+    if (!samePath) {
+      await replaceDirectory(absPath, destDir);
     }
   } else {
     // Single file — copy as SKILL.md
+    await ensureDir(destDir);
     await fs.copyFile(absPath, path.join(destDir, 'SKILL.md'));
   }
 
   // Write meta
-  await fs.writeFile(path.join(destDir, '.skill-meta.json'), JSON.stringify({
+  await writeSkillMeta(destDir, {
     source: 'local',
     sourcePath: filePath,
     installedAt: new Date().toISOString()
-  }, null, 2), 'utf8');
+  });
 
   return { ok: true, destDir };
 }
@@ -429,17 +464,27 @@ async function runSkillList({ args, options = {}, logger, t }) {
       const fm = parseSkillFrontmatter(raw);
 
       let source = 'unknown';
+      let meta = null;
       try {
         const metaRaw = await fs.readFile(path.join(skillsDir, slug, '.skill-meta.json'), 'utf8');
-        const meta = JSON.parse(metaRaw);
+        meta = JSON.parse(metaRaw);
         source = meta.source || 'unknown';
       } catch { /* no meta */ }
 
+      const author = meta?.author?.name || meta?.author_name || null;
+      const model =
+        meta?.generator?.model ||
+        meta?.generation?.model ||
+        meta?.generated_by_model ||
+        null;
+
       installed.push({
         slug,
         name: fm.name || slug,
         description: fm.description || '',
         source,
+        author,
+        model,
         path: path.relative(targetDir, path.join(skillsDir, slug))
       });
     }
@@ -472,6 +517,8 @@ async function runSkillList({ args, options = {}, logger, t }) {
       if (s.description) {
         logger.log(`    ${s.description.slice(0, 100)}`);
       }
+      if (s.author) logger.log(`    author: ${s.author}`);
+      if (s.model) logger.log(`    model: ${s.model}`);
       logger.log(`    ${s.path}/SKILL.md`);
       logger.log('');
     }

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,