daemora 1.0.0

package/src/core/CostTracker.js

@@ -0,0 +1,116 @@
+import { readFileSync, existsSync, appendFileSync, mkdirSync } from "fs";
+import { config } from "../config/default.js";
+import { models } from "../config/models.js";
+import eventBus from "./EventBus.js";
+import tenantContext from "../tenants/TenantContext.js";
+
+const COSTS_DIR = config.costsDir;
+mkdirSync(COSTS_DIR, { recursive: true });
+
+/**
+ * Get today's cost log file path.
+ */
+function getTodayLogPath() {
+  const today = new Date().toISOString().split("T")[0];
+  return `${COSTS_DIR}/${today}.jsonl`;
+}
+
+/**
+ * Log a cost entry.
+ * tenantId is automatically added from TenantContext when available.
+ */
+export function logCost({ taskId, modelId, inputTokens, outputTokens, estimatedCost, tenantId = null }) {
+  const entry = {
+    timestamp: new Date().toISOString(),
+    taskId,
+    modelId,
+    inputTokens,
+    outputTokens,
+    estimatedCost,
+    tenantId,
+  };
+  appendFileSync(getTodayLogPath(), JSON.stringify(entry) + "\n");
+}
+
+/**
+ * Get total cost spent today (global — all tenants combined).
+ */
+export function getTodayCost() {
+  const logPath = getTodayLogPath();
+  if (!existsSync(logPath)) return 0;
+
+  const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  return lines.reduce((sum, line) => {
+    try {
+      const entry = JSON.parse(line);
+      return sum + (entry.estimatedCost || 0);
+    } catch {
+      return sum;
+    }
+  }, 0);
+}
+
+/**
+ * Get total cost spent today for a specific tenant.
+ *
+ * @param {string} tenantId
+ * @returns {number}
+ */
+export function getTenantTodayCost(tenantId) {
+  if (!tenantId) return 0;
+  const logPath = getTodayLogPath();
+  if (!existsSync(logPath)) return 0;
+
+  const lines = readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+  return lines.reduce((sum, line) => {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.tenantId !== tenantId) return sum;
+      return sum + (entry.estimatedCost || 0);
+    } catch {
+      return sum;
+    }
+  }, 0);
+}
+
+/**
+ * Check if global daily budget is exceeded.
+ */
+export function isDailyBudgetExceeded() {
+  return getTodayCost() >= config.maxDailyCost;
+}
+
+/**
+ * Check if a specific tenant's daily budget is exceeded.
+ *
+ * @param {string} tenantId
+ * @param {number} maxDailyCost
+ * @returns {boolean}
+ */
+export function isTenantDailyBudgetExceeded(tenantId, maxDailyCost) {
+  if (!tenantId || !maxDailyCost) return false;
+  return getTenantTodayCost(tenantId) >= maxDailyCost;
+}
+
+/**
+ * Estimate cost for a model call.
+ */
+export function estimateCost(modelId, inputTokens, outputTokens) {
+  const meta = models[modelId];
+  if (!meta) return 0;
+  return (inputTokens / 1000) * meta.costPer1kInput + (outputTokens / 1000) * meta.costPer1kOutput;
+}
+
+// Auto-log costs from EventBus — includes tenantId from TenantContext
+eventBus.on("model:called", (data) => {
+  const tenantId = tenantContext.getStore()?.tenant?.id || null;
+  const cost = estimateCost(data.modelId, data.inputTokens || 0, data.outputTokens || 0);
+  logCost({
+    taskId: data.taskId || "unknown",
+    modelId: data.modelId,
+    inputTokens: data.inputTokens || 0,
+    outputTokens: data.outputTokens || 0,
+    estimatedCost: cost,
+    tenantId,
+  });
+});

package/src/core/EventBus.js

@@ -0,0 +1,46 @@
+import { EventEmitter } from "events";
+
+/**
+ * Global event bus for inter-module communication.
+ *
+ * Events:
+ *   task:created      — new task enqueued
+ *   task:started      — task picked up by runner
+ *   task:completed    — task finished successfully
+ *   task:failed       — task failed
+ *   tool:before       — about to execute a tool (PreToolUse hook point)
+ *   tool:after        — tool execution finished (PostToolUse hook point)
+ *   tool:blocked      — tool call was blocked by safety
+ *   agent:spawned     — sub-agent created
+ *   agent:finished    — sub-agent completed
+ *   agent:killed      — sub-agent terminated by supervisor
+ *   model:called      — LLM API call made (for cost tracking)
+ *   compact:triggered — context compaction started
+ *   memory:written    — memory entry added
+ *   secret:detected   — secret found and redacted
+ *   audit:event       — generic audit event
+ */
+class AgentEventBus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(50);
+  }
+
+  /**
+   * Emit and log an event for audit trail.
+   */
+  emitEvent(event, data = {}) {
+    const payload = {
+      event,
+      timestamp: new Date().toISOString(),
+      ...data,
+    };
+    this.emit(event, payload);
+    this.emit("audit:event", payload);
+    return payload;
+  }
+}
+
+// Singleton
+const eventBus = new AgentEventBus();
+export default eventBus;

package/src/core/Task.js

@@ -0,0 +1,67 @@
+import { v4 as uuidv4 } from "uuid";
+
+/**
+ * Task data model.
+ *
+ * States: pending → running → completed | failed
+ *
+ * Every incoming request (from any channel) becomes a Task.
+ */
+export function createTask({
+  input,
+  channel = "http",
+  channelMeta = {},
+  sessionId = null,
+  priority = 5,
+  model = null,
+  maxCost = null,
+  approvalMode = "auto",
+}) {
+  return {
+    id: uuidv4(),
+    status: "pending",
+    input,                // user's message text
+    channel,              // http | telegram | whatsapp | email | a2a
+    channelMeta,          // channel-specific metadata (chat_id, phone, email, etc.)
+    sessionId,            // link to conversation session
+    priority,             // 1 (highest) - 10 (lowest)
+    model,                // explicit model override or null (use default)
+    maxCost,              // per-task cost budget or null (use global)
+    approvalMode,         // auto | dangerous-only | every-tool | milestones
+    result: null,         // final response text
+    error: null,          // error message if failed
+    cost: {
+      inputTokens: 0,
+      outputTokens: 0,
+      estimatedCost: 0,
+      modelCalls: 0,
+    },
+    toolCalls: [],        // log of tool calls: { tool, params, duration, output_preview }
+    createdAt: new Date().toISOString(),
+    startedAt: null,
+    completedAt: null,
+  };
+}
+
+/**
+ * Task state transitions.
+ */
+export function startTask(task) {
+  task.status = "running";
+  task.startedAt = new Date().toISOString();
+  return task;
+}
+
+export function completeTask(task, result) {
+  task.status = "completed";
+  task.result = result;
+  task.completedAt = new Date().toISOString();
+  return task;
+}
+
+export function failTask(task, error) {
+  task.status = "failed";
+  task.error = error;
+  task.completedAt = new Date().toISOString();
+  return task;
+}

package/src/core/TaskQueue.js

@@ -0,0 +1,206 @@
+import { createTask, startTask, completeTask, failTask } from "./Task.js";
+import { saveTask, loadTask, recoverStaleTasks } from "../storage/TaskStore.js";
+import eventBus from "./EventBus.js";
+
+/**
+ * In-memory priority task queue with file persistence.
+ *
+ * Tasks are:
+ * 1. Enqueued (from any channel) → status: pending
+ * 2. Dequeued by TaskRunner → status: running
+ * 3. Completed or Failed → status: completed/failed
+ *
+ * File persistence: every state change saves to data/tasks/.
+ * On crash recovery: stale "running" tasks are reset to "pending".
+ */
+class TaskQueue {
+  constructor() {
+    this.queue = []; // sorted by priority (lower number = higher priority)
+    this.active = new Map(); // taskId → task (currently running)
+    this.waiters = new Map(); // taskId → { resolve, reject } for sync HTTP callers
+  }
+
+  /**
+   * Initialize queue — recover any stale tasks from previous crash.
+   */
+  init() {
+    recoverStaleTasks();
+    console.log(`[TaskQueue] Initialized`);
+  }
+
+  /**
+   * Add a new task to the queue.
+   * @returns {object} The created task
+   */
+  enqueue(taskInput) {
+    const task = createTask(taskInput);
+    saveTask(task);
+
+    // Insert into queue sorted by priority
+    const insertIdx = this.queue.findIndex((t) => t.priority > task.priority);
+    if (insertIdx === -1) {
+      this.queue.push(task);
+    } else {
+      this.queue.splice(insertIdx, 0, task);
+    }
+
+    eventBus.emitEvent("task:created", { taskId: task.id, channel: task.channel, priority: task.priority });
+    console.log(`[TaskQueue] Enqueued task ${task.id} (priority: ${task.priority}, queue size: ${this.queue.length})`);
+
+    return task;
+  }
+
+  /**
+   * Get the next task to process.
+   * @param {Set<string>} skipSessions - Session IDs currently being processed (skip tasks from these sessions)
+   * @returns {object|null} Next task or null if queue is empty or all tasks are session-blocked
+   */
+  dequeue(skipSessions = null) {
+    if (this.queue.length === 0) return null;
+
+    // Find first task not belonging to an already-active session.
+    // This prevents two messages from the same user running concurrently,
+    // which would cause history corruption (last-write-wins on setMessages).
+    let idx = 0;
+    if (skipSessions && skipSessions.size > 0) {
+      idx = this.queue.findIndex(
+        (t) => !t.sessionId || !skipSessions.has(t.sessionId)
+      );
+      if (idx === -1) return null; // all pending tasks are session-blocked
+    }
+
+    const [task] = this.queue.splice(idx, 1);
+    startTask(task);
+    saveTask(task);
+    this.active.set(task.id, task);
+
+    eventBus.emitEvent("task:started", { taskId: task.id });
+    return task;
+  }
+
+  /**
+   * Mark a task as completed.
+   */
+  complete(taskId, result) {
+    const task = this.active.get(taskId);
+    if (!task) return;
+
+    completeTask(task, result);
+    saveTask(task);
+    this.active.delete(taskId);
+
+    eventBus.emitEvent("task:completed", { taskId: task.id, cost: task.cost });
+
+    // Resolve any sync waiters
+    const waiter = this.waiters.get(taskId);
+    if (waiter) {
+      waiter.resolve(task);
+      this.waiters.delete(taskId);
+    }
+
+    return task;
+  }
+
+  /**
+   * Mark a task as failed.
+   */
+  fail(taskId, error) {
+    const task = this.active.get(taskId);
+    if (!task) return;
+
+    failTask(task, error);
+    saveTask(task);
+    this.active.delete(taskId);
+
+    eventBus.emitEvent("task:failed", { taskId: task.id, error });
+
+    // Reject any sync waiters
+    const waiter = this.waiters.get(taskId);
+    if (waiter) {
+      waiter.resolve(task); // resolve not reject — caller handles error state
+      this.waiters.delete(taskId);
+    }
+
+    return task;
+  }
+
+  /**
+   * Wait for a task to complete (used by sync HTTP callers).
+   * @returns {Promise<object>} The completed task
+   */
+  waitForCompletion(taskId, timeoutMs = 300000) {
+    return new Promise((resolve, reject) => {
+      // Check if already done
+      const existing = loadTask(taskId);
+      if (existing && (existing.status === "completed" || existing.status === "failed")) {
+        resolve(existing);
+        return;
+      }
+
+      // Timeout guard — prevent hanging forever (default 5 min)
+      const timer = setTimeout(() => {
+        this.waiters.delete(taskId);
+        resolve({
+          id: taskId,
+          status: "failed",
+          result: "Task timed out after " + (timeoutMs / 1000) + " seconds. The task may still be running in the background.",
+        });
+      }, timeoutMs);
+
+      this.waiters.set(taskId, {
+        resolve: (task) => { clearTimeout(timer); resolve(task); },
+        reject: (err) => { clearTimeout(timer); reject(err); },
+      });
+    });
+  }
+
+  /**
+   * Get queue stats.
+   */
+  stats() {
+    return {
+      pending: this.queue.length,
+      active: this.active.size,
+      waiters: this.waiters.size,
+    };
+  }
+
+  /**
+   * Peek at the next task without removing it.
+   * @returns {object|null}
+   */
+  peek() {
+    return this.queue[0] || null;
+  }
+
+  /**
+   * Silently absorb a task into the already-running session.
+   * Marks it completed with merged=true so channels skip sending a reply.
+   */
+  merge(taskId) {
+    const task = this.active.get(taskId);
+    if (!task) return;
+    completeTask(task, "");
+    task.merged = true;
+    saveTask(task);
+    this.active.delete(taskId);
+    eventBus.emitEvent("task:completed", { taskId: task.id, merged: true });
+    const waiter = this.waiters.get(taskId);
+    if (waiter) {
+      waiter.resolve(task);
+      this.waiters.delete(taskId);
+    }
+    return task;
+  }
+
+  /**
+   * Check if there are tasks to process.
+   */
+  hasWork() {
+    return this.queue.length > 0;
+  }
+}
+
+// Singleton
+const taskQueue = new TaskQueue();
+export default taskQueue;

package/src/core/TaskRunner.js

@@ -0,0 +1,226 @@
+import { runAgentLoop } from "./AgentLoop.js";
+import { buildSystemPrompt } from "../systemPrompt.js";
+import { toolFunctions } from "../tools/index.js";
+import { createSession, getSession, setMessages } from "../services/sessions.js";
+import taskQueue from "./TaskQueue.js";
+import { isDailyBudgetExceeded, isTenantDailyBudgetExceeded } from "./CostTracker.js";
+import { config } from "../config/default.js";
+import tenantManager from "../tenants/TenantManager.js";
+import tenantContext from "../tenants/TenantContext.js";
+
+/**
+ * Task runner — worker loop that picks tasks from the queue and executes them.
+ *
+ * Configurable concurrency (default: 2 parallel tasks).
+ */
+class TaskRunner {
+  constructor() {
+    this.running = false;
+    this.concurrency = 2;
+    this.activeCount = 0;
+    this.activeSessions = new Set();      // session IDs currently being processed
+    this.sessionSteerQueues = new Map();  // sessionId → steerQueue[] for inject-on-concurrent
+    this.pollInterval = null;
+  }
+
+  /**
+   * Start the runner.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+
+    // Poll for new tasks every 500ms
+    this.pollInterval = setInterval(() => this.tick(), 500);
+    console.log(`[TaskRunner] Started (concurrency: ${this.concurrency})`);
+  }
+
+  /**
+   * Stop the runner.
+   */
+  stop() {
+    this.running = false;
+    if (this.pollInterval) {
+      clearInterval(this.pollInterval);
+      this.pollInterval = null;
+    }
+    console.log(`[TaskRunner] Stopped`);
+  }
+
+  /**
+   * Poll tick — pick up work if available and under concurrency limit.
+   */
+  tick() {
+    if (!this.running) return;
+    if (!taskQueue.hasWork()) return;
+
+    // ── Steer/inject: if next task belongs to an already-running session,
+    //    append its message into the live agent loop rather than spawning a
+    //    second loop.  The agent picks it up between tool calls (like Claude Code).
+    // This runs regardless of concurrency — no extra slot needed.
+    const nextTask = taskQueue.peek();
+    if (nextTask?.sessionId && this.sessionSteerQueues.has(nextTask.sessionId)) {
+      const steerTask = taskQueue.dequeue(); // consume from queue
+      const steerQueue = this.sessionSteerQueues.get(steerTask.sessionId);
+      steerQueue.push({ type: "user", content: steerTask.input }); // inject into live loop
+      taskQueue.merge(steerTask.id);         // complete silently — no duplicate reply
+      console.log(`[TaskRunner] Follow-up "${steerTask.input.slice(0, 60)}" injected into running session ${steerTask.sessionId}`);
+      return;
+    }
+
+    // For starting a fresh agent loop, check concurrency + budget limits
+    if (this.activeCount >= this.concurrency) return;
+
+    if (isDailyBudgetExceeded()) {
+      console.log(`[TaskRunner] Daily budget exceeded ($${config.maxDailyCost}). Pausing.`);
+      return;
+    }
+
+    // Normal path: start a fresh agent loop for this task
+    const task = taskQueue.dequeue(this.activeSessions);
+    if (!task) return;
+
+    // Set up steerQueue synchronously before processTask (no async gap → no race)
+    const steerQueue = [];
+    if (task.sessionId) {
+      this.activeSessions.add(task.sessionId);
+      this.sessionSteerQueues.set(task.sessionId, steerQueue);
+    }
+
+    this.activeCount++;
+    this.processTask(task, steerQueue).finally(() => {
+      this.activeCount--;
+      if (task.sessionId) {
+        this.activeSessions.delete(task.sessionId);
+        this.sessionSteerQueues.delete(task.sessionId);
+      }
+    });
+  }
+
+  /**
+   * Process a single task.
+   * @param {object} task
+   * @param {Array} steerQueue - Shared array; follow-up messages from the same session are
+   *                             pushed here and picked up by AgentLoop between tool calls.
+   */
+  async processTask(task, steerQueue = []) {
+    console.log(`\n[TaskRunner] Processing task ${task.id} from ${task.channel}`);
+
+    // ── Multi-tenant: resolve tenant and effective config ──────────────────────
+    // Derive userId from sessionId: sessionId = "${channel}-${userId}"
+    let tenant = null;
+    if (task.channel && task.sessionId) {
+      const userId = task.sessionId.slice(task.channel.length + 1);
+      if (userId) {
+        tenant = tenantManager.getOrCreate(task.channel, userId);
+      }
+    }
+
+    // Block suspended tenants immediately
+    if (tenant?.suspended) {
+      const reason = tenant.suspendReason
+        ? `Account suspended: ${tenant.suspendReason}`
+        : "Account suspended. Contact the operator.";
+      console.log(`[TaskRunner] Task ${task.id} rejected — tenant ${tenant.id} is suspended`);
+      taskQueue.fail(task.id, reason);
+      return;
+    }
+
+    // Resolve effective config: tenant config > channel config > global config
+    const resolvedConfig = tenantManager.resolveTaskConfig(tenant, task.channelModel || null);
+
+    // Per-tenant daily budget check (separate from global budget)
+    if (tenant && resolvedConfig.maxDailyCost) {
+      if (isTenantDailyBudgetExceeded(tenant.id, resolvedConfig.maxDailyCost)) {
+        console.log(`[TaskRunner] Task ${task.id} rejected — tenant ${tenant.id} daily budget ($${resolvedConfig.maxDailyCost}) reached`);
+        taskQueue.fail(task.id, `Daily budget of $${resolvedConfig.maxDailyCost} reached. Tasks resume tomorrow.`);
+        return;
+      }
+    }
+
+    // Narrow tool list if tenant has a tool allowlist
+    let tools = resolvedConfig.tools?.length
+      ? Object.fromEntries(Object.entries(toolFunctions).filter(([k]) => resolvedConfig.tools.includes(k)))
+      : { ...toolFunctions };
+
+    // Filter MCP tools by per-tenant mcpServers allowlist (null = all allowed)
+    const allowedMcpServers = resolvedConfig.mcpServers; // null = all
+    if (allowedMcpServers !== null) {
+      tools = Object.fromEntries(
+        Object.entries(tools).filter(([name]) => {
+          if (!name.startsWith("mcp__")) return true;
+          const serverName = name.split("__")[1];
+          return allowedMcpServers.includes(serverName);
+        })
+      );
+    }
+
+    // Resolved model for this task (used by sub-agents to inherit parent model)
+    const resolvedModel = resolvedConfig.model || task.model || config.defaultModel;
+    const apiKeys = resolvedConfig.apiKeys || {};
+
+    try {
+      // Wrap entire task execution in tenant context (AsyncLocalStorage).
+      // This allows FilesystemGuard, memory tools, and other tools to read per-tenant config
+      // without any race conditions across concurrent tasks.
+      await tenantContext.run({ tenant, resolvedConfig, resolvedModel, apiKeys }, async () => {
+        // Get or create session
+        let session = task.sessionId ? getSession(task.sessionId) : null;
+        if (!session) {
+          session = createSession(task.sessionId || null);
+          task.sessionId = session.sessionId;
+        }
+
+        // Build system prompt (SOUL.md + MEMORY.md + semantic recall + daily log + matched skills)
+        const systemPrompt = await buildSystemPrompt(task.input);
+
+        // Build message history
+        const previousMessages = session.messages.map((m) => ({
+          role: m.role,
+          content: m.content,
+        }));
+        const messages = [...previousMessages, { role: "user", content: task.input }];
+
+        // Run agent loop with resolved model, cost limits, and per-tenant API keys.
+        // steerQueue lets follow-up messages from the same user be injected live
+        // between tool calls instead of spawning a competing agent loop.
+        const result = await runAgentLoop({
+          messages,
+          systemPrompt,
+          tools,
+          modelId: resolvedModel,
+          taskId: task.id,
+          approvalMode: task.approvalMode || "auto",
+          channelMeta: task.channelMeta || null,
+          maxCostPerTask: resolvedConfig.maxCostPerTask,
+          apiKeys,
+          steerQueue,
+        });
+
+        // Update session with conversation
+        setMessages(session.sessionId, result.messages);
+
+        // Update task cost info
+        task.cost = result.cost;
+
+        // Record cost against tenant lifetime totals
+        if (tenant) {
+          tenantManager.recordCost(tenant.id, result.cost || 0);
+        }
+
+        // Complete the task
+        taskQueue.complete(task.id, result.text);
+        const costStr = result.cost ? ` cost: $${result.cost.toFixed(4)}` : "";
+        const tenantStr = tenant ? ` tenant: ${tenant.id}` : "";
+        console.log(`[TaskRunner] Task ${task.id} completed (${costStr}${tenantStr})`);
+      });
+    } catch (error) {
+      console.error(`[TaskRunner] Task ${task.id} failed:`, error.message);
+      taskQueue.fail(task.id, error.message);
+    }
+  }
+}
+
+// Singleton
+const taskRunner = new TaskRunner();
+export default taskRunner;