@jaimevalasek/aioson 1.7.0 → 1.8.0

package/src/lib/store/security-scan.js

@@ -0,0 +1,173 @@
+'use strict';
+
+const crypto = require('node:crypto');
+
+// ── Extension allowlists ─────────────────────────────────────────────────────
+
+const ALLOWED_EXTENSIONS = {
+  genome: new Set(['.md', '.json']),
+  skill: new Set(['.md', '.json', '.yaml', '.yml', '.txt']),
+  squad: new Set(['.md', '.json', '.yaml', '.yml', '.txt'])
+};
+
+// ── Size limits ──────────────────────────────────────────────────────────────
+
+const MAX_FILE_BYTES = 512 * 1024;       // 512 KB per file
+const MAX_PACKAGE_BYTES = 5 * 1024 * 1024; // 5 MB total
+
+// ── Malicious pattern detection ──────────────────────────────────────────────
+
+/**
+ * Patterns that flag a file for review.
+ * Each entry: { id, pattern, description }
+ * All patterns are applied to raw file content (string).
+ */
+const THREAT_PATTERNS = [
+  // Shell execution
+  { id: 'shell_exec',      pattern: /\$\(.*\)|`[^`]{0,200}`/,                          description: 'shell command substitution' },
+  { id: 'curl_pipe',       pattern: /curl\s+.*\|\s*(ba)?sh/i,                           description: 'curl pipe to shell' },
+  { id: 'wget_pipe',       pattern: /wget\s+.*-O\s*-\s*\|\s*(ba)?sh/i,                 description: 'wget pipe to shell' },
+  { id: 'exec_call',       pattern: /\bexec\s*\(/,                                      description: 'exec() call' },
+  { id: 'eval_call',       pattern: /\beval\s*\(/,                                      description: 'eval() call' },
+  { id: 'spawn_call',      pattern: /child_process|\.spawn\s*\(|\.execSync\s*\(/,       description: 'child_process / spawn' },
+
+  // Encoded payloads
+  { id: 'long_base64',     pattern: /[A-Za-z0-9+/]{200,}={0,2}/,                       description: 'long base64 blob (potential encoded payload)' },
+  { id: 'hex_payload',     pattern: /\\x[0-9a-fA-F]{2}(\\x[0-9a-fA-F]{2}){15,}/,      description: 'hex-encoded payload sequence' },
+
+  // Network calls inside markdown/config
+  { id: 'js_fetch',        pattern: /\bfetch\s*\(\s*['"`]https?:\/\//,                  description: 'fetch() to external URL' },
+  { id: 'require_http',    pattern: /require\s*\(\s*['"`]https?:\/\//,                  description: 'require() from HTTP URL' },
+  { id: 'dynamic_import',  pattern: /import\s*\(\s*['"`]https?:\/\//,                   description: 'dynamic import from HTTP URL' },
+
+  // Filesystem destructive ops
+  { id: 'rm_rf',           pattern: /rm\s+-rf?\s+[/~]/,                                 description: 'rm -rf on root or home' },
+  { id: 'mkfs',            pattern: /\bmkfs\b|\bdd\s+if=\/dev\//,                       description: 'mkfs or dd on device' },
+
+  // Crypto mining markers
+  { id: 'miner_pool',      pattern: /stratum\+tcp:\/\/|minexmr\.com|xmrig/i,            description: 'crypto mining pool reference' },
+
+  // Exfiltration patterns
+  { id: 'env_exfil',       pattern: /process\.env\b.*\b(fetch|axios|request)\b/,        description: 'env vars sent over network' },
+  { id: 'ssh_key_path',    pattern: /\.ssh\/id_rsa|\.ssh\/id_ed25519/,                  description: 'SSH private key path reference' },
+
+  // Obfuscation
+  { id: 'atob_chain',      pattern: /atob\s*\(\s*atob/,                                 description: 'double-decoded base64 (obfuscation)' },
+  { id: 'charcode_concat', pattern: /String\.fromCharCode\s*\(\s*\d[\d,\s]{30,}\)/,     description: 'String.fromCharCode long sequence' }
+];
+
+/**
+ * Scan a single file's content for threat patterns.
+ * Returns array of { id, description, line } for each match.
+ */
+function scanContent(content) {
+  const findings = [];
+  const lines = content.split('\n');
+
+  for (const { id, pattern, description } of THREAT_PATTERNS) {
+    // Check full content first (for multi-char patterns)
+    if (!pattern.test(content)) continue;
+
+    // Find which line triggered it
+    let lineNum = null;
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) {
+        lineNum = i + 1;
+        break;
+      }
+    }
+
+    findings.push({ id, description, line: lineNum });
+  }
+
+  return findings;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Scan a files map { relPath: content } for security issues.
+ *
+ * @param {Record<string, string>} files
+ * @param {'genome'|'skill'|'squad'} packageType
+ * @returns {{ ok: boolean, errors: string[], warnings: string[], hash: string }}
+ */
+function scanPackage(files, packageType) {
+  const allowedExts = ALLOWED_EXTENSIONS[packageType] ?? ALLOWED_EXTENSIONS.squad;
+  const errors = [];
+  const warnings = [];
+  let totalBytes = 0;
+
+  for (const [relPath, content] of Object.entries(files)) {
+    if (typeof content !== 'string') continue;
+
+    const ext = relPath.includes('.') ? `.${relPath.split('.').pop().toLowerCase()}` : '';
+    const bytes = Buffer.byteLength(content, 'utf8');
+    totalBytes += bytes;
+
+    // Extension check
+    if (!allowedExts.has(ext)) {
+      errors.push(`Blocked file type: "${relPath}" (extension "${ext}" not allowed for ${packageType} packages)`);
+      continue; // don't scan content of blocked files
+    }
+
+    // Per-file size check
+    if (bytes > MAX_FILE_BYTES) {
+      errors.push(`File too large: "${relPath}" (${(bytes / 1024).toFixed(0)} KB, limit is ${MAX_FILE_BYTES / 1024} KB)`);
+    }
+
+    // Threat patterns
+    const findings = scanContent(content);
+    for (const finding of findings) {
+      const loc = finding.line ? `:${finding.line}` : '';
+      warnings.push(`Suspicious pattern in "${relPath}"${loc} — ${finding.description} [${finding.id}]`);
+    }
+  }
+
+  // Total package size
+  if (totalBytes > MAX_PACKAGE_BYTES) {
+    errors.push(`Package too large: ${(totalBytes / 1024 / 1024).toFixed(2)} MB (limit is ${MAX_PACKAGE_BYTES / 1024 / 1024} MB)`);
+  }
+
+  // Deterministic hash of the full package contents
+  const hash = hashPackage(files);
+
+  return { ok: errors.length === 0, errors, warnings, hash, totalBytes };
+}
+
+/**
+ * Compute a deterministic SHA-256 of the package contents.
+ * Files are sorted by path before hashing.
+ */
+function hashPackage(files) {
+  const h = crypto.createHash('sha256');
+  const sortedPaths = Object.keys(files).sort();
+  for (const p of sortedPaths) {
+    h.update(`\0${p}\0`);
+    h.update(files[p] ?? '');
+  }
+  return h.digest('hex');
+}
+
+/**
+ * Format scan results for CLI output.
+ * Returns lines to log.
+ */
+function formatScanReport(scanResult, logger) {
+  const lines = [];
+
+  if (scanResult.errors.length > 0) {
+    lines.push('Security scan FAILED:');
+    for (const e of scanResult.errors) lines.push(`  [ERROR] ${e}`);
+  }
+
+  if (scanResult.warnings.length > 0) {
+    lines.push('Security scan warnings:');
+    for (const w of scanResult.warnings) lines.push(`  [WARN]  ${w}`);
+  }
+
+  for (const line of lines) logger.log(line);
+  return lines;
+}
+
+module.exports = { scanPackage, hashPackage, formatScanReport, ALLOWED_EXTENSIONS, MAX_FILE_BYTES, MAX_PACKAGE_BYTES };

package/src/lib/terminal-checkbox.js

@@ -0,0 +1,130 @@
+'use strict';
+
+/**
+ * Lightweight terminal checkbox UI using raw mode and keypress events.
+ * No external dependencies.
+ */
+
+const readline = require('node:readline');
+
+function countVisualLines(text, cols) {
+  return text.split('\n').reduce((acc, line) => {
+    return acc + Math.max(1, Math.ceil((line.length || 1) / cols));
+  }, 0);
+}
+
+function render(items, selectedIndex, hint) {
+  const lines = items.map((item, index) => {
+    const marker = item.checked ? '[x]' : '[ ]';
+    const prefix = index === selectedIndex ? '> ' : '  ';
+    return `${prefix}${marker} ${item.label}`;
+  });
+  lines.push('');
+  lines.push(hint);
+  return lines.join('\n');
+}
+
+function promptCheckbox(items, hint = '↑/↓ navegar | Espaço selecionar | Enter confirmar | Esc cancelar | a=todos | n=limpar') {
+  return new Promise((resolve) => {
+    const state = items.map((label) => ({ label, checked: true }));
+    let selectedIndex = 0;
+    let renderedLines = 0;
+
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    const wasRaw = stdin.isRaw;
+    if (stdin.setRawMode) {
+      stdin.setRawMode(true);
+    }
+    stdin.resume();
+    readline.emitKeypressEvents(stdin);
+
+    function draw() {
+      const cols = stdout.columns || 80;
+      if (renderedLines > 0) {
+        stdout.write(`\x1B[${renderedLines}A\x1B[J`);
+      }
+      const output = render(state, selectedIndex, hint);
+      renderedLines = countVisualLines(output, cols);
+      stdout.write(output + '\n');
+    }
+
+    function cleanup() {
+      if (stdin.setRawMode) {
+        stdin.setRawMode(wasRaw);
+      }
+      stdin.pause();
+      stdin.removeListener('keypress', onKeypress);
+      const cols = stdout.columns || 80;
+      if (renderedLines > 0) {
+        stdout.write(`\x1B[${renderedLines}A\x1B[J`);
+      }
+      renderedLines = 0;
+    }
+
+    function confirm() {
+      cleanup();
+      resolve(state.filter((s) => s.checked).map((s) => s.label));
+    }
+
+    function cancel() {
+      cleanup();
+      resolve(null);
+    }
+
+    function onKeypress(str, key) {
+      if (!key) return;
+
+      if (key.name === 'c' && key.ctrl) {
+        cancel();
+        return;
+      }
+
+      if (key.name === 'escape') {
+        cancel();
+        return;
+      }
+
+      if (key.name === 'return' || key.name === 'enter') {
+        confirm();
+        return;
+      }
+
+      if (key.name === 'up') {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : state.length - 1;
+        draw();
+        return;
+      }
+
+      if (key.name === 'down') {
+        selectedIndex = selectedIndex < state.length - 1 ? selectedIndex + 1 : 0;
+        draw();
+        return;
+      }
+
+      if (key.name === 'space') {
+        state[selectedIndex].checked = !state[selectedIndex].checked;
+        draw();
+        return;
+      }
+
+      if (str === 'a' || str === 'A') {
+        state.forEach((s) => { s.checked = true; });
+        draw();
+        return;
+      }
+
+      if (str === 'n' || str === 'N') {
+        state.forEach((s) => { s.checked = false; });
+        draw();
+        return;
+      }
+    }
+
+    stdin.on('keypress', onKeypress);
+    draw();
+  });
+}
+
+module.exports = { promptCheckbox };

package/src/lib/tmux-launcher.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+const path = require('node:path');
+
+async function isTmuxAvailable() {
+  return new Promise((resolve) => {
+    const child = spawn('which', ['tmux'], { stdio: 'pipe' });
+    child.on('close', (code) => resolve(code === 0));
+    child.on('error', () => resolve(false));
+  });
+}
+
+function buildSessionName(targetDir, agentName) {
+  const base = targetDir.split(/[\\/]/).pop() || 'aioson';
+  const agent = String(agentName || '').replace(/^@/, '');
+  const sanitized = `${base}-${agent}`.replace(/[^a-zA-Z0-9_-]/g, '-').slice(0, 50);
+  return sanitized;
+}
+
+function resolveAiosonBinary() {
+  if (process.argv[1]) {
+    return path.resolve(process.argv[1]);
+  }
+  return 'aioson';
+}
+
+async function hasSession(sessionName) {
+  return new Promise((resolve) => {
+    const child = spawn('tmux', ['has-session', '-t', sessionName], { stdio: 'ignore' });
+    child.on('close', (code) => resolve(code === 0));
+    child.on('error', () => resolve(false));
+  });
+}
+
+async function killSession(sessionName) {
+  return new Promise((resolve) => {
+    const kill = spawn('tmux', ['kill-session', '-t', sessionName], { stdio: 'ignore' });
+    kill.on('close', () => resolve());
+    kill.on('error', () => resolve());
+  });
+}
+
+async function createTmuxSession(sessionName, targetDir, binaryPath, toolArgs) {
+  const args = [
+    'new-session',
+    '-d',
+    '-s', sessionName,
+    '-c', targetDir,
+    binaryPath,
+    ...toolArgs
+  ];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('tmux', args, { stdio: 'ignore' });
+    child.on('error', (err) => reject(err));
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`tmux new-session exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+async function configureTmuxSession(sessionName) {
+  const commands = [
+    // Mouse on so scroll works in the main pane; the bottom pane is 1 line
+    // and non-interactive, so accidental focus is harmless
+    ['set-option', '-t', sessionName, 'mouse', 'on'],
+    // Hide tmux status line (we use our own pane)
+    ['set-option', '-t', sessionName, 'status', 'off'],
+    // Hide pane borders for a clean look
+    ['set-option', '-t', sessionName, 'pane-border-status', 'off'],
+    // Prevent focus events from shifting to the bottom pane
+    ['set-option', '-t', sessionName, 'focus-events', 'off']
+  ];
+
+  for (const cmd of commands) {
+    await new Promise((resolve, reject) => {
+      const child = spawn('tmux', cmd, { stdio: 'ignore' });
+      child.on('error', (err) => reject(err));
+      child.on('close', () => resolve());
+    });
+  }
+}
+
+async function createStatusPane(sessionName, targetDir) {
+  const aiosonBin = resolveAiosonBinary();
+  const safeDir = String(targetDir || '.').replace(/"/g, '\\"');
+  const safeBin = String(aiosonBin).replace(/"/g, '\\"');
+
+  // Command runs directly in the pane (no interactive bash)
+  // printTmuxBar writes WITHOUT newline; we clear the line before each refresh
+  const cmd = `while true; do printf '\\033[2K\\r'; AIOSON_TMUX_BAR=1 "${safeBin}" live:status "${safeDir}" --format=tmux-bar; sleep 2; done`;
+
+  return new Promise((resolve, reject) => {
+    const split = spawn('tmux', [
+      'split-window',
+      '-v',
+      '-t', `${sessionName}:0.0`,
+      '-c', targetDir,
+      '-l', '1',
+      cmd
+    ], { stdio: 'ignore' });
+    split.on('error', (err) => reject(err));
+    split.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`tmux split-window exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+
+async function focusTopPane(sessionName) {
+  return new Promise((resolve, reject) => {
+    const focus = spawn('tmux', [
+      'select-pane',
+      '-t', `${sessionName}:0.0`
+    ], { stdio: 'ignore' });
+    focus.on('error', (err) => reject(err));
+    focus.on('close', () => resolve());
+  });
+}
+
+async function attachSession(sessionName) {
+  return new Promise((resolve, reject) => {
+    const attach = spawn('tmux', ['attach', '-t', sessionName], { stdio: 'inherit' });
+    attach.on('error', (err) => reject(err));
+    attach.on('close', () => resolve());
+  });
+}
+
+async function launchTmuxSession(options) {
+  const { targetDir, agentName, tool, binaryPath, toolArgs = [] } = options;
+  const sessionName = buildSessionName(targetDir, agentName);
+
+  await killSession(sessionName);
+  await createTmuxSession(sessionName, targetDir, binaryPath, toolArgs);
+  await configureTmuxSession(sessionName);
+  await createStatusPane(sessionName, targetDir);
+  await focusTopPane(sessionName);
+
+  try {
+    await attachSession(sessionName);
+  } finally {
+    await killSession(sessionName);
+  }
+
+  return { ok: true, sessionName };
+}
+
+module.exports = {
+  isTmuxAvailable,
+  launchTmuxSession,
+  buildSessionName,
+  hasSession,
+  attachSession,
+  resolveAiosonBinary
+};

package/src/lib/tool-capabilities.js

@@ -0,0 +1,102 @@
+'use strict';
+
+// Capabilities map for the AI CLIs that AIOSON can spawn via `aioson live:start`.
+// Each CLI persists conversation history in its own per-cwd location, so
+// "continue last conversation" is achieved by passing the right resume flag
+// at spawn time — AIOSON never has to track an internal session ID.
+//
+// Used by:
+//   - `aioson live:start --resume[=last|<id>]` to map to the correct argv
+//   - `aioson tool:capabilities` to expose this map as JSON to UI clients
+//     (e.g. AIOSON Play) so they don't duplicate the lookup.
+//
+// Keep entries minimal and source-of-truth here. Adding a new CLI = one entry.
+const TOOL_CAPS = {
+  claude: {
+    install_command: 'npm install -g @anthropic-ai/claude-code',
+    binary: 'claude',
+    supports_resume: true,
+    resume_last: ['--continue'],
+    supports_session_id: true,
+    resume_session_id: ['--resume', '<id>'],
+    supports_session_picker: true,
+    session_picker: ['--resume'],
+  },
+  codex: {
+    install_command: 'npm install -g @openai/codex',
+    binary: 'codex',
+    supports_resume: true,
+    resume_last: ['resume', '--last'],
+    supports_session_id: true,
+    resume_session_id: ['resume', '<id>'],
+    supports_session_picker: true,
+    session_picker: ['resume'],
+  },
+  opencode: {
+    install_command: 'npm install -g opencode-ai',
+    binary: 'opencode',
+    supports_resume: true,
+    resume_last: ['--continue'],
+    supports_session_id: true,
+    resume_session_id: ['--session', '<id>'],
+    supports_session_picker: false,
+    session_picker: null,
+  },
+  gemini: {
+    install_command: 'npm install -g @google/gemini-cli',
+    binary: 'gemini',
+    supports_resume: false,
+    resume_last: null,
+    supports_session_id: false,
+    resume_session_id: null,
+    supports_session_picker: false,
+    session_picker: null,
+  },
+};
+
+function getToolCapabilities(tool) {
+  const key = String(tool || '').trim().toLowerCase();
+  if (!key) return null;
+  return TOOL_CAPS[key] || null;
+}
+
+function listSupportedTools() {
+  return Object.keys(TOOL_CAPS).sort();
+}
+
+// Resolve the argv prefix to add to the CLI spawn so it resumes a conversation.
+// `resumeOpt` accepted shapes:
+//   - true            → resume last
+//   - 'last' / 'true' → resume last
+//   - '' / undefined / null / false → no resume
+//   - any other string → treat as session id
+// Returns [] when the tool doesn't support resume or resumeOpt is falsy.
+function resolveResumeArgs(tool, resumeOpt) {
+  if (resumeOpt === undefined || resumeOpt === null || resumeOpt === '' || resumeOpt === false) {
+    return [];
+  }
+  const caps = getToolCapabilities(tool);
+  if (!caps || !caps.supports_resume) return [];
+
+  const wantsLast =
+    resumeOpt === true ||
+    resumeOpt === 'last' ||
+    String(resumeOpt).toLowerCase() === 'true';
+
+  if (wantsLast) {
+    return Array.isArray(caps.resume_last) ? [...caps.resume_last] : [];
+  }
+
+  if (caps.supports_session_id && Array.isArray(caps.resume_session_id)) {
+    return caps.resume_session_id.map((part) => (part === '<id>' ? String(resumeOpt) : part));
+  }
+
+  return Array.isArray(caps.resume_last) ? [...caps.resume_last] : [];
+}
+
+module.exports = {
+  TOOL_CAPS,
+  getToolCapabilities,
+  listSupportedTools,
+  resolveResumeArgs,
+};

package/src/locales.js

@@ -3,18 +3,20 @@
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const { AGENT_DEFINITIONS } = require('./constants');
+const { TEMPLATE_DIR } = require('./installer');
 const { exists, ensureDir } = require('./utils');
+const { normalizeLanguageTag } = require('./context');
 
 const SUPPORTED_AGENT_LOCALES = ['en', 'pt-BR', 'es', 'fr'];
 
-function normalizeLanguageTag(value) {
-  return String(value || '').trim();
-}
-
 function localeForPath(value) {
   return String(value || '').replace(/_/g, '-');
 }
 
+function normalizeInteractionLanguage(languageTag, fallback = 'en') {
+  return normalizeLanguageTag(languageTag, fallback);
+}
+
 function resolveAgentLocale(languageTag) {
   const tag = normalizeLanguageTag(languageTag);
   if (!tag) return 'en';
@@ -43,15 +45,15 @@ function getActiveAgentPath(agentId) {
 }
 
 async function applyAgentLocale(targetDir, locale, options = {}) {
-  const resolved = resolveAgentLocale(locale);
+  const interactionLanguage = normalizeInteractionLanguage(locale || 'en');
   const dryRun = Boolean(options.dryRun);
   const copied = [];
   const missing = [];
 
   for (const agent of AGENT_DEFINITIONS) {
-    const sourceRel = getLocalizedAgentPath(agent.id, resolved);
+    const sourceRel = getActiveAgentPath(agent.id);
+    const sourceAbs = path.join(TEMPLATE_DIR, sourceRel);
     const destRel = getActiveAgentPath(agent.id);
-    const sourceAbs = path.join(targetDir, sourceRel);
     const destAbs = path.join(targetDir, destRel);
 
     if (!(await exists(sourceAbs))) {
@@ -67,7 +69,8 @@ async function applyAgentLocale(targetDir, locale, options = {}) {
   }
 
   return {
-    locale: resolved,
+    locale: interactionLanguage,
+    promptLocale: 'en',
     copied,
     missing,
     dryRun
@@ -77,6 +80,7 @@ async function applyAgentLocale(targetDir, locale, options = {}) {
 module.exports = {
   SUPPORTED_AGENT_LOCALES,
   normalizeLanguageTag,
+  normalizeInteractionLanguage,
   resolveAgentLocale,
   getLocalizedAgentPath,
   getActiveAgentPath,