daemora 1.0.3 → 1.0.5

package/skills/webapp-testing/scripts/with_server.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""
+Start one or more servers, wait for them to be ready, run a command, then clean up.
+
+Usage:
+    # Single server
+    python scripts/with_server.py --server "npm run dev" --port 5173 -- python automation.py
+    python scripts/with_server.py --server "npm start" --port 3000 -- python test.py
+
+    # Multiple servers
+    python scripts/with_server.py \
+      --server "cd backend && python server.py" --port 3000 \
+      --server "cd frontend && npm run dev" --port 5173 \
+      -- python test.py
+"""
+
+import subprocess
+import socket
+import time
+import sys
+import argparse
+
+def is_server_ready(port, timeout=30):
+    """Wait for server to be ready by polling the port."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            with socket.create_connection(('localhost', port), timeout=1):
+                return True
+        except (socket.error, ConnectionRefusedError):
+            time.sleep(0.5)
+    return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Run command with one or more servers')
+    parser.add_argument('--server', action='append', dest='servers', required=True, help='Server command (can be repeated)')
+    parser.add_argument('--port', action='append', dest='ports', type=int, required=True, help='Port for each server (must match --server count)')
+    parser.add_argument('--timeout', type=int, default=30, help='Timeout in seconds per server (default: 30)')
+    parser.add_argument('command', nargs=argparse.REMAINDER, help='Command to run after server(s) ready')
+
+    args = parser.parse_args()
+
+    # Remove the '--' separator if present
+    if args.command and args.command[0] == '--':
+        args.command = args.command[1:]
+
+    if not args.command:
+        print("Error: No command specified to run")
+        sys.exit(1)
+
+    # Parse server configurations
+    if len(args.servers) != len(args.ports):
+        print("Error: Number of --server and --port arguments must match")
+        sys.exit(1)
+
+    servers = []
+    for cmd, port in zip(args.servers, args.ports):
+        servers.append({'cmd': cmd, 'port': port})
+
+    server_processes = []
+
+    try:
+        # Start all servers
+        for i, server in enumerate(servers):
+            print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
+
+            # Use shell=True to support commands with cd and &&
+            process = subprocess.Popen(
+                server['cmd'],
+                shell=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            server_processes.append(process)
+
+            # Wait for this server to be ready
+            print(f"Waiting for server on port {server['port']}...")
+            if not is_server_ready(server['port'], timeout=args.timeout):
+                raise RuntimeError(f"Server failed to start on port {server['port']} within {args.timeout}s")
+
+            print(f"Server ready on port {server['port']}")
+
+        print(f"\nAll {len(servers)} server(s) ready")
+
+        # Run the command
+        print(f"Running: {' '.join(args.command)}\n")
+        result = subprocess.run(args.command)
+        sys.exit(result.returncode)
+
+    finally:
+        # Clean up all servers
+        print(f"\nStopping {len(server_processes)} server(s)...")
+        for i, process in enumerate(server_processes):
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait()
+            print(f"Server {i+1} stopped")
+        print("All servers stopped")
+
+
+if __name__ == '__main__':
+    main()

package/src/agents/SubAgentManager.js

@@ -2,10 +2,12 @@ import { runAgentLoop } from "../core/AgentLoop.js";
 import { buildSystemPrompt } from "../systemPrompt.js";
 import { toolFunctions } from "../tools/index.js";
 import { agentProfiles, defaultSubAgentTools } from "../config/agentProfiles.js";
+import { config } from "../config/default.js";
 import eventBus from "../core/EventBus.js";
 import { v4 as uuidv4 } from "uuid";
 import tenantContext from "../tenants/TenantContext.js";
 import { resolveModelForProfile } from "../models/ModelRouter.js";
+import { createSession, getSession, setMessages } from "../services/sessions.js";
 
 /**
  * Sub-Agent Manager - spawns, tracks, kills, and steers sub-agents.
@@ -94,12 +96,14 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     toolOverride         = null,        // exact tool functions - specialist agents only (e.g. MCP)
     systemPromptOverride = null,        // replace system prompt - specialist agents only
     maxCost              = 0.10,
-    timeout              = 120_000,
+    timeout              = 300_000,
     depth                = 0,
     parentTaskId         = null,
     parentContext        = null,
     approvalMode         = "auto",
     channelMeta          = null,
+    historyMessages      = [],     // previous session messages to prepend (persistent sub-agent sessions)
+    returnFullResult     = false,  // return {text, messages, cost} instead of just text
   } = options;
 
   const maxDepth = 3;
@@ -114,11 +118,6 @@ export async function spawnSubAgent(taskDescription, options = {}) {
   const agentId = uuidv4().slice(0, 8);
   const taskId  = `subagent-${agentId}`;
 
-  const profileLabel = profile ? ` [${profile}]` : "";
-  const modelLabel   = resolvedModel ? ` ${C.dim}(${resolvedModel})${C.reset}` : "";
-  _agentLog(C.cyan + C.bold, "🤖 SPAWN", agentId, depth,
-    `${C.cyan}${C.bold}${profileLabel}${C.reset}${modelLabel} "${taskDescription.slice(0, 80)}${taskDescription.length > 80 ? "…" : ""}"`);
-
   // ── Model resolution - priority: explicit > profile routing > parent > global default ───────
   const store = tenantContext.getStore();
   const resolvedModel = model
@@ -126,6 +125,12 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     || store?.resolvedModel
     || config.defaultModel;
 
+  const profileLabel = profile ? ` [${profile}]` : "";
+  const modelLabel   = resolvedModel ? ` ${C.dim}(${resolvedModel})${C.reset}` : "";
+  _agentLog(C.cyan + C.bold, "🤖 SPAWN", agentId, depth,
+    `${C.cyan}${C.bold}${profileLabel}${C.reset}${modelLabel} "${taskDescription.slice(0, 80)}${taskDescription.length > 80 ? "…" : ""}"`);
+
+
   const apiKeys = store?.apiKeys || {};
 
   // ── Tool set ──────────────────────────────────────────────────────────────
@@ -229,11 +234,25 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     taskDescription: taskDescription.slice(0, 100),
   });
 
-  // ── Build initial messages (optionally include parent context) ────────────
-  const initialMessages = [];
+  // ── Auto session load for regular sub-agents (not MCP — they manage their own) ──
+  const mainSessionId = store?.sessionId || null;
+  const shouldManageSession = !toolOverride && historyMessages.length === 0 && mainSessionId;
+  let subSessionId = null;
+
+  if (shouldManageSession) {
+    const sessionKey = profile || "general";
+    subSessionId = `${mainSessionId}--${sessionKey}`;
+    const subSession = getSession(subSessionId);
+    if (subSession && subSession.messages.length > 0) {
+      historyMessages = subSession.messages.map(m => ({ role: m.role, content: m.content }));
+      console.log(`[SubAgent:${agentId}] Loaded ${historyMessages.length} history messages from "${subSessionId}"`);
+    }
+  }
+
+  // ── Build initial messages (include history + optionally parent context) ──
+  const initialMessages = [...historyMessages];
 
   if (parentContext) {
-    // Give the sub-agent a quick summary of what the parent knows
     initialMessages.push({
       role: "user",
       content: `[Context from parent agent]:\n${parentContext}\n\n[Your task]:\n${taskDescription}`,
@@ -249,7 +268,11 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     const result = await Promise.race([
       runAgentLoop({
         messages:     initialMessages,
-        systemPrompt: systemPromptOverride || await buildSystemPrompt(taskDescription),
+        systemPrompt: systemPromptOverride || await buildSystemPrompt(taskDescription, "minimal", {
+          model: resolvedModel,
+          agentId,
+          taskDescription,
+        }),
         tools:        agentTools,
         modelId:      resolvedModel,
         taskId,
@@ -268,10 +291,32 @@ export async function spawnSubAgent(taskDescription, options = {}) {
     ]);
 
     const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
-    const costStr = result.cost ? ` $${result.cost.toFixed(4)}` : "";
+    const costVal = typeof result.cost === "number" ? result.cost : result.cost?.estimatedCost;
+    const costStr = costVal ? ` $${costVal.toFixed(4)}` : "";
     _agentLog(C.green + C.bold, "✅ DONE ", agentId, depth,
       `${C.green}${C.bold}completed in ${elapsed}s${costStr}${C.reset}`);
-    eventBus.emitEvent("agent:finished", { agentId, taskId, parentTaskId, cost: result.cost });
+    eventBus.emitEvent("agent:finished", {
+      agentId, taskId, parentTaskId, cost: result.cost,
+      toolCalls: (result.toolCalls || []).map(tc => ({ tool: tc.tool, duration: tc.duration })),
+      resultPreview: (result.text || "").slice(0, 200),
+      model: resolvedModel,
+      role: profile || "general",
+    });
+
+    // ── Auto session save for regular sub-agents ──────────────────────────
+    if (subSessionId && result.messages) {
+      let subSession = getSession(subSessionId);
+      if (!subSession) subSession = createSession(subSessionId);
+      const capped = result.messages.length > 100
+        ? result.messages.slice(-100)
+        : result.messages;
+      setMessages(subSessionId, capped);
+      console.log(`[SubAgent:${agentId}] Saved ${capped.length} messages to "${subSessionId}"`);
+    }
+
+    if (returnFullResult) {
+      return { text: result.text, messages: result.messages, cost: result.cost };
+    }
     return result.text;
 
   } catch (error) {

package/src/api/openai-compat.js

@@ -0,0 +1,212 @@
+/**
+ * OpenAI-Compatible API — /v1/chat/completions
+ *
+ * Drop-in replacement for OpenAI API. Routes through TaskRunner as a chat task.
+ * Supports both non-streaming and SSE streaming responses.
+ *
+ * Auth: Bearer token from OPENAI_COMPAT_TOKEN or WEBHOOK_TOKEN env var.
+ * Config: openaiCompat.enabled (default false, set OPENAI_COMPAT_ENABLED=true)
+ */
+
+import { Router } from "express";
+import { v4 as uuidv4 } from "uuid";
+import taskQueue from "../core/TaskQueue.js";
+import eventBus from "../core/EventBus.js";
+import { loadTask } from "../storage/TaskStore.js";
+
+const router = Router();
+
+function checkAuth(req, res) {
+  const token = process.env.OPENAI_COMPAT_TOKEN || process.env.WEBHOOK_TOKEN;
+  if (!token) {
+    res.status(503).json({ error: { message: "OpenAI-compat API not configured. Set OPENAI_COMPAT_TOKEN env var.", type: "server_error" } });
+    return false;
+  }
+
+  const authHeader = req.headers.authorization;
+  if (!authHeader || !authHeader.startsWith("Bearer ") || authHeader.slice(7) !== token) {
+    res.status(401).json({ error: { message: "Invalid API key.", type: "invalid_request_error" } });
+    return false;
+  }
+  return true;
+}
+
+/**
+ * POST /v1/chat/completions
+ */
+router.post("/chat/completions", async (req, res) => {
+  if (!checkAuth(req, res)) return;
+
+  const { messages, model, stream = false, max_tokens } = req.body;
+  if (!messages || !Array.isArray(messages) || messages.length === 0) {
+    return res.status(400).json({ error: { message: "messages array is required", type: "invalid_request_error" } });
+  }
+
+  // Extract user message (last user message) and system prompt
+  let systemContent = "";
+  let userContent = "";
+  for (const msg of messages) {
+    if (msg.role === "system") systemContent += msg.content + "\n";
+    if (msg.role === "user") userContent = msg.content;
+  }
+
+  const taskInput = systemContent
+    ? `[System instruction]: ${systemContent.trim()}\n\n${userContent}`
+    : userContent;
+
+  const taskId = uuidv4();
+
+  const task = taskQueue.enqueue({
+    input: taskInput,
+    channel: "openai-compat",
+    sessionId: `compat-${taskId.slice(0, 8)}`,
+    model: model || null,
+    priority: 5,
+    type: "chat",
+  });
+
+  if (stream) {
+    // SSE streaming
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    });
+
+    const completionId = `chatcmpl-${task.id.slice(0, 12)}`;
+
+    const onComplete = (evt) => {
+      if (evt.taskId !== task.id) return;
+      const finalTask = loadTask(task.id);
+      const text = finalTask?.result || "";
+
+      // Send chunks
+      const chunk = {
+        id: completionId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model || "daemora",
+        choices: [{
+          index: 0,
+          delta: { role: "assistant", content: text },
+          finish_reason: "stop",
+        }],
+      };
+      res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+      res.write("data: [DONE]\n\n");
+      cleanup();
+      res.end();
+    };
+
+    const onFail = (evt) => {
+      if (evt.taskId !== task.id) return;
+      const errChunk = {
+        id: completionId,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model: model || "daemora",
+        choices: [{
+          index: 0,
+          delta: { content: `Error: ${evt.error || "Task failed"}` },
+          finish_reason: "stop",
+        }],
+      };
+      res.write(`data: ${JSON.stringify(errChunk)}\n\n`);
+      res.write("data: [DONE]\n\n");
+      cleanup();
+      res.end();
+    };
+
+    eventBus.on("task:completed", onComplete);
+    eventBus.on("task:failed", onFail);
+
+    const cleanup = () => {
+      eventBus.removeListener("task:completed", onComplete);
+      eventBus.removeListener("task:failed", onFail);
+    };
+
+    req.on("close", cleanup);
+
+    // Timeout after 5 minutes
+    setTimeout(() => {
+      cleanup();
+      if (!res.writableEnded) {
+        res.write(`data: ${JSON.stringify({ error: "Timeout" })}\n\n`);
+        res.write("data: [DONE]\n\n");
+        res.end();
+      }
+    }, 300_000);
+
+  } else {
+    // Non-streaming — wait for completion
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          cleanup();
+          reject(new Error("Request timed out after 5 minutes"));
+        }, 300_000);
+
+        const onComplete = (evt) => {
+          if (evt.taskId !== task.id) return;
+          clearTimeout(timeout);
+          cleanup();
+          const finalTask = loadTask(task.id);
+          resolve(finalTask?.result || "");
+        };
+
+        const onFail = (evt) => {
+          if (evt.taskId !== task.id) return;
+          clearTimeout(timeout);
+          cleanup();
+          reject(new Error(evt.error || "Task failed"));
+        };
+
+        eventBus.on("task:completed", onComplete);
+        eventBus.on("task:failed", onFail);
+
+        var cleanup = () => {
+          eventBus.removeListener("task:completed", onComplete);
+          eventBus.removeListener("task:failed", onFail);
+        };
+
+        req.on("close", () => {
+          clearTimeout(timeout);
+          cleanup();
+        });
+      });
+
+      res.json({
+        id: `chatcmpl-${task.id.slice(0, 12)}`,
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: model || "daemora",
+        choices: [{
+          index: 0,
+          message: { role: "assistant", content: result },
+          finish_reason: "stop",
+        }],
+        usage: {
+          prompt_tokens: Math.ceil(taskInput.length / 4),
+          completion_tokens: Math.ceil(result.length / 4),
+          total_tokens: Math.ceil((taskInput.length + result.length) / 4),
+        },
+      });
+    } catch (error) {
+      res.status(500).json({ error: { message: error.message, type: "server_error" } });
+    }
+  }
+});
+
+/**
+ * GET /v1/models — list available models
+ */
+router.get("/models", (req, res) => {
+  res.json({
+    object: "list",
+    data: [
+      { id: "daemora", object: "model", owned_by: "daemora", created: Math.floor(Date.now() / 1000) },
+    ],
+  });
+});
+
+export default router;

package/src/channels/TelegramChannel.js

@@ -225,12 +225,15 @@ export class TelegramChannel extends BaseChannel {
       }
 
       const failed  = completedTask.status === "failed";
+      await this.sendReaction({ chatId, messageId }, failed ? "❌" : "✅");
+
+      // Skip text reply if agent already sent a file directly via replyWithFile
+      if (completedTask.directReplySent && !failed) return;
+
       const response = failed
         ? `Sorry, I encountered an error: ${completedTask.error}`
         : completedTask.result || "Done.";
 
-      await this.sendReaction({ chatId, messageId }, failed ? "❌" : "✅");
-
       const chunks = splitMessage(response, 4096);
       for (const chunk of chunks) {
         await ctx.reply(chunk).catch(() => {});

package/src/channels/index.js

@@ -1,7 +1,4 @@
-// HTTP channel is intentionally commented out - it has no authentication.
-// Anyone on the network could send arbitrary tasks to the agent.
-// Uncomment only if you've added your own auth middleware.
-// import { HttpChannel } from "./HttpChannel.js";
+import { HttpChannel } from "./HttpChannel.js";
 
 // ─── Core channels ─────────────────────────────────────────────────────────────
 import { TelegramChannel } from "./TelegramChannel.js";
@@ -42,10 +39,10 @@ class ChannelRegistry {
    * Initialize and start all enabled channels.
    */
   async startAll() {
-    // ─── HTTP channel disabled (no authentication) ────────────────────────────
-    // const http = new HttpChannel(config.channels.http);
-    // this.channels.set("http", http);
-    // await http.start();
+    // ─── HTTP channel (Securely handled by Express routes in index.js) ────────
+    const http = new HttpChannel(config.channels.http);
+    this.channels.set("http", http);
+    await http.start();
     // ─────────────────────────────────────────────────────────────────────────
 
     // ── Core channels ─────────────────────────────────────────────────────────
@@ -351,11 +348,11 @@ class ChannelRegistry {
     eventBus.on("task:reply:needed", async ({ task }) => {
       const channel = this.channels.get(task.channel);
       if (!channel?.running) {
-        console.log(`[ChannelRegistry] Cannot send recovered reply — channel "${task.channel}" not running`);
+        console.log(`[ChannelRegistry] Cannot send recovered reply \u2014 channel "${task.channel}" not running`);
         return;
       }
       try {
-        const reply = task.result || "(Task completed — no output)";
+        const reply = task.result || "(Task completed \u2014 no output)";
         await channel.sendReply(task.channelMeta, reply);
         console.log(`[ChannelRegistry] Recovered reply sent via ${task.channel} for task ${task.id}`);
       } catch (e) {