@makefinks/daemon 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 makefinks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# DAEMON
+**DAEMON** (pronounced "day-mon") is an opinionated **terminal-based AI agent** with distinct sci-fi theming,
+delivered through a well-thought-out TUI powered by [OpenTUI](https://github.com/anomalyco/opentui).
+It supports **text and voice interaction** and can be fully controlled through **hotkeys**.
+
+DAEMON is focused on **information-gathering workflows** that benefit from **grounded responses**
+but can also interact with and **control** your system through the terminal with scoped permissions.
+
+![DAEMON terminal avatar](img/daemon.gif)
+
+## Highlights
+
+### 👤 Interactive Avatar
+At the core of the TUI is DAEMON's **animated avatar**, reacting to what it's doing in real time:
+listening to audio input, reasoning about questions, calling tools, and generating an answer.
+
+The avatar was deliberately designed to feel slightly ominous and alien-like playing into
+
+### 🧠 LLMs
+DAEMON can be powered by **any** model available on [OpenRouter](https://openrouter.ai/models).
+The TUI includes a model picker that can fetch and select models as they become available on OpenRouter.
+Models are sorted by average provider pricing and the picker includes information about their context window and caching support.
+Once a model is selected, the **selection of the inference provider** is possible. Open-source models can vary strongly between providers.
+> While all models on OpenRouter are supported, a curated list is included for the best experience.
+It is generally recommended to use Models that support caching due to being significantly cheaper in DAEMON
+
+![Model Picker](img/model-picker.png)
+
+
+### 🎙️ Voice capabilities
+SOTA transcription accuracy is achieved by using OpenAI's latest transcription model `gpt-4o-mini-transcribe-2025-03-20`.
+It features a large vocabulary and can transcribe multilingual inputs with complex terminology.
+
+OpenAI's TTS model `gpt-4o-mini-tts-2025-03-20` is used to generate voice output with as little latency as possible.
+
+### 🔎 Web Search
+DAEMON uses the [Exa](https://exa.ai/) search and fetch API for retrieving accurate and up-to-date information.
+
+### 💾 Session Persistence
+DAEMON stores chat sessions locally (SQLite) and lets you resume past conversations.
+
+## ✨ Feature List
+
+| Feature | Description |
+| --- | --- |
+| Terminal TUI | OpenTUI-powered interface with sci-fi styling and hotkey controls. |
+| Text + Voice | Supports text input and voice interaction with transcription and TTS. |
+| Animated Avatar | Sci-fi avatar reacts to listening, tool use, and response generation. |
+| Multi-Model Support | Works with all OpenRouter models and includes a curated default list. |
+| Session Persistence | Preferences and chat sessions stored locally on disk. |
+| Workspaces | On-disk workspaces for the agent to work in. |
+| Web Search | Exa-based search and fetch for grounded, up-to-date info. |
+| Grounding | Text-fragment grounding with a dedicated UI. |
+| Bash Execution | Bash integration with approval scoping for potentially dangerous commands. |
+| JS Page Rendering | Optional Playwright renderer for SPA content. |
+
+## 📦 Install (npm/bun)
+
+DAEMON is published as a CLI package. It **requires Bun** at runtime, even if you install via npm.
+
+To install bun on macOs/Linux
+```bash
+curl -fsSL https://bun.com/install | bash
+```
+Then install DAEMON:
+```bash
+# Global npm install
+npm i -g @makefinks/daemon
+# or via bun
+bun add -g @makefinks/daemon
+
+# Then run
+daemon
+```
+
+Configuration is done via environment variables (or the onboarding UI):
+
+- `OPENROUTER_API_KEY` (required) - response generation via OpenRouter models
+- `EXA_API_KEY` (optional) - enables web search + fetch grounding via Exa
+- `OPENAI_API_KEY` (optional) - enables voice transcription + TTS
+
+> Keys entered via the onboarding UI are stored locally in `~/.config/daemon/credentials.json` with restricted permissions (`0600`). For maximum security, use environment variables instead.
+
+## 🛠️ System dependencies
+
+Voice input requires `sox` and platform-specific audio libraries:
+
+### macOS
+```bash
+brew install sox
+```
+
+### Linux (Debian/Ubuntu)
+```bash
+sudo apt install sox libsox-fmt-pulse
+```
+
+### Linux (Fedora)
+```bash
+sudo dnf install sox sox-plugins-freeworld
+```
+
+### Linux (Arch)
+```bash
+sudo pacman -S sox
+```
+
+## 🧩 Optional: JS-rendered page support (`renderUrl`)
+
+DAEMON defaults to Exa-based `fetchUrls` for retrieving web page text. For JavaScript-heavy sites (SPAs) where `fetchUrls` returns "shell-only" content, DAEMON can optionally use a local Playwright Chromium renderer via the `renderUrl` tool.
+
+This feature is **optional** and intentionally not installed by default (browser downloads are large). The render tool is not available to DAEMON without the installation below.
+
+### For global installs (`npm i -g` / `bun add -g`)
+
+Playwright must also be installed globally:
+
+```bash
+# 1) Install Playwright globally
+npm i -g playwright
+# or
+bun add -g playwright
+
+# 2) Install Chromium browser binaries
+npx playwright install chromium
+```

package/dist/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+var args = process.argv.slice(2);
+var bunCmd = process.platform === "win32" ? "bun.exe" : "bun";
+var bunCheck = spawnSync(bunCmd, ["--version"], { stdio: "ignore" });
+if (bunCheck.error || bunCheck.status !== 0) {
+  console.error("DAEMON requires Bun. Install it from https://bun.sh and try again.");
+  process.exit(1);
+}
+var packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+var entry = path.join(packageRoot, "src", "index.tsx");
+var result = spawnSync(bunCmd, [entry, ...args], { stdio: "inherit" });
+if (result.error) {
+  const error = result.error instanceof Error ? result.error : new Error(String(result.error));
+  console.error(error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 0);

package/package.json

@@ -0,0 +1,79 @@
+{
+	"name": "@makefinks/daemon",
+	"description": "Terminal-first AI agent with an interactive avatar, vim-style controls, and advanced voice capabilities.",
+	"author": "makefinks",
+	"license": "MIT",
+	"keywords": [
+		"agent",
+		"llm-agent",
+		"terminal-ui",
+		"tui",
+		"cli",
+		"ai",
+		"terminal",
+		"llm",
+		"daemon",
+		"makefinks",
+		"openrouter",
+		"bun",
+		"voice",
+		"ai-assistant"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/makefinks/daemon.git"
+	},
+	"bugs": {
+		"url": "https://github.com/makefinks/daemon/issues"
+	},
+	"module": "src/index.tsx",
+	"type": "module",
+	"version": "0.1.0",
+	"bin": {
+		"daemon": "dist/cli.js"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"files": ["dist", "src", "LICENSE", "README.md", "package.json"],
+	"scripts": {
+		"build:cli": "bun build src/cli.ts --outdir dist --target node",
+		"dev": "bun run --watch src/index.tsx",
+		"check": "bun run typecheck && bun run lint && bun run format:check",
+		"typecheck": "bunx tsc -p tsconfig.json --noEmit",
+		"lint": "biome lint src __tests__",
+		"lint:fix": "biome lint --write src __tests__",
+		"format": "biome format --write src __tests__",
+		"format:check": "biome format src __tests__",
+		"preview:avatar": "bun run src/avatar-preview.ts",
+		"preview:avatar:mp4": "bun run src/avatar-preview.ts --mp4 tmp/avatar-preview.mp4",
+		"setup:browsers": "bun run src/scripts/setup-browsers.ts",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
+		"prepublishOnly": "bun run build:cli",
+		"release:patch": "npm version patch && git push && git push --tags && npm publish",
+		"release:minor": "npm version minor && git push && git push --tags && npm publish",
+		"release:major": "npm version major && git push && git push --tags && npm publish"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@types/bun": "latest",
+		"@types/react": "^19.2.7",
+		"playwright": "^1.57.0"
+	},
+	"peerDependencies": {
+		"typescript": "^5.9.2"
+	},
+	"dependencies": {
+		"@ai-sdk/openai": "^3.0.0",
+		"@openrouter/ai-sdk-provider": "1.5.4",
+		"@opentui-ui/toast": "^0.0.3",
+		"@opentui/core": "^0.1.63",
+		"@opentui/react": "^0.1.63",
+		"ai": "^6.0.0",
+		"exa-js": "^2.0.12",
+		"openai": "^6.16.0",
+		"opentui-spinner": "^0.0.6",
+		"react": "^19.2.3"
+	}
+}

package/src/ai/agent-turn-runner.ts

@@ -0,0 +1,130 @@
+import { generateResponse } from "./daemon-ai";
+import type {
+	InteractionMode,
+	ModelMessage,
+	ReasoningEffort,
+	StreamCallbacks,
+	TokenUsage,
+	ToolApprovalRequest,
+	ToolApprovalResponse,
+} from "../types";
+
+export interface AgentTurnParams {
+	userText: string;
+	conversationHistory: ModelMessage[];
+	interactionMode: InteractionMode;
+	reasoningEffort: ReasoningEffort;
+}
+
+export interface AgentTurnResult {
+	fullText: string;
+	responseMessages: ModelMessage[];
+	usage?: TokenUsage;
+	finalText?: string;
+}
+
+export class AgentTurnRunner {
+	private abortController: AbortController | null = null;
+	private activeRunId = 0;
+
+	cancel(): void {
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		this.activeRunId++;
+	}
+
+	async run(params: AgentTurnParams, callbacks: StreamCallbacks): Promise<AgentTurnResult | null> {
+		const runId = ++this.activeRunId;
+		this.abortController = new AbortController();
+
+		const isActive = () => runId === this.activeRunId && this.abortController !== null;
+
+		let result: AgentTurnResult | null = null;
+		let error: Error | null = null;
+
+		const wrapped: StreamCallbacks = {
+			onReasoningToken: (token) => {
+				if (!isActive()) return;
+				callbacks.onReasoningToken?.(token);
+			},
+			onToolCallStart: (toolName, toolCallId) => {
+				if (!isActive()) return;
+				callbacks.onToolCallStart?.(toolName, toolCallId);
+			},
+			onToolCall: (toolName, args, toolCallId) => {
+				if (!isActive()) return;
+				callbacks.onToolCall?.(toolName, args, toolCallId);
+			},
+			onToolResult: (toolName, resultValue, toolCallId) => {
+				if (!isActive()) return;
+				callbacks.onToolResult?.(toolName, resultValue, toolCallId);
+			},
+			onToolApprovalRequest: (request) => {
+				if (!isActive()) return;
+				callbacks.onToolApprovalRequest?.(request);
+			},
+			onAwaitingApprovals: (pendingApprovals, respondToApprovals) => {
+				if (!isActive()) return;
+				callbacks.onAwaitingApprovals?.(pendingApprovals, respondToApprovals);
+			},
+			onSubagentToolCall: (toolCallId, toolName, input) => {
+				if (!isActive()) return;
+				callbacks.onSubagentToolCall?.(toolCallId, toolName, input);
+			},
+			onSubagentUsage: (usage) => {
+				if (!isActive()) return;
+				callbacks.onSubagentUsage?.(usage);
+			},
+			onSubagentToolResult: (toolCallId, toolName, success) => {
+				if (!isActive()) return;
+				callbacks.onSubagentToolResult?.(toolCallId, toolName, success);
+			},
+			onSubagentComplete: (toolCallId, success) => {
+				if (!isActive()) return;
+				callbacks.onSubagentComplete?.(toolCallId, success);
+			},
+			onToken: (token) => {
+				if (!isActive()) return;
+				callbacks.onToken?.(token);
+			},
+			onStepUsage: (usage) => {
+				if (!isActive()) return;
+				callbacks.onStepUsage?.(usage);
+			},
+			onComplete: (fullText, responseMessages, usage, finalText) => {
+				if (!isActive()) return;
+				result = { fullText, responseMessages, usage, finalText };
+				callbacks.onComplete?.(fullText, responseMessages, usage, finalText);
+			},
+			onError: (err) => {
+				if (!isActive()) return;
+				error = err;
+				callbacks.onError?.(err);
+			},
+		};
+
+		try {
+			await generateResponse(
+				params.userText,
+				wrapped,
+				params.conversationHistory,
+				params.interactionMode,
+				this.abortController.signal,
+				params.reasoningEffort
+			);
+		} catch (err) {
+			const e = err instanceof Error ? err : new Error(String(err));
+			error = e;
+			wrapped.onError?.(e);
+		} finally {
+			if (isActive()) {
+				this.abortController = null;
+			}
+		}
+
+		if (error) throw error;
+		return result;
+	}
+}