@jaimevalasek/aioson 1.3.0 → 1.5.1

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
+};

package/src/squad-dashboard/api.js

@@ -0,0 +1,223 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const {
+  getSquadOverview,
+  getRecentContent,
+  getLearnings,
+  getRecentDeliveries,
+  getRecentEvents,
+  getSquadMetrics
+} = require('./metrics');
+const { getContextUsage } = require('./context-monitor');
+const { getTokenUsage } = require('./token-tracker');
+const { getActiveProcesses, stopProcess } = require('./process-monitor');
+const { getHunks, updateHunk, getReviewProgress, HUNK_STATES } = require('./hunk-review');
+const { generateRecovery, readRecovery } = require('../squad/recovery-context');
+const { getLogsForTask, getSessionLog } = require('./execution-logs');
+
+const SQUADS_DIR = path.join('.aioson', 'squads');
+
+async function loadSquadList(projectDir) {
+  const squadsDir = path.join(projectDir, SQUADS_DIR);
+  let entries;
+  try {
+    entries = await fs.readdir(squadsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  const squads = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const manifestPath = path.join(squadsDir, entry.name, 'squad.manifest.json');
+    try {
+      const raw = await fs.readFile(manifestPath, 'utf8');
+      const manifest = JSON.parse(raw);
+      squads.push({
+        slug: entry.name,
+        name: manifest.name || entry.name,
+        mode: manifest.mode || 'mixed',
+        goal: manifest.goal || '',
+        status: manifest.status || 'active',
+        executorCount: (manifest.executors || []).length,
+        manifest
+      });
+    } catch {
+      squads.push({
+        slug: entry.name,
+        name: entry.name,
+        mode: 'unknown',
+        goal: '',
+        status: 'unknown',
+        executorCount: 0,
+        manifest: null
+      });
+    }
+  }
+  return squads;
+}
+
+function detectPanels(manifest) {
+  const panels = ['overview', 'content', 'learnings', 'logs'];
+
+  if (manifest) {
+    if (manifest.mode === 'content') panels.push('content-preview');
+    if (manifest.mode === 'software') panels.push('tasks');
+
+    const hasWebhooks = manifest.outputStrategy &&
+      manifest.outputStrategy.delivery &&
+      Array.isArray(manifest.outputStrategy.delivery.webhooks) &&
+      manifest.outputStrategy.delivery.webhooks.length > 0;
+    const hasMcps = Array.isArray(manifest.mcps) && manifest.mcps.length > 0;
+    if (hasWebhooks || hasMcps) panels.push('integrations');
+
+    const channelMcps = (manifest.mcps || []).filter(function (m) {
+      return ['whatsapp', 'telegram', 'sms', 'voice'].some(function (ch) {
+        return (m.slug || '').includes(ch);
+      });
+    });
+    if (channelMcps.length > 0) panels.push('channels');
+  }
+
+  panels.push('metrics');
+  panels.push('processes');
+  return panels;
+}
+
+function loadSquadData(db, squadSlug) {
+  const overview = getSquadOverview(db, squadSlug);
+  const content = getRecentContent(db, squadSlug);
+  const learnings = getLearnings(db, squadSlug);
+  const deliveries = getRecentDeliveries(db, squadSlug);
+  const events = getRecentEvents(db, squadSlug);
+  const customMetrics = getSquadMetrics(db, squadSlug);
+
+  return {
+    overview,
+    content,
+    learnings,
+    deliveries,
+    events,
+    customMetrics,
+    pipelineInfo: overview.pipelineInfo,
+    metrics: {
+      content_items: overview.contentItems,
+      sessions: overview.sessions,
+      learnings: overview.learnings,
+      delivery_rate: overview.deliveryRate
+    }
+  };
+}
+
+/**
+ * GET /api/squads/:slug/context
+ * Returns context usage with warning levels for all agents in a squad.
+ */
+async function getContextData(projectDir, squadSlug, agentSlug) {
+  return getContextUsage(projectDir, squadSlug, agentSlug || null);
+}
+
+/**
+ * GET /api/squads/:slug/tokens?breakdown=true
+ * Returns token usage with cost estimates and waste flags.
+ */
+async function getTokenData(projectDir, squadSlug, breakdown) {
+  return getTokenUsage(projectDir, squadSlug, breakdown);
+}
+
+/**
+ * GET /api/processes[?squad=:slug]
+ * Returns active agent processes across all squads (or filtered by squad).
+ */
+async function getProcesses(projectDir, squadSlug) {
+  return getActiveProcesses(projectDir, squadSlug || null);
+}
+
+/**
+ * POST /api/processes/:pid/stop
+ * Sends SIGTERM to the process and removes its process file.
+ */
+async function stopProcessById(projectDir, pid) {
+  return stopProcess(projectDir, pid);
+}
+
+/**
+ * GET /api/tasks/:id/hunks
+ * Returns hunk review state for a task.
+ * Requires squadSlug and optionally diff (to init on first call).
+ */
+async function getTaskHunks(projectDir, squadSlug, taskId, diff) {
+  return getHunks(projectDir, squadSlug, taskId, diff || null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/approve
+ */
+async function approveHunk(projectDir, squadSlug, taskId, hunkId) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.APPROVED, null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/reject
+ */
+async function rejectHunk(projectDir, squadSlug, taskId, hunkId, comment) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.REJECTED, comment || null);
+}
+
+/**
+ * POST /api/tasks/:id/hunks/:hunkId/comment
+ */
+async function commentHunk(projectDir, squadSlug, taskId, hunkId, comment) {
+  return updateHunk(projectDir, squadSlug, taskId, hunkId, HUNK_STATES.REVISED, comment || null);
+}
+
+/**
+ * GET /api/squads/:slug/agents/:agent/recovery
+ * Returns the recovery-context.md for an agent (generates if missing).
+ */
+async function getAgentRecovery(projectDir, squadSlug, agentSlug) {
+  // Try to read existing first
+  const existing = await readRecovery(projectDir, squadSlug);
+  if (existing) return { ok: true, content: existing, squadSlug, agentSlug };
+  // Generate on demand
+  const result = await generateRecovery(projectDir, squadSlug, agentSlug);
+  if (!result.ok) return result;
+  const content = await readRecovery(projectDir, squadSlug);
+  return { ok: true, content, squadSlug, agentSlug, tokens: result.tokens };
+}
+
+/**
+ * GET /api/squads/:slug/tasks/:taskId/logs
+ * Returns all session logs for a task, sorted oldest-first.
+ */
+async function getTaskLogs(projectDir, squadSlug, taskId) {
+  return getLogsForTask(projectDir, squadSlug, taskId);
+}
+
+/**
+ * GET /api/squads/:slug/tasks/:taskId/logs/:sessionId
+ * Returns a single session log by sessionId.
+ */
+async function getTaskSessionLog(projectDir, squadSlug, taskId, sessionId) {
+  return getSessionLog(projectDir, squadSlug, taskId, sessionId);
+}
+
+module.exports = {
+  loadSquadList,
+  detectPanels,
+  loadSquadData,
+  getContextData,
+  getTokenData,
+  getProcesses,
+  stopProcessById,
+  getTaskHunks,
+  approveHunk,
+  rejectHunk,
+  commentHunk,
+  getAgentRecovery,
+  getReviewProgress,
+  getTaskLogs,
+  getTaskSessionLog
+};