claudeck 1.0.0

package/server/agent-loop.js

@@ -0,0 +1,385 @@
+import { query } from "@anthropic-ai/claude-code";
+import { execPath } from "process";
+import { existsSync } from "fs";
+import { homedir } from "os";
+
+// Map short model names to current model IDs
+const MODEL_MAP = {
+  haiku: "claude-haiku-4-5-20251001",
+  sonnet: "claude-sonnet-4-6",
+  opus: "claude-opus-4-6",
+};
+function resolveModel(name) {
+  if (!name) return undefined;
+  return MODEL_MAP[name] || name;
+}
+import {
+  createSession,
+  updateClaudeSessionId,
+  getSession,
+  touchSession,
+  addCost,
+  addMessage,
+  getTotalCost,
+  setClaudeSession,
+  updateSessionTitle,
+  setAgentContext,
+  getAllAgentContext,
+  recordAgentRunStart,
+  recordAgentRunComplete,
+} from "../db.js";
+import { getProjectSystemPrompt } from "./routes/projects.js";
+import { sendPushNotification } from "./push-sender.js";
+import { sendTelegramNotification } from "./telegram-sender.js";
+
+/**
+ * Build the agent system prompt that instructs Claude to work autonomously
+ * toward the given goal.
+ */
+function buildAgentPrompt(agentDef, userContext, sharedContext) {
+  let prompt = `You are an autonomous AI agent. Work toward the following goal step by step, using any tools available to you.\n\n`;
+  prompt += `## Goal\n${agentDef.goal}\n\n`;
+  if (userContext) {
+    prompt += `## Additional Context from User\n${userContext}\n\n`;
+  }
+  if (sharedContext && sharedContext.length > 0) {
+    prompt += `## Context from Previous Agents\n`;
+    prompt += `The following is output from agents that ran before you in this chain. Use this context to inform your work.\n\n`;
+    for (const ctx of sharedContext) {
+      prompt += `### From: ${ctx.agent_id}\n${ctx.value}\n\n`;
+    }
+  }
+  prompt += `## Instructions\n`;
+  prompt += `- Break the goal into logical steps and execute them one by one.\n`;
+  prompt += `- Use tools (read files, search, write, run commands) as needed.\n`;
+  prompt += `- After completing all steps, provide a clear final summary of what you accomplished.\n`;
+  prompt += `- If you encounter a blocker you cannot resolve, explain it clearly and stop.\n`;
+  return prompt;
+}
+
+/**
+ * Run an autonomous agent.
+ * This uses a single SDK query() call with high maxTurns so Claude
+ * autonomously decides what tools to use and when to stop.
+ */
+export async function runAgent({
+  ws,
+  agentDef,
+  cwd,
+  sessionId: clientSid,
+  projectName,
+  permissionMode,
+  model,
+  sessionIds,
+  pendingApprovals,
+  makeCanUseTool,
+  userContext,
+  activeQueries,
+  chainResumeId,
+  runId,
+  runType,
+  parentRunId,
+}) {
+  const agentId = agentDef.id;
+  const maxTurns = agentDef.constraints?.maxTurns || 50;
+  const timeoutMs = agentDef.constraints?.timeoutMs || 300000;
+
+  // Record run start for monitoring dashboard
+  const monitorRunId = runId || `single-${Date.now()}`;
+  const effectiveRunType = runType || 'single';
+  try {
+    recordAgentRunStart(monitorRunId, agentId, agentDef.title, effectiveRunType, parentRunId);
+  } catch (e) { /* ignore duplicates */ }
+
+  function agentSend(payload) {
+    if (ws.readyState !== 1) return;
+    ws.send(JSON.stringify(payload));
+  }
+
+  // Notify client that agent has started
+  agentSend({
+    type: "agent_started",
+    agentId,
+    title: agentDef.title,
+    goal: agentDef.goal,
+    maxTurns,
+  });
+
+  const abortController = new AbortController();
+  const queryKey = `agent-${agentId}-${Date.now()}`;
+  if (activeQueries) {
+    activeQueries.set(queryKey, { abort: () => abortController.abort() });
+  }
+
+  // Set up timeout
+  const timeoutHandle = setTimeout(() => {
+    abortController.abort();
+    agentSend({ type: "agent_error", error: "Agent reached time limit", agentId });
+  }, timeoutMs);
+
+  const effectivePermMode = permissionMode || "bypass";
+  const useBypass = effectivePermMode === "bypass";
+  const usePlan = effectivePermMode === "plan";
+  const resolvedCwd = (cwd && existsSync(cwd)) ? cwd : homedir();
+
+  const opts = {
+    cwd: resolvedCwd,
+    permissionMode: usePlan ? "plan" : (useBypass ? "bypassPermissions" : "default"),
+    abortController,
+    maxTurns,
+    executable: execPath,
+  };
+
+  if (!useBypass && !usePlan) {
+    opts.canUseTool = makeCanUseTool(ws, pendingApprovals, effectivePermMode, null, agentDef.title || "Agent");
+  }
+  if (model) opts.model = resolveModel(model);
+
+  const projectPrompt = getProjectSystemPrompt(cwd);
+  if (projectPrompt) opts.appendSystemPrompt = projectPrompt;
+
+  // Resume existing session — explicit chainResumeId takes priority
+  const resumeId = chainResumeId || (clientSid ? sessionIds.get(clientSid) : undefined);
+  if (resumeId) opts.resume = resumeId;
+
+  // Load shared context from previous agents in this run
+  const sharedContext = runId ? getAllAgentContext(runId) : [];
+  const prompt = buildAgentPrompt(agentDef, userContext, sharedContext);
+  let resolvedSid = clientSid;
+  let claudeSessionId = null;
+  let sessionModel = null;
+  let turnCount = 0;
+  let lastAssistantText = "";
+  let lastAgentMetrics = {};
+
+  try {
+    const q = query({ prompt, options: opts });
+
+    for await (const sdkMsg of q) {
+      if (ws.readyState !== 1) break;
+
+      // Init message — session setup
+      if (sdkMsg.type === "system" && sdkMsg.subtype === "init") {
+        claudeSessionId = sdkMsg.session_id;
+        if (sdkMsg.model) sessionModel = sdkMsg.model;
+        const ourSid = clientSid || crypto.randomUUID();
+        resolvedSid = ourSid;
+
+        sessionIds.set(ourSid, claudeSessionId);
+
+        if (!getSession(ourSid)) {
+          createSession(ourSid, claudeSessionId, projectName || "Agent Session", cwd || "");
+          updateSessionTitle(ourSid, `Agent: ${agentDef.title}`);
+        } else {
+          updateClaudeSessionId(ourSid, claudeSessionId);
+        }
+
+        agentSend({ type: "session", sessionId: ourSid });
+        addMessage(resolvedSid, "user", JSON.stringify({ text: `[Agent: ${agentDef.title}] ${agentDef.goal}` }), null);
+        continue;
+      }
+
+      // Assistant message — text and tool_use blocks
+      if (sdkMsg.type === "assistant" && sdkMsg.message?.content) {
+        for (const block of sdkMsg.message.content) {
+          if (block.type === "text" && block.text) {
+            lastAssistantText = block.text;
+            agentSend({ type: "text", text: block.text });
+            if (resolvedSid) {
+              addMessage(resolvedSid, "assistant", JSON.stringify({ text: block.text }), null);
+            }
+          } else if (block.type === "tool_use") {
+            turnCount++;
+            agentSend({ type: "tool", id: block.id, name: block.name, input: block.input });
+            agentSend({
+              type: "agent_progress",
+              agentId,
+              turn: turnCount,
+              maxTurns,
+              action: block.name,
+              detail: typeof block.input === "object"
+                ? (block.input.command || block.input.pattern || block.input.file_path || block.input.query || "").slice(0, 120)
+                : "",
+            });
+            if (resolvedSid) {
+              addMessage(resolvedSid, "tool", JSON.stringify({ id: block.id, name: block.name, input: block.input }), null);
+            }
+          }
+        }
+        continue;
+      }
+
+      // Tool results
+      if (sdkMsg.type === "user" && sdkMsg.message?.content) {
+        const blocks = Array.isArray(sdkMsg.message.content) ? sdkMsg.message.content : [];
+        for (const block of blocks) {
+          if (block.type === "tool_result") {
+            const text = Array.isArray(block.content)
+              ? block.content.map(c => c.type === "text" ? c.text : "").join("")
+              : typeof block.content === "string" ? block.content : "";
+            agentSend({
+              type: "tool_result",
+              toolUseId: block.tool_use_id,
+              content: text.slice(0, 2000),
+              isError: block.is_error || false,
+            });
+            if (resolvedSid) {
+              addMessage(resolvedSid, "tool_result", JSON.stringify({
+                toolUseId: block.tool_use_id,
+                content: text.slice(0, 10000),
+                isError: block.is_error || false,
+              }), null);
+            }
+          }
+        }
+        continue;
+      }
+
+      // Result message
+      if (sdkMsg.type === "result") {
+        if (sdkMsg.subtype === "success" || sdkMsg.subtype === "error_max_turns") {
+          const costUsd = sdkMsg.total_cost_usd || 0;
+          const durationMs = sdkMsg.duration_ms || 0;
+          const numTurns = sdkMsg.num_turns || 0;
+          const inputTokens = sdkMsg.usage?.input_tokens || 0;
+          const outputTokens = sdkMsg.usage?.output_tokens || 0;
+          const cacheReadTokens = sdkMsg.usage?.cache_read_input_tokens || 0;
+          const cacheCreationTokens = sdkMsg.usage?.cache_creation_input_tokens || 0;
+          const resultModel = Object.keys(sdkMsg.modelUsage || {})[0] || sessionModel;
+
+          if (resolvedSid) {
+            addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
+              model: resultModel,
+              stopReason: sdkMsg.subtype,
+              isError: 0,
+              cacheReadTokens,
+              cacheCreationTokens,
+            });
+          }
+
+          agentSend({
+            type: "result",
+            duration_ms: durationMs,
+            num_turns: numTurns,
+            cost_usd: costUsd,
+            totalCost: getTotalCost(),
+            input_tokens: inputTokens,
+            output_tokens: outputTokens,
+            cache_read_tokens: cacheReadTokens,
+            cache_creation_tokens: cacheCreationTokens,
+            model: resultModel,
+            stop_reason: sdkMsg.subtype,
+          });
+
+          lastAgentMetrics = { durationMs, costUsd, inputTokens, outputTokens, model: resultModel, turns: numTurns, isError: false };
+
+          agentSend({
+            type: "agent_completed",
+            agentId,
+            totalTurns: numTurns,
+            durationMs,
+            costUsd,
+          });
+
+          // Record completion for monitoring
+          try {
+            recordAgentRunComplete(monitorRunId, agentId, 'completed', numTurns, costUsd, durationMs, inputTokens, outputTokens);
+          } catch (e) { /* ignore */ }
+
+          // Store agent output as shared context for downstream agents
+          if (runId && lastAssistantText) {
+            const summary = lastAssistantText.length > 4000
+              ? lastAssistantText.slice(0, 4000) + "\n\n[truncated]"
+              : lastAssistantText;
+            setAgentContext(runId, agentId, "output", summary);
+          }
+        } else if (sdkMsg.subtype?.startsWith("error")) {
+          const errMsg = sdkMsg.errors?.join(", ") || "Unknown error";
+          const costUsd = sdkMsg.total_cost_usd || 0;
+          const durationMs = sdkMsg.duration_ms || 0;
+          const numTurns = sdkMsg.num_turns || 0;
+          const inputTokens = sdkMsg.usage?.input_tokens || 0;
+          const outputTokens = sdkMsg.usage?.output_tokens || 0;
+          const cacheReadTokens = sdkMsg.usage?.cache_read_input_tokens || 0;
+          const cacheCreationTokens = sdkMsg.usage?.cache_creation_input_tokens || 0;
+          const resultModel = Object.keys(sdkMsg.modelUsage || {})[0] || sessionModel;
+
+          if (resolvedSid) {
+            addCost(resolvedSid, costUsd, durationMs, numTurns, inputTokens, outputTokens, {
+              model: resultModel,
+              stopReason: sdkMsg.subtype,
+              isError: 1,
+              cacheReadTokens,
+              cacheCreationTokens,
+            });
+            addMessage(resolvedSid, "error", JSON.stringify({ error: errMsg, subtype: sdkMsg.subtype }), null);
+          }
+
+          lastAgentMetrics = { durationMs, costUsd, inputTokens, outputTokens, model: resultModel, turns: numTurns, isError: true, error: errMsg };
+          agentSend({ type: "error", error: errMsg });
+          agentSend({ type: "agent_error", agentId, error: errMsg, turn: turnCount });
+
+          // Record error for monitoring
+          try {
+            recordAgentRunComplete(monitorRunId, agentId, 'error', numTurns, costUsd, durationMs, inputTokens, outputTokens, errMsg);
+          } catch (e) { /* ignore */ }
+        }
+        continue;
+      }
+    }
+  } catch (err) {
+    if (err.name === "AbortError") {
+      agentSend({ type: "agent_aborted", agentId, turn: turnCount });
+      agentSend({ type: "aborted" });
+      try { recordAgentRunComplete(monitorRunId, agentId, 'aborted', turnCount, 0, 0, 0, 0, 'Aborted'); } catch (e) { /* ignore */ }
+    } else {
+      agentSend({ type: "agent_error", agentId, error: err.message, turn: turnCount });
+      agentSend({ type: "error", error: err.message });
+      try { recordAgentRunComplete(monitorRunId, agentId, 'error', turnCount, 0, 0, 0, 0, err.message); } catch (e) { /* ignore */ }
+    }
+    throw err; // Re-throw so callers (chains, DAGs) know the agent failed
+  } finally {
+    clearTimeout(timeoutHandle);
+    if (activeQueries) activeQueries.delete(queryKey);
+    agentSend({ type: "done" });
+    sendPushNotification("Claudeck", `Agent "${agentDef.title}" completed`, `agent-${resolvedSid}`);
+
+    // Rich Telegram notification — meaningful for AFK developer
+    const goalSnippet = agentDef.goal ? agentDef.goal.slice(0, 150).split("\n")[0] : "";
+    const outputSnippet = lastAssistantText
+      ? lastAssistantText.slice(0, 300).replace(/\n{2,}/g, "\n")
+      : "";
+
+    if (lastAgentMetrics.isError) {
+      const errorBody = [
+        agentDef.title,
+        goalSnippet ? `Goal: ${goalSnippet}` : "",
+        `Error: ${lastAgentMetrics.error || "Unknown error"}`,
+      ].filter(Boolean).join("\n");
+      sendTelegramNotification("error", "Agent Failed", errorBody, {
+        durationMs: lastAgentMetrics.durationMs,
+        costUsd: lastAgentMetrics.costUsd,
+        inputTokens: lastAgentMetrics.inputTokens,
+        outputTokens: lastAgentMetrics.outputTokens,
+        model: lastAgentMetrics.model,
+        turns: lastAgentMetrics.turns,
+      });
+    } else {
+      const body = [
+        agentDef.title,
+        goalSnippet ? `Goal: ${goalSnippet}` : "",
+        outputSnippet ? `\nResult: ${outputSnippet}` : "",
+      ].filter(Boolean).join("\n");
+      sendTelegramNotification("agent", "Agent Completed", body, {
+        durationMs: lastAgentMetrics.durationMs,
+        costUsd: lastAgentMetrics.costUsd,
+        inputTokens: lastAgentMetrics.inputTokens,
+        outputTokens: lastAgentMetrics.outputTokens,
+        model: lastAgentMetrics.model,
+        turns: lastAgentMetrics.turns,
+      });
+    }
+  }
+
+  return { resolvedSid, claudeSessionId };
+}

package/server/dag-executor.js

@@ -0,0 +1,265 @@
+/**
+ * DAG Executor — runs agents in dependency order with parallelism.
+ *
+ * Topologically sorts nodes, groups by level, and runs each level
+ * with Promise.all (max 3 concurrent agents). Shared context flows
+ * from completed nodes to dependents via the agent_context table.
+ */
+
+import { runAgent } from "./agent-loop.js";
+import { sendPushNotification } from "./push-sender.js";
+import { sendTelegramNotification } from "./telegram-sender.js";
+
+const MAX_CONCURRENT = 3;
+
+/**
+ * Topological sort — returns array of arrays (levels).
+ * Each level contains nodes whose dependencies are all in earlier levels.
+ */
+function topologicalLevels(nodes, edges) {
+  const inDegree = new Map();
+  const adj = new Map();
+  for (const n of nodes) {
+    inDegree.set(n.id, 0);
+    adj.set(n.id, []);
+  }
+  for (const e of edges) {
+    adj.get(e.from)?.push(e.to);
+    inDegree.set(e.to, (inDegree.get(e.to) || 0) + 1);
+  }
+
+  const levels = [];
+  const remaining = new Set(nodes.map((n) => n.id));
+
+  while (remaining.size > 0) {
+    const level = [];
+    for (const id of remaining) {
+      if (inDegree.get(id) === 0) level.push(id);
+    }
+    if (level.length === 0) {
+      // Cycle detected — break to avoid infinite loop
+      break;
+    }
+    levels.push(level);
+    for (const id of level) {
+      remaining.delete(id);
+      for (const next of adj.get(id) || []) {
+        inDegree.set(next, (inDegree.get(next) || 0) - 1);
+      }
+    }
+  }
+
+  return levels;
+}
+
+/**
+ * Run agents in batches with a concurrency limit.
+ */
+async function runBatch(tasks, limit) {
+  const results = [];
+  for (let i = 0; i < tasks.length; i += limit) {
+    const batch = tasks.slice(i, i + limit);
+    const batchResults = await Promise.allSettled(batch.map((fn) => fn()));
+    results.push(...batchResults);
+  }
+  return results;
+}
+
+export async function runDag({
+  ws,
+  dag,
+  agents,
+  cwd,
+  sessionId: clientSid,
+  projectName,
+  permissionMode,
+  model,
+  sessionIds,
+  pendingApprovals,
+  makeCanUseTool,
+  activeQueries,
+}) {
+  const runId = crypto.randomUUID();
+
+  function dagSend(payload) {
+    if (ws.readyState !== 1) return;
+    ws.send(JSON.stringify(payload));
+  }
+
+  const levels = topologicalLevels(dag.nodes, dag.edges);
+  const nodeMap = new Map(dag.nodes.map((n) => [n.id, n]));
+
+  dagSend({
+    type: "dag_started",
+    dagId: dag.id,
+    runId,
+    title: dag.title,
+    nodes: dag.nodes.map((n) => ({
+      id: n.id,
+      agentId: n.agentId,
+      title: agents.find((a) => a.id === n.agentId)?.title || n.agentId,
+    })),
+    edges: dag.edges,
+    levels: levels.map((l) => [...l]),
+    totalNodes: dag.nodes.length,
+  });
+
+  // Telegram start notification
+  const nodeNames = dag.nodes.map((n) => {
+    const title = agents.find((a) => a.id === n.agentId)?.title || n.agentId;
+    return `  \u{2022} ${title}`;
+  }).join("\n");
+  sendTelegramNotification("start", "DAG Started", `${dag.title}\n\n${dag.nodes.length} nodes:\n${nodeNames}`);
+
+  let resolvedSid = clientSid;
+  const failedNodes = new Set();
+  let aborted = false;
+  // Track which nodes have dependents that failed
+  const edgeMap = new Map();
+  for (const e of dag.edges) {
+    if (!edgeMap.has(e.to)) edgeMap.set(e.to, []);
+    edgeMap.get(e.to).push(e.from);
+  }
+
+  for (let li = 0; li < levels.length; li++) {
+    const level = levels[li];
+    if (ws.readyState !== 1 || aborted) break;
+
+    dagSend({
+      type: "dag_level",
+      dagId: dag.id,
+      levelIndex: li,
+      nodeIds: level,
+      status: "running",
+    });
+
+    const tasks = level.map((nodeId) => {
+      return async () => {
+        const node = nodeMap.get(nodeId);
+        if (!node) return;
+
+        // Check if any dependency failed
+        const deps = edgeMap.get(nodeId) || [];
+        const failedDep = deps.find((d) => failedNodes.has(d));
+        if (failedDep) {
+          failedNodes.add(nodeId);
+          dagSend({
+            type: "dag_node",
+            dagId: dag.id,
+            nodeId,
+            agentId: node.agentId,
+            status: "skipped",
+            reason: `Dependency "${failedDep}" failed`,
+          });
+          return;
+        }
+
+        const agentDef = agents.find((a) => a.id === node.agentId);
+        if (!agentDef) {
+          failedNodes.add(nodeId);
+          dagSend({
+            type: "dag_node",
+            dagId: dag.id,
+            nodeId,
+            agentId: node.agentId,
+            status: "skipped",
+            reason: "Agent not found",
+          });
+          return;
+        }
+
+        dagSend({
+          type: "dag_node",
+          dagId: dag.id,
+          nodeId,
+          agentId: agentDef.id,
+          agentTitle: agentDef.title,
+          status: "running",
+        });
+
+        try {
+          const result = await runAgent({
+            ws,
+            agentDef,
+            cwd,
+            sessionId: resolvedSid,
+            projectName: projectName || `DAG: ${dag.title}`,
+            permissionMode,
+            model,
+            sessionIds,
+            pendingApprovals,
+            makeCanUseTool,
+            activeQueries,
+            runId,
+            runType: 'dag',
+            parentRunId: dag.id,
+          });
+
+          if (result?.resolvedSid) resolvedSid = result.resolvedSid;
+
+          dagSend({
+            type: "dag_node",
+            dagId: dag.id,
+            nodeId,
+            agentId: agentDef.id,
+            agentTitle: agentDef.title,
+            status: "completed",
+          });
+        } catch (err) {
+          failedNodes.add(nodeId);
+          if (err.name === "AbortError") aborted = true;
+          dagSend({
+            type: "dag_node",
+            dagId: dag.id,
+            nodeId,
+            agentId: agentDef.id,
+            agentTitle: agentDef.title,
+            status: err.name === "AbortError" ? "aborted" : "error",
+            error: err.message,
+          });
+        }
+      };
+    });
+
+    await runBatch(tasks, MAX_CONCURRENT);
+
+    dagSend({
+      type: "dag_level",
+      dagId: dag.id,
+      levelIndex: li,
+      nodeIds: level,
+      status: "completed",
+    });
+  }
+
+  dagSend({
+    type: "dag_completed",
+    dagId: dag.id,
+    runId,
+    totalNodes: dag.nodes.length,
+    succeeded: dag.nodes.length - failedNodes.size,
+    failed: failedNodes.size,
+  });
+
+  sendPushNotification(
+    "Claudeck",
+    `DAG "${dag.title}" completed`,
+    `dag-${resolvedSid}`,
+  );
+  const nodeStatus = dag.nodes.map((n) => {
+    const title = agents.find((a) => a.id === n.agentId)?.title || n.agentId;
+    const icon = failedNodes.has(n.id) ? "\u{274C}" : "\u{2705}";
+    return `  ${icon} ${title}`;
+  }).join("\n");
+  const dagEventType = failedNodes.size > 0 ? "error" : "dag";
+  const dagLabel = failedNodes.size > 0 ? "DAG Completed with Failures" : "DAG Completed";
+  sendTelegramNotification(
+    dagEventType,
+    dagLabel,
+    `${dag.title}\n\n${nodeStatus}`,
+    {
+      succeeded: dag.nodes.length - failedNodes.size,
+      failed: failedNodes.size,
+    },
+  );
+}