@makefinks/daemon 0.1.0

package/src/ai/tools/run-bash.ts

@@ -0,0 +1,224 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { spawn } from "node:child_process";
+import { getDaemonManager } from "../../state/daemon-state";
+
+const DEFAULT_TIMEOUT_MS = 30000; // 30 seconds
+const MAX_OUTPUT_LENGTH = 50000;
+
+const DANGEROUS_COMMANDS = [
+	"rm",
+	"rmdir",
+	"mv",
+	"kill",
+	"killall",
+	"pkill",
+	"shutdown",
+	"reboot",
+	"halt",
+	"poweroff",
+	"init",
+	"systemctl",
+	"chmod",
+	"chown",
+	"chgrp",
+	"mkfs",
+	"fdisk",
+	"dd",
+	"format",
+	"sudo",
+	"su",
+	"doas",
+	"passwd",
+	"useradd",
+	"userdel",
+	"usermod",
+	"groupadd",
+	"groupdel",
+	"visudo",
+	"crontab",
+	"iptables",
+	"ufw",
+	"firewall-cmd",
+	"mount",
+	"umount",
+	"fstab",
+	"apt-get remove",
+	"apt-get purge",
+	"apt remove",
+	"apt purge",
+	"yum remove",
+	"yum erase",
+	"dnf remove",
+	"pacman -R",
+	"brew uninstall",
+	"npm uninstall -g",
+	"pip uninstall",
+	"truncate",
+	"shred",
+	"wipefs",
+	">",
+	">>",
+	"git push --force",
+	"git push -f",
+	"git reset --hard",
+	"git clean -fd",
+	"docker rm",
+	"docker rmi",
+	"docker system prune",
+	"kubectl delete",
+	"terraform destroy",
+	"drop database",
+	"drop table",
+	"delete from",
+	"truncate table",
+];
+
+const DANGEROUS_PATTERNS = [
+	/\brm\s+(-[a-zA-Z]*r[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*|\s).*\//i,
+	/\brm\s+-rf?\s/i,
+	/\bkill\s+-9\b/i,
+	/\bsudo\s/i,
+	/\bsu\s+-?\s*$/i,
+	/\bchmod\s+[0-7]{3,4}\s/i,
+	/\bchown\s/i,
+	/\bdd\s+if=/i,
+	/>\s*\/dev\//i,
+	/\|.*\bsh\b/i,
+	/\|.*\bbash\b/i,
+	/curl.*\|\s*(ba)?sh/i,
+	/wget.*\|\s*(ba)?sh/i,
+	/eval\s*\$/i,
+	/\$\(.*\)/,
+	/`.*`/,
+];
+
+function isDangerousCommand(command: string): boolean {
+	const normalizedCmd = command.toLowerCase().trim();
+
+	for (const dangerous of DANGEROUS_COMMANDS) {
+		if (dangerous.includes(" ")) {
+			if (normalizedCmd.includes(dangerous.toLowerCase())) {
+				return true;
+			}
+		} else {
+			const wordBoundaryRegex = new RegExp(`\\b${dangerous}\\b`, "i");
+			if (wordBoundaryRegex.test(command)) {
+				return true;
+			}
+		}
+	}
+
+	for (const pattern of DANGEROUS_PATTERNS) {
+		if (pattern.test(command)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+export const runBash = tool({
+	description:
+		"Execute a bash command on the user's system. Use this to run shell commands, scripts, install packages, manage files, or perform any terminal operation. Commands run in the current working directory by default.",
+	inputSchema: z.object({
+		description: z
+			.string()
+			.describe(
+				"A brief description (5-10 words) of what this command does, so the user understands the purpose."
+			),
+		command: z
+			.string()
+			.describe("The bash command to execute. Can include pipes, redirects, and chained commands."),
+		workdir: z
+			.string()
+			.optional()
+			.describe("Working directory to run the command in. Defaults to current working directory."),
+		timeout: z
+			.number()
+			.optional()
+			.default(DEFAULT_TIMEOUT_MS)
+			.describe("Timeout in milliseconds. Defaults to 20 seconds."),
+	}),
+	needsApproval: async ({ command }) => {
+		const manager = getDaemonManager();
+		const approvalLevel = manager.bashApprovalLevel;
+
+		if (approvalLevel === "none") {
+			return false;
+		}
+
+		if (approvalLevel === "all") {
+			return true;
+		}
+
+		return isDangerousCommand(command);
+	},
+	execute: async ({ command, workdir, timeout }) => {
+		return new Promise((resolve) => {
+			const cwd = workdir || process.cwd();
+			let stdout = "";
+			let stderr = "";
+			let killed = false;
+
+			const proc = spawn("bash", ["-c", command], {
+				cwd,
+				env: process.env,
+				shell: false,
+			});
+
+			const timeoutId = setTimeout(() => {
+				killed = true;
+				proc.kill("SIGKILL");
+			}, timeout || DEFAULT_TIMEOUT_MS);
+
+			proc.stdout.on("data", (data: Buffer) => {
+				stdout += data.toString();
+			});
+
+			proc.stderr.on("data", (data: Buffer) => {
+				stderr += data.toString();
+			});
+
+			proc.on("close", (code) => {
+				clearTimeout(timeoutId);
+
+				// Truncate output if too long
+				if (stdout.length > MAX_OUTPUT_LENGTH) {
+					stdout = stdout.slice(0, MAX_OUTPUT_LENGTH) + "\n... [output truncated]";
+				}
+				if (stderr.length > MAX_OUTPUT_LENGTH) {
+					stderr = stderr.slice(0, MAX_OUTPUT_LENGTH) + "\n... [output truncated]";
+				}
+
+				if (killed) {
+					resolve({
+						success: false,
+						exitCode: null,
+						stdout: stdout.trim(),
+						stderr: stderr.trim(),
+						error: `Command timed out after ${timeout || DEFAULT_TIMEOUT_MS}ms`,
+					});
+				} else {
+					resolve({
+						success: code === 0,
+						exitCode: code,
+						stdout: stdout.trim(),
+						stderr: stderr.trim(),
+					});
+				}
+			});
+
+			proc.on("error", (error) => {
+				clearTimeout(timeoutId);
+				resolve({
+					success: false,
+					exitCode: null,
+					stdout: stdout.trim(),
+					stderr: stderr.trim(),
+					error: error instanceof Error ? error.message : String(error),
+				});
+			});
+		});
+	},
+});

package/src/ai/tools/subagents.ts

@@ -0,0 +1,195 @@
+/**
+ * Subagent tool for delegating tasks.
+ * DAEMON can call this tool multiple times in parallel to spawn concurrent subagents.
+ */
+
+import { tool } from "ai";
+import { z } from "zod";
+import { createOpenRouter } from "@openrouter/ai-sdk-provider";
+import { ToolLoopAgent, stepCountIs } from "ai";
+import { fetchUrls } from "./fetch-urls";
+import { renderUrl } from "./render-url";
+import { webSearch } from "./web-search";
+
+import { readFile } from "./read-file";
+import { runBash } from "./run-bash";
+import { todoManager } from "./todo-manager";
+import { buildOpenRouterChatSettings, getSubagentModel } from "../model-config";
+import { isWebSearchAvailable } from "./index";
+import type { ToolSet } from "ai";
+import type { SubagentProgressEmitter } from "../../types";
+import { detectLocalPlaywrightChromium } from "../../utils/js-rendering";
+import { getOpenRouterReportedCost } from "../../utils/openrouter-reported-cost";
+
+// OpenRouter client for subagents
+const openrouter = createOpenRouter();
+
+// Maximum steps for subagent loops
+const MAX_SUBAGENT_STEPS = 30;
+
+let cachedSubagentTools: Promise<ToolSet> | null = null;
+
+// Subagent tools (all tools except subagent itself to prevent recursion)
+async function getSubagentTools(): Promise<ToolSet> {
+	if (cachedSubagentTools) return cachedSubagentTools;
+
+	cachedSubagentTools = (async () => {
+		const tools: ToolSet = {
+			readFile,
+			runBash,
+			todoManager,
+		};
+
+		if (isWebSearchAvailable()) {
+			(tools as ToolSet & { webSearch: typeof webSearch }).webSearch = webSearch;
+			(tools as ToolSet & { fetchUrls: typeof fetchUrls }).fetchUrls = fetchUrls;
+		}
+
+		const jsRendering = await detectLocalPlaywrightChromium();
+		if (jsRendering.available) {
+			return { ...tools, renderUrl };
+		}
+
+		return tools;
+	})();
+
+	return cachedSubagentTools;
+}
+
+// System prompt for subagents
+function buildSubagentSystemPrompt(webSearchAvailable: boolean): string {
+	const disabledNotice = !webSearchAvailable
+		? "\nNOTICE: Web search and URL fetching are DISABLED because EXA_API_KEY is not configured.\n"
+		: "";
+
+	return `
+You are a focused subagent. You have been spawned to complete a specific task by a main agent.${disabledNotice}
+
+RULES:
+- Complete the assigned task thoroughly.
+- Use tools as needed to accomplish the task.
+- Do not ask clarifying questions - make reasonable assumptions.
+- Be direct and factual in your response.
+- If you cannot complete the task, explain why clearly.
+- Return a clear, detailed summary of what you found or accomplished.
+- The final summary needs to be self contained and needs to provide enough information to the main agent so it is clear what you have done and what the results are.
+
+Today's date: ${new Date().toISOString().split("T")[0]}
+`;
+}
+
+// Global emitter that will be set by the daemon-ai module
+let progressEmitter: SubagentProgressEmitter | null = null;
+
+/**
+ * Set the progress emitter for subagent updates.
+ * Called by daemon-ai when setting up the response generation.
+ */
+export function setSubagentProgressEmitter(emitter: SubagentProgressEmitter | null): void {
+	progressEmitter = emitter;
+}
+
+/**
+ * The subagent tool - spawns a single subagent to complete a task.
+ * DAEMON can call this multiple times in parallel for concurrent execution.
+ */
+export const subagent = tool({
+	description: `Spawn a subagent to complete a specific task. The subagent has access to available tools (bash, system info, etc.) except spawning more subagents.
+
+Call this tool multiple times in parallel to execute tasks concurrently.
+
+Use this when you need to:
+- Delegate a research or information-gathering task
+- Run an independent operation while continuing other work
+- Parallelize multiple lookups or checks
+
+Provide a concise summary for display and a very specific task description (especially for complex work).`,
+	inputSchema: z.object({
+		summary: z
+			.string()
+			.describe("A concise summary with a bit of detail (not just a title). Shown in the UI."),
+		task: z.string().describe("A specific, scoped description of what the subagent should accomplish."),
+	}),
+	execute: async ({ summary, task }, { toolCallId }) => {
+		try {
+			const tools = await getSubagentTools();
+			const webSearchAvailable = isWebSearchAvailable();
+
+			// Create ephemeral subagent
+			const subagent = new ToolLoopAgent({
+				model: openrouter.chat(getSubagentModel(), buildOpenRouterChatSettings()),
+				instructions: buildSubagentSystemPrompt(webSearchAvailable),
+				tools,
+				stopWhen: stepCountIs(MAX_SUBAGENT_STEPS),
+			});
+
+			let responseText = "";
+			let costTotal = 0;
+			let hasCost = false;
+
+			// Stream the subagent response to capture tool calls for UI
+			const stream = await subagent.stream({
+				messages: [{ role: "user" as const, content: task }],
+			});
+
+			for await (const part of stream.fullStream) {
+				if (part.type === "text-delta") {
+					responseText += part.text;
+				} else if (part.type === "finish-step") {
+					const reportedCost = getOpenRouterReportedCost(part.providerMetadata);
+					if (reportedCost !== undefined) {
+						costTotal += reportedCost;
+						hasCost = true;
+					}
+				} else if (part.type === "tool-call") {
+					// Emit tool call event for UI update
+					// Use setImmediate to yield to the event loop and allow React to re-render
+					setImmediate(() => {
+						progressEmitter?.onSubagentToolCall(toolCallId, part.toolName, part.input);
+					});
+				} else if (part.type === "tool-result") {
+					// Emit tool result event
+					const success =
+						typeof part.output === "object" && part.output !== null && "success" in part.output
+							? Boolean((part.output as { success?: unknown }).success)
+							: true;
+					setImmediate(() => {
+						progressEmitter?.onSubagentToolResult(toolCallId, part.toolName, success);
+					});
+				}
+			}
+
+			const streamUsage = await stream.usage;
+			if (streamUsage) {
+				progressEmitter?.onSubagentUsage({
+					promptTokens: streamUsage.inputTokens ?? 0,
+					completionTokens: streamUsage.outputTokens ?? 0,
+					totalTokens: streamUsage.totalTokens ?? 0,
+					reasoningTokens: streamUsage.outputTokenDetails?.reasoningTokens ?? 0,
+					cachedInputTokens: streamUsage.inputTokenDetails?.cacheReadTokens ?? 0,
+					cost: hasCost ? costTotal : undefined,
+				});
+			}
+
+			// Emit completion
+			progressEmitter?.onSubagentComplete(toolCallId, true);
+
+			return {
+				success: true,
+				summary,
+				response: responseText || "Task completed but no text response generated.",
+			};
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+
+			// Emit failure
+			progressEmitter?.onSubagentComplete(toolCallId, false);
+
+			return {
+				success: false,
+				summary,
+				response: `Error: ${errorMessage}`,
+			};
+		}
+	},
+});

package/src/ai/tools/todo-manager.ts

@@ -0,0 +1,150 @@
+import { tool } from "ai";
+import { z } from "zod";
+import type { TodoItem, TodoStatus } from "../../types";
+
+// Session-based todo storage
+const todoSessions = new Map<string, TodoItem[]>();
+
+// Default session for single-user mode
+const DEFAULT_SESSION = "default";
+
+function getTodos(sessionId: string = DEFAULT_SESSION): TodoItem[] {
+	if (!todoSessions.has(sessionId)) {
+		todoSessions.set(sessionId, []);
+	}
+	return todoSessions.get(sessionId)!;
+}
+
+function setTodos(sessionId: string, todos: TodoItem[]): void {
+	todoSessions.set(sessionId, todos);
+}
+
+function formatTodoList(todos: TodoItem[]): string {
+	if (todos.length === 0) {
+		return "No todos.";
+	}
+
+	const statusIcon: Record<TodoItem["status"], string> = {
+		pending: "[pending]",
+		in_progress: "[in_progress]",
+		completed: "[completed]",
+		cancelled: "[cancelled]",
+	};
+
+	const lines = todos.map((todo, index) => {
+		return `${index + 1}. ${statusIcon[todo.status]} ${todo.content}`;
+	});
+
+	return lines.join("\n");
+}
+
+// Schema for a single todo item in the write action
+const todoItemSchema = z.object({
+	content: z.string().describe("The todo item description"),
+	status: z
+		.enum(["pending", "in_progress", "completed", "cancelled"])
+		.default("pending")
+		.describe("Status of the todo"),
+});
+
+export const todoManager = tool({
+	description: `Manage a todo list to plan and track your actions.
+
+Actions:
+- write: Replace the entire todo list. Each item can have its own status, so you can write the full list AND set one task to in_progress in a single call.
+- update: Update a single todo's status by index (1-based)
+- list: Show current todos
+
+Example write with status:
+{ "action": "write", "todos": [{ "content": "First task", "status": "in_progress" }, { "content": "Second task", "status": "pending" }] }`,
+	inputSchema: z.object({
+		action: z.enum(["write", "update", "list"]).describe("The action to perform"),
+		todos: z.array(todoItemSchema).optional().describe("Array of todo items (required for 'write')"),
+		index: z.number().optional().describe("1-based index of the todo to update (required for 'update')"),
+		status: z
+			.enum(["pending", "in_progress", "completed", "cancelled"])
+			.optional()
+			.describe("New status for the todo (used with 'update')"),
+		sessionId: z.string().optional().describe("Session ID for isolation. Defaults to 'default'."),
+	}),
+	execute: async ({ action, todos: newTodos, index, status, sessionId }) => {
+		const session = sessionId || DEFAULT_SESSION;
+
+		switch (action) {
+			case "write": {
+				if (!newTodos || newTodos.length === 0) {
+					setTodos(session, []);
+					return {
+						success: true,
+						message: "Cleared all todos",
+						list: "No todos.",
+					};
+				}
+				const items: TodoItem[] = newTodos.map((t) => ({
+					content: t.content,
+					status: t.status || "pending",
+				}));
+				setTodos(session, items);
+				return {
+					success: true,
+					message: `Set ${items.length} todos`,
+					list: formatTodoList(items),
+				};
+			}
+
+			case "update": {
+				if (index === undefined) {
+					return {
+						success: false,
+						error: "Index is required for 'update'",
+					};
+				}
+				const todos = getTodos(session);
+				const idx = index - 1; // Convert to 0-based
+				if (idx < 0 || idx >= todos.length) {
+					return {
+						success: false,
+						error: `Invalid index ${index}. Valid range: 1-${todos.length}`,
+					};
+				}
+				const todo = todos[idx]!;
+				if (status) {
+					todo.status = status;
+				}
+				return {
+					success: true,
+					message: `Updated #${index}: ${todo.content} -> ${todo.status}`,
+					list: formatTodoList(todos),
+				};
+			}
+
+			case "list": {
+				const todos = getTodos(session);
+				return {
+					success: true,
+					count: todos.length,
+					pending: todos.filter((t) => t.status === "pending").length,
+					inProgress: todos.filter((t) => t.status === "in_progress").length,
+					completed: todos.filter((t) => t.status === "completed").length,
+					list: formatTodoList(todos),
+				};
+			}
+
+			default:
+				return {
+					success: false,
+					error: `Unknown action: ${action}`,
+				};
+		}
+	},
+});
+
+// Export a function to clear all sessions (useful for testing)
+export function clearAllTodoSessions(): void {
+	todoSessions.clear();
+}
+
+// Export function to get current todos for UI display
+export function getCurrentTodos(sessionId: string = DEFAULT_SESSION): TodoItem[] {
+	return [...getTodos(sessionId)];
+}

package/src/ai/tools/web-search.ts

@@ -0,0 +1,91 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { getExaClient } from "../exa-client";
+
+const RecencyEnum = z.enum(["day", "week", "month", "year"]);
+
+function recencyToStartDate(recency: z.infer<typeof RecencyEnum>): string {
+	const now = new Date();
+	switch (recency) {
+		case "day":
+			now.setDate(now.getDate() - 1);
+			break;
+		case "week":
+			now.setDate(now.getDate() - 7);
+			break;
+		case "month":
+			now.setMonth(now.getMonth() - 1);
+			break;
+		case "year":
+			now.setFullYear(now.getFullYear() - 1);
+			break;
+	}
+	return now.toISOString();
+}
+
+export const webSearch = tool({
+	description:
+		"Searches the web for information. Returns metadata (title, URL, published date) for relevant web pages. Use this to discover URLs, then use fetchUrls to read contents.",
+	inputSchema: z.object({
+		query: z.string().describe("The search query to find relevant web pages for."),
+		numResults: z
+			.number()
+			.min(1)
+			.max(20)
+			.default(10)
+			.describe("Number of results to return. Defaults to 10, max 20."),
+		recency: RecencyEnum.optional().describe(
+			"Filter to recent results: 'day', 'week', 'month', or 'year'. Omit for all time."
+		),
+		includeDomains: z
+			.array(z.string())
+			.optional()
+			.describe("Limit search to specific domains (e.g., ['arxiv.org', 'github.com'])."),
+	}),
+	execute: async ({ query, numResults, recency, includeDomains }) => {
+		const exaClientResult = getExaClient();
+		if ("error" in exaClientResult) {
+			return { success: false, error: exaClientResult.error };
+		}
+
+		try {
+			const searchOptions: Record<string, unknown> = {
+				numResults,
+				type: "auto",
+			};
+
+			if (recency) {
+				searchOptions.startPublishedDate = recencyToStartDate(recency);
+			}
+
+			if (includeDomains && includeDomains.length > 0) {
+				searchOptions.includeDomains = includeDomains;
+			}
+
+			const rawData = (await exaClientResult.client.search(query, searchOptions)) as unknown as {
+				results: Array<{ title?: string; url?: string; publishedDate?: string; [key: string]: unknown }>;
+			};
+
+			const results = (rawData.results ?? []).map((r) => {
+				const result: { title?: string; url?: string; publishedDate?: string } = {};
+				if (typeof r.title === "string") result.title = r.title;
+				if (typeof r.url === "string") result.url = r.url;
+				if (typeof r.publishedDate === "string") {
+					result.publishedDate = r.publishedDate;
+				}
+				return result;
+			});
+
+			return {
+				success: true,
+				data: { results },
+			};
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			return {
+				success: false,
+				error: err.message,
+			};
+		}
+	},
+});