@jaimevalasek/aioson 1.4.0 → 1.6.0

package/src/squad/worktree-manager.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const path = require('node:path');
+
+/**
+ * Create a git worktree for a squad agent.
+ * Branch: aioson/{squadSlug}/{agentSlug}
+ * Path: .aioson/squads/{squadSlug}/worktrees/{agentSlug}
+ */
+function createWorktree(projectDir, squadSlug, agentSlug) {
+  const branchName = `aioson/${squadSlug}/${agentSlug}`;
+  const worktreePath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'worktrees', agentSlug);
+
+  // Try with new branch first
+  let result = spawnSync('git', ['worktree', 'add', '-b', branchName, worktreePath], {
+    cwd: projectDir,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0) {
+    // Branch may already exist — try without -b
+    result = spawnSync('git', ['worktree', 'add', worktreePath, branchName], {
+      cwd: projectDir,
+      encoding: 'utf8'
+    });
+    if (result.status !== 0) {
+      throw new Error(result.stderr || 'Failed to create worktree');
+    }
+  }
+
+  return { ok: true, branchName, worktreePath };
+}
+
+/**
+ * Merge worktree branch back to the current branch.
+ * autoMerge=true → attempt fast-forward. false → report without merging.
+ */
+function mergeWorktree(projectDir, squadSlug, agentSlug, autoMerge = false) {
+  const branchName = `aioson/${squadSlug}/${agentSlug}`;
+
+  if (!autoMerge) {
+    return { ok: false, reason: 'auto_merge_disabled', branch: branchName };
+  }
+
+  const result = spawnSync('git', ['merge', '--ff-only', branchName], {
+    cwd: projectDir,
+    encoding: 'utf8'
+  });
+
+  if (result.status === 0) {
+    return { ok: true, branch: branchName, merged: true };
+  }
+
+  return {
+    ok: false,
+    reason: 'merge_conflict',
+    branch: branchName,
+    detail: (result.stderr || result.stdout || '').trim()
+  };
+}
+
+/**
+ * Remove a worktree (and optionally delete its branch).
+ */
+function cleanupWorktree(projectDir, squadSlug, agentSlug, deleteBranch = false) {
+  const worktreePath = path.join(projectDir, '.aioson', 'squads', squadSlug, 'worktrees', agentSlug);
+  const branchName = `aioson/${squadSlug}/${agentSlug}`;
+
+  const result = spawnSync('git', ['worktree', 'remove', '--force', worktreePath], {
+    cwd: projectDir,
+    encoding: 'utf8'
+  });
+
+  const removed = result.status === 0;
+
+  if (deleteBranch) {
+    spawnSync('git', ['branch', '-D', branchName], { cwd: projectDir, encoding: 'utf8' });
+  }
+
+  return { ok: removed, worktreePath, branchName };
+}
+
+/**
+ * List all squad worktrees (filters by aioson/{squadSlug}/ branch prefix).
+ */
+function listWorktrees(projectDir, squadSlug) {
+  const result = spawnSync('git', ['worktree', 'list', '--porcelain'], {
+    cwd: projectDir,
+    encoding: 'utf8'
+  });
+
+  if (result.status !== 0) return [];
+
+  const entries = [];
+  const blocks = result.stdout.trim().split('\n\n');
+  for (const block of blocks) {
+    if (!block.trim()) continue;
+    const entry = {};
+    for (const line of block.split('\n')) {
+      if (line.startsWith('worktree ')) entry.path = line.slice(9);
+      else if (line.startsWith('branch ')) entry.branch = line.slice(7).replace('refs/heads/', '');
+      else if (line.startsWith('HEAD ')) entry.head = line.slice(5);
+    }
+    if (entry.branch && entry.branch.startsWith(`aioson/${squadSlug}/`)) {
+      entry.agentSlug = entry.branch.split('/').pop();
+      entries.push(entry);
+    }
+  }
+
+  return entries;
+}
+
+module.exports = { createWorktree, mergeWorktree, cleanupWorktree, listWorktrees };

package/src/squad-daemon.js

@@ -0,0 +1,490 @@
+'use strict';
+
+const http = require('node:http');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, insertWorkerRun } = require('./runtime-store');
+const { listWorkers, runWorker, loadWorkerConfig } = require('./worker-runner');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+// --- Simple Cron Parser (zero dependencies) ---
+
+const CRON_PRESETS = {
+  '@yearly': '0 0 1 1 *',
+  '@monthly': '0 0 1 * *',
+  '@weekly': '0 0 * * 0',
+  '@daily': '0 0 * * *',
+  '@hourly': '0 * * * *',
+  '@every5m': '*/5 * * * *',
+  '@every10m': '*/10 * * * *',
+  '@every15m': '*/15 * * * *',
+  '@every30m': '*/30 * * * *'
+};
+
+function parseCronField(field, min, max) {
+  if (field === '*') return null; // matches all
+  const values = new Set();
+  for (const part of field.split(',')) {
+    const stepMatch = part.match(/^(\*|\d+(?:-\d+)?)\/(\d+)$/);
+    if (stepMatch) {
+      const step = parseInt(stepMatch[2], 10);
+      let start = min;
+      let end = max;
+      if (stepMatch[1] !== '*') {
+        const range = stepMatch[1].split('-');
+        start = parseInt(range[0], 10);
+        if (range[1]) end = parseInt(range[1], 10);
+      }
+      for (let i = start; i <= end; i += step) values.add(i);
+    } else if (part.includes('-')) {
+      const [a, b] = part.split('-').map(Number);
+      for (let i = a; i <= b; i++) values.add(i);
+    } else {
+      values.add(parseInt(part, 10));
+    }
+  }
+  return values;
+}
+
+function parseCronExpression(expr) {
+  const resolved = CRON_PRESETS[expr] || expr;
+  const parts = resolved.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  return {
+    minute: parseCronField(parts[0], 0, 59),
+    hour: parseCronField(parts[1], 0, 23),
+    dayOfMonth: parseCronField(parts[2], 1, 31),
+    month: parseCronField(parts[3], 1, 12),
+    dayOfWeek: parseCronField(parts[4], 0, 6)
+  };
+}
+
+function cronMatches(parsed, date) {
+  if (!parsed) return false;
+  const checks = [
+    [parsed.minute, date.getMinutes()],
+    [parsed.hour, date.getHours()],
+    [parsed.dayOfMonth, date.getDate()],
+    [parsed.month, date.getMonth() + 1],
+    [parsed.dayOfWeek, date.getDay()]
+  ];
+  return checks.every(([field, val]) => field === null || field.has(val));
+}
+
+// --- Squad Daemon ---
+
+class SquadDaemon {
+  constructor(projectDir, squadSlug, options = {}) {
+    this.projectDir = projectDir;
+    this.squadSlug = squadSlug;
+    this.webhookPort = options.port || 0;
+    this.pollInterval = options.poll || 10000;
+    this.config = options.config || {};
+    this.running = false;
+    this.db = null;
+    this.httpServer = null;
+    this.cronTimer = null;
+    this.pollTimer = null;
+    this.cronJobs = [];
+    this.lastCronCheck = null;
+    this.eventLog = [];
+    this.startedAt = null;
+  }
+
+  log(level, message, data) {
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      squad: this.squadSlug,
+      message,
+      ...(data || {})
+    };
+    this.eventLog.push(entry);
+    if (this.eventLog.length > 500) this.eventLog.shift();
+    return entry;
+  }
+
+  async start() {
+    // 1. Open runtime DB
+    const handle = await openRuntimeDb(this.projectDir, { mustExist: false });
+    if (!handle) {
+      throw new Error('Could not open runtime database');
+    }
+    this.db = handle.db;
+
+    // 2. Load workers and register cron jobs
+    const workers = await listWorkers(this.projectDir, this.squadSlug);
+    this.cronJobs = [];
+    for (const worker of workers) {
+      if (worker.type === 'scheduled' && worker.trigger && worker.trigger.cron) {
+        const parsed = parseCronExpression(worker.trigger.cron);
+        if (parsed) {
+          this.cronJobs.push({ workerSlug: worker.slug, cron: worker.trigger.cron, parsed });
+        }
+      }
+    }
+
+    // 3. Start webhook HTTP server
+    this.httpServer = await this._startWebhookServer();
+
+    // 4. Start cron check loop (every 60s, checks at minute boundaries)
+    this.lastCronCheck = new Date();
+    this.cronTimer = setInterval(() => this._checkCron(), 60000);
+
+    // 5. Start event poll loop
+    this.pollTimer = setInterval(() => this._pollEvents(), this.pollInterval);
+
+    // 6. Register daemon in SQLite
+    this._upsertDaemonRecord('running');
+
+    this.running = true;
+    await this._processInbox();
+
+    this.startedAt = new Date().toISOString();
+    this.log('info', 'Daemon started', {
+      port: this.webhookPort,
+      cronJobs: this.cronJobs.length,
+      workers: workers.length
+    });
+
+    return {
+      port: this.webhookPort,
+      cronJobs: this.cronJobs.length,
+      workers: workers.length
+    };
+  }
+
+  async stop() {
+    this.running = false;
+
+    if (this.cronTimer) {
+      clearInterval(this.cronTimer);
+      this.cronTimer = null;
+    }
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+
+    if (this.httpServer) {
+      await new Promise((resolve) => this.httpServer.close(resolve));
+      this.httpServer = null;
+    }
+
+    this._upsertDaemonRecord('stopped');
+
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+
+    this.log('info', 'Daemon stopped');
+  }
+
+  getStatus() {
+    return {
+      squad: this.squadSlug,
+      running: this.running,
+      port: this.webhookPort,
+      startedAt: this.startedAt,
+      cronJobs: this.cronJobs.map(j => ({ worker: j.workerSlug, cron: j.cron })),
+      recentLogs: this.eventLog.slice(-20)
+    };
+  }
+
+  // --- Private methods ---
+
+  _startWebhookServer() {
+    return new Promise((resolve, reject) => {
+      const server = http.createServer(async (req, res) => {
+        await this._handleWebhook(req, res);
+      });
+      server.on('error', reject);
+      const bindAddr = this.config.webhook?.bind || '127.0.0.1';
+      server.listen(this.webhookPort, bindAddr, () => {
+        this.webhookPort = server.address().port;
+        resolve(server);
+      });
+    });
+  }
+
+  async _handleWebhook(req, res) {
+    const segments = (req.url || '').replace(/\/+$/, '').split('/').filter(Boolean);
+
+    // Status aceita GET e POST (health check externo)
+    if (segments[0] === 'status' && segments.length === 1) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(this.getStatus()));
+      return;
+    }
+
+    if (req.method !== 'POST' && req.method !== 'OPTIONS') {
+      res.writeHead(405, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Method not allowed' }));
+      return;
+    }
+
+    // Read raw body (must be before JSON.parse so HMAC validates original bytes)
+    let rawBody = '';
+    for await (const chunk of req) rawBody += chunk;
+
+    // HMAC signature validation
+    if (this.config.webhook?.validate_signature) {
+      const { createHmac, timingSafeEqual } = require('node:crypto');
+      const envKey = this.config.webhook.signature_env || 'WEBHOOK_SECRET';
+      const headerKey = (this.config.webhook.signature_header || 'x-hub-signature-256').toLowerCase();
+      const secret = process.env[envKey];
+      const receivedSig = req.headers[headerKey];
+
+      if (!secret || !receivedSig) {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'signature_required' }));
+        return;
+      }
+      const expected = 'sha256=' + createHmac('sha256', secret).update(rawBody).digest('hex');
+      try {
+        if (!timingSafeEqual(Buffer.from(receivedSig), Buffer.from(expected))) {
+          res.writeHead(401, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ error: 'invalid_signature' }));
+          return;
+        }
+      } catch {
+        res.writeHead(401, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'invalid_signature' }));
+        return;
+      }
+    }
+
+    let payload;
+    try {
+      payload = JSON.parse(rawBody || '{}');
+    } catch {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+      return;
+    }
+
+    // POST /call/:worker (inter-squad)
+    if (segments[0] === 'call' && segments[1]) {
+      const depth = payload?._inter_squad?.depth ?? 0;
+      if (depth > 5) {
+        res.writeHead(429, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'cascade_guard' }));
+        return;
+      }
+      const result = await this._executeWorker(segments[1], payload, 'inter-squad');
+      res.writeHead(result.ok ? 200 : 500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+      return;
+    }
+
+    // /api/:path (public API endpoints)
+    if (segments[0] === 'api' && segments[1]) {
+      const apiPath = '/' + segments[1];
+      const endpoint = (this.config.api_endpoints || []).find(e => e.path === apiPath);
+
+      if (!endpoint) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'api_endpoint_not_found' }));
+        return;
+      }
+
+      const origin = req.headers['origin'];
+      const corsOrigins = endpoint.cors_origins || [];
+      if (origin && corsOrigins.includes(origin)) {
+        res.setHeader('Access-Control-Allow-Origin', origin);
+        res.setHeader('Access-Control-Allow-Methods', endpoint.method || 'POST');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        res.setHeader('Vary', 'Origin');
+      }
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      const result = await this._executeWorker(endpoint.worker, payload, 'api');
+      res.writeHead(result.ok ? 200 : 500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+      return;
+    }
+
+    if (segments[0] !== 'webhook' || !segments[1]) {
+      res.writeHead(404, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'Not found. Use POST /webhook/<worker-slug>' }));
+      return;
+    }
+
+    const workerSlug = segments[1];
+
+    this.log('info', `Webhook received for ${workerSlug}`, { payload });
+
+    // Execute worker
+    const result = await this._executeWorker(workerSlug, payload, 'webhook');
+
+    const statusCode = result.ok ? 200 : 500;
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(result));
+  }
+
+  async _checkCron() {
+    if (!this.running || this.cronJobs.length === 0) return;
+
+    const now = new Date();
+    for (const job of this.cronJobs) {
+      if (cronMatches(job.parsed, now)) {
+        this.log('info', `Cron triggered: ${job.workerSlug}`, { cron: job.cron });
+        this._executeWorker(job.workerSlug, {}, 'scheduled').catch(err => {
+          this.log('error', `Cron execution failed: ${job.workerSlug}`, { error: err.message });
+        });
+      }
+    }
+    this.lastCronCheck = now;
+
+    // Update heartbeat
+    this._updateHeartbeat();
+  }
+
+  async _pollEvents() {
+    if (!this.running || !this.db) return;
+
+    // Poll for pending handoffs targeted at this squad
+    try {
+      const pending = this.db.prepare(
+        "SELECT * FROM squad_handoffs WHERE to_squad = ? AND status = 'pending' ORDER BY created_at ASC LIMIT 5"
+      ).all(this.squadSlug);
+
+      for (const handoff of pending) {
+        const payload = handoff.payload_json ? JSON.parse(handoff.payload_json) : {};
+        this.log('info', `Handoff received from ${handoff.from_squad}`, { handoffId: handoff.id });
+
+        // Find event-triggered workers
+        const workers = await listWorkers(this.projectDir, this.squadSlug);
+        for (const w of workers) {
+          if (w.type === 'event' && w.trigger && w.trigger.source === 'handoff') {
+            await this._executeWorker(w.slug, payload, 'event');
+          }
+        }
+
+        // Mark handoff consumed
+        this.db.prepare(
+          "UPDATE squad_handoffs SET status = 'consumed', consumed_at = datetime('now') WHERE id = ?"
+        ).run(handoff.id);
+      }
+    } catch (err) {
+      this.log('error', 'Poll error', { error: err.message });
+    }
+
+    this._updateHeartbeat();
+  }
+
+  async _executeWorker(workerSlug, inputPayload, triggerType) {
+    const result = await runWorker(this.projectDir, this.squadSlug, workerSlug, inputPayload, {
+      triggerType,
+      noRetry: false
+    });
+
+    // Log to runtime store
+    if (this.db) {
+      try {
+        const conversationId = triggerType === 'inter-squad'
+          ? inputPayload?._inter_squad?.conversationId
+          : undefined;
+        insertWorkerRun(this.db, {
+          squadSlug: this.squadSlug,
+          workerSlug,
+          triggerType,
+          inputJson: JSON.stringify(inputPayload),
+          outputJson: result.ok ? JSON.stringify(result.output) : null,
+          status: result.ok ? 'completed' : 'failed',
+          errorMessage: result.ok ? null : result.error,
+          durationMs: result.durationMs || 0,
+          attempt: result.attempt || 1,
+          conversationId
+        });
+      } catch (err) {
+        this.log('error', 'Failed to log worker run', { error: err.message });
+      }
+    }
+
+    this.log(result.ok ? 'info' : 'error', `Worker ${workerSlug}: ${result.ok ? 'completed' : 'failed'}`, {
+      triggerType,
+      durationMs: result.durationMs
+    });
+
+    return result;
+  }
+
+  async _processInbox() {
+    const inboxDir = path.join(this.projectDir, '.aioson', 'squads', this.squadSlug, 'inbox');
+    let entries;
+    try { entries = await fs.readdir(inboxDir); } catch { return; }
+
+    for (const file of entries.filter(f => f.endsWith('.json'))) {
+      const filePath = path.join(inboxDir, file);
+      try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const msg = JSON.parse(raw);
+        const result = await this._executeWorker(msg.worker, msg.payload, 'inter-squad');
+        if (result.ok) {
+          await fs.unlink(filePath);
+        } else {
+          const failDir = path.join(inboxDir, 'failed');
+          await fs.mkdir(failDir, { recursive: true });
+          await fs.rename(filePath, path.join(failDir, file));
+        }
+      } catch {
+        // arquivo corrompido — mover para failed
+      }
+    }
+  }
+
+  _upsertDaemonRecord(status) {
+    if (!this.db) return;
+    try {
+      this.db.prepare(`
+        INSERT INTO squad_daemons (squad_slug, status, pid, port, started_at, last_heartbeat, config_json)
+        VALUES (@squad_slug, @status, @pid, @port, @started_at, @last_heartbeat, @config_json)
+        ON CONFLICT(squad_slug) DO UPDATE SET
+          status = excluded.status,
+          pid = excluded.pid,
+          port = excluded.port,
+          started_at = CASE WHEN excluded.status = 'running' THEN excluded.started_at ELSE squad_daemons.started_at END,
+          last_heartbeat = excluded.last_heartbeat,
+          config_json = excluded.config_json,
+          error_message = NULL
+      `).run({
+        squad_slug: this.squadSlug,
+        status,
+        pid: process.pid,
+        port: this.webhookPort || null,
+        started_at: this.startedAt || new Date().toISOString(),
+        last_heartbeat: new Date().toISOString(),
+        config_json: JSON.stringify({
+          cronJobs: this.cronJobs.map(j => ({ worker: j.workerSlug, cron: j.cron }))
+        })
+      });
+    } catch {
+      // Ignore — daemon record is nice-to-have
+    }
+  }
+
+  _updateHeartbeat() {
+    if (!this.db) return;
+    try {
+      this.db.prepare(
+        "UPDATE squad_daemons SET last_heartbeat = datetime('now') WHERE squad_slug = ?"
+      ).run(this.squadSlug);
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+module.exports = {
+  SquadDaemon,
+  parseCronExpression,
+  cronMatches,
+  parseCronField
+};