@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/sandbox.js

@@ -0,0 +1,177 @@
+'use strict';
+
+const { spawn } = require('node:child_process');
+
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_OUTPUT_BYTES = 5 * 1024; // 5KB before summarization
+
+// Credential redaction patterns — covers the most common secret formats
+const REDACTION_PATTERNS = [
+  // GitHub tokens (classic and fine-grained)
+  { pattern: /ghp_[A-Za-z0-9]{36}/g, replacement: 'ghp_[REDACTED]' },
+  { pattern: /github_pat_[A-Za-z0-9_]{82}/g, replacement: 'github_pat_[REDACTED]' },
+  // AWS access keys
+  { pattern: /AKIA[0-9A-Z]{16}/g, replacement: 'AKIA[REDACTED]' },
+  // Google OAuth tokens
+  { pattern: /ya29\.[A-Za-z0-9_\-]{50,}/g, replacement: 'ya29.[REDACTED]' },
+  // Generic Bearer tokens in headers
+  { pattern: /Bearer\s+[A-Za-z0-9\-._~+\/]+=*/gi, replacement: 'Bearer [REDACTED]' },
+  // Password in URL (e.g. postgres://user:password@host)
+  { pattern: /:[^/:@\s]{4,}@[a-z0-9.\-]+(?::\d+)?/gi, replacement: ':[REDACTED]@host' },
+  // Generic password= key=value pairs
+  { pattern: /password\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'password=[REDACTED]' },
+  { pattern: /passwd\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'passwd=[REDACTED]' },
+  // secret= key=value pairs
+  { pattern: /secret\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'secret=[REDACTED]' },
+  // api_key= or apikey= patterns
+  { pattern: /api[_-]?key\s*=\s*["']?[^\s"'&;,]{4,}["']?/gi, replacement: 'api_key=[REDACTED]' },
+  // Private key blocks
+  { pattern: /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g, replacement: '-----BEGIN PRIVATE KEY [REDACTED] END PRIVATE KEY-----' },
+];
+
+/**
+ * Redact known credential patterns from a string.
+ * @param {string} text
+ * @returns {string}
+ */
+function redactCredentials(text) {
+  if (!text) return text;
+  let result = text;
+  for (const { pattern, replacement } of REDACTION_PATTERNS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+
+/**
+ * Summarize long output to stay within size budget.
+ * @param {string} output
+ * @param {string} intent — optional context about what was executed
+ * @param {number} maxSize — max bytes to return
+ * @returns {string}
+ */
+function summarizeOutput(output, intent = '', maxSize = MAX_OUTPUT_BYTES) {
+  if (!output || output.length <= maxSize) return output;
+
+  const half = Math.floor(maxSize / 2);
+  const head = output.slice(0, half);
+  const tail = output.slice(-half);
+  const omitted = output.length - maxSize;
+  const intentNote = intent ? ` (${intent})` : '';
+
+  return `${head}\n\n[... ${omitted} bytes omitted${intentNote} ...]\n\n${tail}`;
+}
+
+/**
+ * Execute a shell command in a sandboxed subprocess with timeout and redaction.
+ *
+ * @param {string} command  — shell command to run
+ * @param {object} opts     — { cwd?, timeout?, env?, maxOutput?, intent?, shell? }
+ * @returns {{ ok: boolean, stdout: string, stderr: string, exitCode: number|null, timedOut: boolean }}
+ */
+async function executeInSandbox(command, opts = {}) {
+  const timeout = opts.timeout || DEFAULT_TIMEOUT_MS;
+  const cwd = opts.cwd || process.cwd();
+  const maxOutput = opts.maxOutput || MAX_OUTPUT_BYTES;
+  const intent = opts.intent || command.slice(0, 60);
+  const shell = opts.shell !== false; // default true
+
+  return new Promise((resolve) => {
+    const controller = new AbortController();
+    let timedOut = false;
+    let killed = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeout);
+
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutSize = 0;
+    let stderrSize = 0;
+
+    const baseOpts = {
+      cwd,
+      env: { ...process.env, ...(opts.env || {}) },
+      signal: controller.signal
+    };
+
+    let child;
+    try {
+      if (shell) {
+        // Use Node's built-in shell wrapping
+        child = spawn(command, [], { ...baseOpts, shell: true });
+      } else {
+        const parts = command.split(/\s+/);
+        child = spawn(parts[0], parts.slice(1), { ...baseOpts, shell: false });
+      }
+    } catch (err) {
+      clearTimeout(timer);
+      resolve({ ok: false, stdout: '', stderr: err.message, exitCode: null, timedOut: false, error: err.message });
+      return;
+    }
+
+    child.stdout.on('data', (chunk) => {
+      if (stdoutSize < maxOutput * 2) {
+        stdoutChunks.push(chunk);
+        stdoutSize += chunk.length;
+      }
+    });
+
+    child.stderr.on('data', (chunk) => {
+      if (stderrSize < maxOutput * 2) {
+        stderrChunks.push(chunk);
+        stderrSize += chunk.length;
+      }
+    });
+
+    child.on('close', (code, signal) => {
+      if (killed) return;
+      clearTimeout(timer);
+
+      const rawStdout = Buffer.concat(stdoutChunks).toString('utf8');
+      const rawStderr = Buffer.concat(stderrChunks).toString('utf8');
+
+      const stdout = redactCredentials(summarizeOutput(rawStdout, intent, maxOutput));
+      const stderr = redactCredentials(summarizeOutput(rawStderr, intent, maxOutput));
+
+      resolve({
+        ok: !timedOut && code === 0,
+        stdout,
+        stderr,
+        exitCode: code,
+        timedOut,
+        signal: signal || null
+      });
+    });
+
+    child.on('error', (err) => {
+      if (killed) return;
+      clearTimeout(timer);
+
+      if (err.code === 'ABORT_ERR' || timedOut) {
+        resolve({
+          ok: false,
+          stdout: '',
+          stderr: `Command timed out after ${timeout}ms`,
+          exitCode: null,
+          timedOut: true,
+          signal: null
+        });
+      } else {
+        resolve({
+          ok: false,
+          stdout: '',
+          stderr: err.message,
+          exitCode: null,
+          timedOut: false,
+          error: err.message
+        });
+      }
+      killed = true;
+    });
+  });
+}
+
+module.exports = { executeInSandbox, redactCredentials, summarizeOutput };

package/src/squad/external-session.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SESSIONS_DIR = path.join('.aioson', 'sessions');
+const DEFAULT_TTL_HOURS = 24;
+
+function sanitizeSessionId(sessionId) {
+  // Replace anything that isn't alphanumeric, hyphen, or underscore with a dash
+  return String(sessionId)
+    .replace(/[^a-zA-Z0-9_-]/g, '-')
+    .replace(/-{2,}/g, '-')
+    .replace(/^-|-$/g, '')
+    .slice(0, 128);
+}
+
+function sessionPath(projectDir, sessionId) {
+  return path.join(projectDir, SESSIONS_DIR, `${sanitizeSessionId(sessionId)}.json`);
+}
+
+async function ensureSessionsDir(projectDir) {
+  const dir = path.join(projectDir, SESSIONS_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Load a session by ID. Returns null if not found or expired.
+ * @param {string} projectDir
+ * @param {string} sessionId
+ * @param {number} [ttlHours]
+ * @returns {Promise<object|null>}
+ */
+async function loadSession(projectDir, sessionId, ttlHours = DEFAULT_TTL_HOURS) {
+  const filePath = sessionPath(projectDir, sessionId);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+
+  let session;
+  try {
+    session = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+
+  // Check TTL
+  if (ttlHours > 0 && session.last_active) {
+    const idleMs = Date.now() - new Date(session.last_active).getTime();
+    if (idleMs > ttlHours * 3_600_000) {
+      // Expired — delete and return null
+      await fs.unlink(filePath).catch(() => {});
+      return null;
+    }
+  }
+
+  return session;
+}
+
+/**
+ * Save (overwrite) a session file atomically.
+ * @param {string} projectDir
+ * @param {object} session  Must have session.session_id
+ */
+async function saveSession(projectDir, session) {
+  await ensureSessionsDir(projectDir);
+  const filePath = sessionPath(projectDir, session.session_id);
+  const tmpPath = filePath + '.tmp';
+  await fs.writeFile(tmpPath, JSON.stringify(session, null, 2), 'utf8');
+  await fs.rename(tmpPath, filePath);
+}
+
+/**
+ * Append a turn to a session. Creates the session file if it doesn't exist.
+ * @param {string} projectDir
+ * @param {string} sessionId
+ * @param {'user'|'assistant'} role
+ * @param {string} content
+ * @param {object} [metadata]  Merged into session.metadata on first creation
+ * @param {number} [ttlHours]
+ * @returns {Promise<object>} Updated session
+ */
+async function appendTurn(projectDir, sessionId, role, content, metadata = {}, ttlHours = DEFAULT_TTL_HOURS) {
+  let session = await loadSession(projectDir, sessionId, ttlHours);
+  const now = new Date().toISOString();
+
+  if (!session) {
+    session = {
+      session_id: sessionId,
+      channel: metadata.channel || 'webhook',
+      created_at: now,
+      last_active: now,
+      turns: [],
+      metadata: { ...metadata }
+    };
+  }
+
+  session.last_active = now;
+  session.turns.push({ role, content, ts: now });
+
+  // Merge any new metadata fields without overwriting existing ones
+  if (metadata && typeof metadata === 'object') {
+    for (const [k, v] of Object.entries(metadata)) {
+      if (session.metadata[k] === undefined) session.metadata[k] = v;
+    }
+  }
+
+  await saveSession(projectDir, session);
+  return session;
+}
+
+/**
+ * Build a context string from session history to inject into the squad input.
+ * @param {object} session
+ * @param {string} currentInput
+ * @returns {string}
+ */
+function buildContextualInput(session, currentInput) {
+  if (!session || !session.turns || session.turns.length === 0) {
+    return currentInput;
+  }
+
+  const history = session.turns
+    .map(t => `${t.role}: ${t.content}`)
+    .join('\n');
+
+  return `[Conversation history]\n${history}\n\n[Current message]\n${currentInput}`;
+}
+
+/**
+ * Delete all session files that have been inactive for longer than ttlHours.
+ * @param {string} projectDir
+ * @param {number} [ttlHours]
+ * @returns {Promise<number>} Number of sessions deleted
+ */
+async function cleanExpiredSessions(projectDir, ttlHours = DEFAULT_TTL_HOURS) {
+  const dir = path.join(projectDir, SESSIONS_DIR);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return 0;
+  }
+
+  let deleted = 0;
+  const cutoff = Date.now() - ttlHours * 3_600_000;
+
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.json')) continue;
+    const filePath = path.join(dir, entry.name);
+    try {
+      const raw = await fs.readFile(filePath, 'utf8');
+      const session = JSON.parse(raw);
+      const lastActive = session.last_active ? new Date(session.last_active).getTime() : 0;
+      if (lastActive < cutoff) {
+        await fs.unlink(filePath);
+        deleted++;
+      }
+    } catch {
+      // Corrupt file — remove it
+      await fs.unlink(filePath).catch(() => {});
+      deleted++;
+    }
+  }
+
+  return deleted;
+}
+
+module.exports = {
+  loadSession,
+  saveSession,
+  appendTurn,
+  buildContextualInput,
+  cleanExpiredSessions,
+  sanitizeSessionId
+};

package/src/squad/inter-squad.js

@@ -0,0 +1,74 @@
+'use strict';
+const { randomUUID } = require('node:crypto');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, insertWorkerRun } = require('../runtime-store');
+
+const INBOX_DIR = (projectDir, squadSlug) =>
+  path.join(projectDir, '.aioson', 'squads', squadSlug, 'inbox');
+
+async function callSquad({ projectDir, from, to, worker, payload, conversationId, depth = 0 }) {
+  // 1. Cascade guard
+  if (depth > 5) return { ok: false, error: 'cascade_guard' };
+
+  conversationId = conversationId || randomUUID();
+
+  // 2. Resolver porta do squad destino no SQLite (manter DB aberto para log)
+  const handle = await openRuntimeDb(projectDir);
+  const db = handle?.db;
+  const port = db
+    ?.prepare("SELECT port FROM squad_daemons WHERE squad_slug = ? AND status = 'running'")
+    .get(to)?.port;
+
+  let result;
+
+  // 3. Tentar chamada direta
+  if (port) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/webhook/${worker}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...payload, _inter_squad: { from, conversationId, depth: depth + 1 } }),
+        signal: AbortSignal.timeout(10000)
+      });
+      const json = await res.json();
+      result = { ok: res.ok, result: json, conversationId };
+    } catch {
+      // cai para inbox
+    }
+  }
+
+  // 4. Enfileirar na inbox do squad destino
+  if (!result) {
+    const inboxDir = INBOX_DIR(projectDir, to);
+    await fs.mkdir(inboxDir, { recursive: true });
+    const id = randomUUID();
+    await fs.writeFile(
+      path.join(inboxDir, `${id}.json`),
+      JSON.stringify({ id, from, to, worker, payload, conversationId, depth, created_at: new Date().toISOString() })
+    );
+    result = { ok: false, error: 'offline_queued', conversationId };
+  }
+
+  // 5. Gravar chamada emitida no runtime store (trigger_type = 'inter-squad')
+  if (db) {
+    try {
+      insertWorkerRun(db, {
+        squadSlug: from,
+        workerSlug: worker,
+        triggerType: 'inter-squad',
+        inputJson: JSON.stringify({ to, payload, conversationId }),
+        outputJson: result.ok ? JSON.stringify(result.result) : null,
+        status: result.ok ? 'completed' : 'failed',
+        errorMessage: result.ok ? null : result.error,
+        durationMs: 0,
+        attempt: 1
+      });
+    } catch { /* ignore */ }
+    db.close();
+  }
+
+  return result;
+}
+
+module.exports = { callSquad, INBOX_DIR };

package/src/squad/recovery-context.js

@@ -0,0 +1,201 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// Events that trigger an automatic refresh of the recovery context
+const REFRESH_EVENTS = new Set(['task_completed', 'decision_made', 'handoff']);
+
+// Approximate token count (chars / 4)
+function estimateTokens(str) {
+  return Math.ceil(str.length / 4);
+}
+
+/**
+ * Read squad manifest (best-effort, returns {} on failure).
+ */
+async function readManifest(projectDir, squadSlug) {
+  const p = path.join(projectDir, SQUADS_DIR, squadSlug, 'squad.manifest.json');
+  try {
+    return JSON.parse(await fs.readFile(p, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Read recent events from session-log.json (last N entries).
+ */
+async function readRecentEvents(projectDir, squadSlug, limit = 10) {
+  const p = path.join(projectDir, SQUADS_DIR, squadSlug, 'session-log.json');
+  try {
+    const raw = JSON.parse(await fs.readFile(p, 'utf8'));
+    const entries = Array.isArray(raw) ? raw : (raw.entries || []);
+    return entries.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read recent tasks from tasks.json (last 5, enriched).
+ */
+async function readRecentTasks(projectDir, squadSlug, limit = 5) {
+  const p = path.join(projectDir, SQUADS_DIR, squadSlug, 'tasks.json');
+  try {
+    const raw = JSON.parse(await fs.readFile(p, 'utf8'));
+    const tasks = Array.isArray(raw) ? raw : (raw.tasks || []);
+    return tasks.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Read context-monitor.json snapshot for an agent.
+ */
+async function readContextSnapshot(projectDir, squadSlug, agentSlug) {
+  const p = path.join(projectDir, SQUADS_DIR, squadSlug, 'context-monitor.json');
+  try {
+    const data = JSON.parse(await fs.readFile(p, 'utf8'));
+    if (agentSlug && data.agents && data.agents[agentSlug]) {
+      return data.agents[agentSlug];
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the markdown content for recovery-context.md.
+ * Target < 2000 tokens.
+ */
+function buildRecoveryMarkdown(squadSlug, agentSlug, manifest, tasks, events, ctxSnapshot) {
+  const lines = [];
+
+  lines.push(`# Recovery Context — ${squadSlug} / ${agentSlug}`);
+  lines.push(`> Generated: ${new Date().toISOString()}`);
+  lines.push('');
+
+  // Squad goal
+  if (manifest.goal) {
+    lines.push('## Squad Goal');
+    lines.push(manifest.goal);
+    lines.push('');
+  }
+
+  // Agent role (from executors array)
+  const executor = (manifest.executors || []).find(e => e.slug === agentSlug);
+  if (executor) {
+    lines.push('## Your Role');
+    lines.push(`**${executor.title || agentSlug}**: ${executor.role || ''}`);
+    lines.push('');
+  }
+
+  // Recent tasks
+  if (tasks.length > 0) {
+    lines.push('## Recent Tasks');
+    for (const t of tasks) {
+      const status = t.status || 'unknown';
+      const title = t.title || t.slug || t.id || '(untitled)';
+      lines.push(`- [${status}] ${title}`);
+      if (t.output && typeof t.output === 'string') {
+        // Truncate long outputs
+        const out = t.output.length > 200 ? t.output.slice(0, 200) + '…' : t.output;
+        lines.push(`  Output: ${out}`);
+      }
+    }
+    lines.push('');
+  }
+
+  // Recent events
+  if (events.length > 0) {
+    lines.push('## Recent Events');
+    for (const ev of events) {
+      const ts = ev.created_at || ev.timestamp || '';
+      const type = ev.event_type || ev.type || 'event';
+      const msg = ev.message || ev.summary || '';
+      lines.push(`- [${ts}] ${type}: ${msg}`);
+    }
+    lines.push('');
+  }
+
+  // Context snapshot
+  if (ctxSnapshot) {
+    lines.push('## Context Window at Last Compact');
+    const used = ctxSnapshot.totalUsed || 0;
+    const win = ctxSnapshot.windowSize || 0;
+    const pct = win > 0 ? Math.round((used / win) * 100) : 0;
+    lines.push(`Used: ${used.toLocaleString()} / ${win.toLocaleString()} tokens (${pct}%)`);
+    lines.push('');
+  }
+
+  lines.push('---');
+  lines.push('*Inject this file at the top of your next session to restore context after a compact.*');
+
+  const content = lines.join('\n');
+
+  // Enforce token limit: if over budget, trim events section
+  if (estimateTokens(content) > 2000) {
+    // Rebuild with fewer events
+    return buildRecoveryMarkdown(squadSlug, agentSlug, manifest, tasks, events.slice(-3), ctxSnapshot);
+  }
+
+  return content;
+}
+
+/**
+ * Generate and write recovery-context.md for an agent.
+ * @param {string} projectDir
+ * @param {string} squadSlug
+ * @param {string} agentSlug
+ * @returns {{ ok: boolean, path: string, tokens: number }}
+ */
+async function generateRecovery(projectDir, squadSlug, agentSlug) {
+  const [manifest, tasks, events, ctxSnapshot] = await Promise.all([
+    readManifest(projectDir, squadSlug),
+    readRecentTasks(projectDir, squadSlug),
+    readRecentEvents(projectDir, squadSlug),
+    readContextSnapshot(projectDir, squadSlug, agentSlug)
+  ]);
+
+  const content = buildRecoveryMarkdown(squadSlug, agentSlug, manifest, tasks, events, ctxSnapshot);
+  const tokens = estimateTokens(content);
+
+  const outDir = path.join(projectDir, SQUADS_DIR, squadSlug);
+  const outPath = path.join(outDir, `recovery-context.md`);
+
+  try {
+    await fs.mkdir(outDir, { recursive: true });
+    await fs.writeFile(outPath, content, 'utf8');
+  } catch (err) {
+    return { ok: false, error: err.message, path: outPath, tokens };
+  }
+
+  return { ok: true, path: outPath, tokens, squadSlug, agentSlug };
+}
+
+/**
+ * Read the current recovery-context.md for an agent (returns null if missing).
+ */
+async function readRecovery(projectDir, squadSlug) {
+  const p = path.join(projectDir, SQUADS_DIR, squadSlug, 'recovery-context.md');
+  try {
+    return await fs.readFile(p, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a runtime event should trigger a recovery refresh.
+ * @param {string} eventType
+ */
+function shouldRefreshOnEvent(eventType) {
+  return REFRESH_EVENTS.has(eventType);
+}
+
+module.exports = { generateRecovery, readRecovery, shouldRefreshOnEvent, REFRESH_EVENTS };