@makefinks/daemon 0.1.0

package/src/utils/paste.ts

@@ -0,0 +1,33 @@
+import type { TextareaRenderable } from "@opentui/core";
+import { readClipboardText } from "./clipboard";
+import { debug } from "./debug-logger";
+
+export interface PasteOptions {
+	singleLine?: boolean;
+	source?: string;
+}
+
+export function normalizeClipboardText(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export async function pasteClipboardIntoTextarea(
+	textarea: TextareaRenderable | null,
+	options: PasteOptions = {}
+): Promise<boolean> {
+	const raw = await readClipboardText();
+	const normalized = normalizeClipboardText(raw);
+	const text = options.singleLine ? normalized.replace(/[\r\n]/g, "") : normalized;
+
+	if (!text) {
+		debug.log("[Paste] Clipboard empty", { source: options.source });
+		return false;
+	}
+
+	textarea?.insertText(text);
+	debug.log("[Paste] Inserted clipboard text", {
+		source: options.source,
+		length: text.length,
+	});
+	return true;
+}

package/src/utils/preferences.ts

@@ -0,0 +1,289 @@
+/**
+ * Preferences persistence for DAEMON.
+ * Stores user configuration in OS-appropriate config directories.
+ */
+
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { AppPreferences } from "../types";
+
+const PREFERENCES_VERSION = 1;
+const APP_DIR_NAME = "daemon";
+const PREFERENCES_FILE = "preferences.json";
+const CREDENTIALS_FILE = "credentials.json";
+
+/** Keys that belong in credentials.json (secrets) vs preferences.json (settings) */
+const CREDENTIAL_KEYS = ["openRouterApiKey", "openAiApiKey", "exaApiKey"] as const;
+type CredentialKey = (typeof CREDENTIAL_KEYS)[number];
+
+function isCredentialKey(key: string): key is CredentialKey {
+	return CREDENTIAL_KEYS.includes(key as CredentialKey);
+}
+
+function getBaseConfigDir(): string {
+	if (process.platform === "win32") {
+		return process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+	}
+	if (process.platform === "darwin") {
+		return path.join(os.homedir(), ".config");
+	}
+	return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+}
+
+export function getAppConfigDir(): string {
+	return path.join(getBaseConfigDir(), APP_DIR_NAME);
+}
+
+export function getPreferencesPath(): string {
+	return path.join(getAppConfigDir(), PREFERENCES_FILE);
+}
+
+export function getCredentialsPath(): string {
+	return path.join(getAppConfigDir(), CREDENTIALS_FILE);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null;
+}
+
+export function parsePreferences(raw: unknown): AppPreferences | null {
+	if (!isRecord(raw)) return null;
+
+	const version = typeof raw.version === "number" ? raw.version : PREFERENCES_VERSION;
+	const createdAt = typeof raw.createdAt === "string" ? raw.createdAt : new Date().toISOString();
+	const updatedAt = typeof raw.updatedAt === "string" ? raw.updatedAt : createdAt;
+	const onboardingCompleted = typeof raw.onboardingCompleted === "boolean" ? raw.onboardingCompleted : false;
+
+	const prefs: AppPreferences = {
+		version,
+		createdAt,
+		updatedAt,
+		onboardingCompleted,
+	};
+
+	if (typeof raw.audioDeviceName === "string") {
+		prefs.audioDeviceName = raw.audioDeviceName;
+	}
+	if (typeof raw.audioOutputDeviceName === "string") {
+		prefs.audioOutputDeviceName = raw.audioOutputDeviceName;
+	}
+	if (typeof raw.modelId === "string") {
+		prefs.modelId = raw.modelId;
+	}
+	if (typeof raw.openRouterProviderTag === "string") {
+		prefs.openRouterProviderTag = raw.openRouterProviderTag;
+	}
+	if (raw.interactionMode === "text" || raw.interactionMode === "voice") {
+		prefs.interactionMode = raw.interactionMode;
+	}
+	if (raw.voiceInteractionType === "direct" || raw.voiceInteractionType === "review") {
+		prefs.voiceInteractionType = raw.voiceInteractionType;
+	} else {
+		prefs.voiceInteractionType = "direct";
+	}
+	if (
+		raw.speechSpeed === 1.0 ||
+		raw.speechSpeed === 1.25 ||
+		raw.speechSpeed === 1.5 ||
+		raw.speechSpeed === 1.75 ||
+		raw.speechSpeed === 2.0
+	) {
+		prefs.speechSpeed = raw.speechSpeed;
+	}
+	if (raw.reasoningEffort === "low" || raw.reasoningEffort === "medium" || raw.reasoningEffort === "high") {
+		prefs.reasoningEffort = raw.reasoningEffort;
+	}
+	if (typeof raw.openRouterApiKey === "string") {
+		prefs.openRouterApiKey = raw.openRouterApiKey;
+	}
+	if (typeof raw.openAiApiKey === "string") {
+		prefs.openAiApiKey = raw.openAiApiKey;
+	}
+	if (typeof raw.exaApiKey === "string") {
+		prefs.exaApiKey = raw.exaApiKey;
+	}
+	if (typeof raw.showFullReasoning === "boolean") {
+		prefs.showFullReasoning = raw.showFullReasoning;
+	}
+	if (typeof raw.showToolOutput === "boolean") {
+		prefs.showToolOutput = raw.showToolOutput;
+	}
+	if (
+		raw.bashApprovalLevel === "none" ||
+		raw.bashApprovalLevel === "dangerous" ||
+		raw.bashApprovalLevel === "all"
+	) {
+		prefs.bashApprovalLevel = raw.bashApprovalLevel;
+	}
+	if (Array.isArray(raw.inputHistory)) {
+		const validHistory = raw.inputHistory.filter((item): item is string => typeof item === "string");
+		prefs.inputHistory = validHistory.slice(0, 20);
+	}
+
+	return prefs;
+}
+
+export async function loadPreferences(): Promise<AppPreferences | null> {
+	try {
+		const prefsPath = getPreferencesPath();
+		const credsPath = getCredentialsPath();
+
+		let prefsRaw: unknown = {};
+		let credsRaw: unknown = {};
+
+		try {
+			const prefsContents = await fs.readFile(prefsPath, "utf8");
+			prefsRaw = JSON.parse(prefsContents) as unknown;
+		} catch {}
+
+		try {
+			const credsContents = await fs.readFile(credsPath, "utf8");
+			credsRaw = JSON.parse(credsContents) as unknown;
+		} catch {}
+
+		const merged = {
+			...(isRecord(prefsRaw) ? prefsRaw : {}),
+			...(isRecord(credsRaw) ? credsRaw : {}),
+		};
+
+		if (Object.keys(merged).length === 0) {
+			return null;
+		}
+
+		return parsePreferences(merged);
+	} catch {
+		return null;
+	}
+}
+
+async function writeJsonFile(filePath: string, data: Record<string, unknown>, mode?: number): Promise<void> {
+	const dir = path.dirname(filePath);
+	await fs.mkdir(dir, { recursive: true });
+
+	const tempPath = path.join(dir, `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+	const payload = JSON.stringify(data, null, 2);
+
+	await fs.writeFile(tempPath, payload, { encoding: "utf8", mode: mode ?? 0o644 });
+	await fs.rename(tempPath, filePath);
+
+	if (mode !== undefined) {
+		await fs.chmod(filePath, mode);
+	}
+}
+
+export async function savePreferences(preferences: AppPreferences): Promise<void> {
+	const prefsPath = getPreferencesPath();
+	const credsPath = getCredentialsPath();
+
+	const prefsData: Record<string, unknown> = {};
+	const credsData: Record<string, unknown> = {};
+
+	for (const [key, value] of Object.entries(preferences)) {
+		if (value === undefined) continue;
+		if (isCredentialKey(key)) {
+			credsData[key] = value;
+		} else {
+			prefsData[key] = value;
+		}
+	}
+
+	await writeJsonFile(prefsPath, prefsData);
+
+	if (Object.keys(credsData).length > 0) {
+		await writeJsonFile(credsPath, credsData, 0o600);
+	}
+}
+
+export async function updatePreferences(updates: Partial<AppPreferences>): Promise<AppPreferences> {
+	const existing = await loadPreferences();
+	const now = new Date().toISOString();
+	const base: AppPreferences = existing ?? {
+		version: PREFERENCES_VERSION,
+		createdAt: now,
+		updatedAt: now,
+		onboardingCompleted: false,
+	};
+
+	const next: AppPreferences = {
+		...base,
+		...updates,
+		version: PREFERENCES_VERSION,
+		updatedAt: now,
+	};
+
+	await savePreferences(next);
+	return next;
+}
+
+/**
+ * Check if OpenRouter API key is available (from env or stored preferences).
+ */
+export function hasOpenRouterApiKey(): boolean {
+	return Boolean(process.env.OPENROUTER_API_KEY);
+}
+
+/**
+ * Check if OpenAI API key is available (from env or stored preferences).
+ */
+export function hasOpenAiApiKey(): boolean {
+	return Boolean(process.env.OPENAI_API_KEY);
+}
+
+/**
+ * Check if Exa API key is available (from env or stored preferences).
+ */
+export function hasExaApiKey(): boolean {
+	return Boolean(process.env.EXA_API_KEY);
+}
+
+/**
+ * Get the effective OpenRouter API key (env takes precedence over stored).
+ */
+export function getOpenRouterApiKey(storedKey?: string): string | undefined {
+	return process.env.OPENROUTER_API_KEY || storedKey;
+}
+
+/**
+ * Get the effective OpenAI API key (env takes precedence over stored).
+ */
+export function getOpenAiApiKey(storedKey?: string): string | undefined {
+	return process.env.OPENAI_API_KEY || storedKey;
+}
+
+/**
+ * Get the effective Exa API key (env takes precedence over stored).
+ */
+export function getExaApiKey(storedKey?: string): string | undefined {
+	return process.env.EXA_API_KEY || storedKey;
+}
+
+/**
+ * Set API keys in process.env for the current session.
+ * Called after loading preferences to make stored keys available to SDK clients.
+ */
+export function applyApiKeysToEnv(prefs: AppPreferences): void {
+	if (prefs.openRouterApiKey && !process.env.OPENROUTER_API_KEY) {
+		process.env.OPENROUTER_API_KEY = prefs.openRouterApiKey;
+	}
+	if (prefs.openAiApiKey && !process.env.OPENAI_API_KEY) {
+		process.env.OPENAI_API_KEY = prefs.openAiApiKey;
+	}
+	if (prefs.exaApiKey && !process.env.EXA_API_KEY) {
+		process.env.EXA_API_KEY = prefs.exaApiKey;
+	}
+}
+
+/**
+ * Open a URL in the default browser.
+ */
+export function openUrlInBrowser(url: string): void {
+	const { spawn } = require("node:child_process");
+	if (process.platform === "darwin") {
+		spawn("open", [url], { detached: true, stdio: "ignore" });
+	} else if (process.platform === "win32") {
+		spawn("cmd", ["/c", "start", url], { detached: true, stdio: "ignore" });
+	} else {
+		spawn("xdg-open", [url], { detached: true, stdio: "ignore" });
+	}
+}

package/src/utils/text-fragment.ts

@@ -0,0 +1,39 @@
+function encodeTextFragment(text: string): string {
+	return encodeURIComponent(text).replace(/-/g, "%2D");
+}
+
+export function buildTextFragmentUrl(url: string, fragment: { fragmentText: string }): string {
+	if (!fragment || !fragment.fragmentText) return url;
+
+	const encoded = encodeTextFragment(fragment.fragmentText);
+	const textDirective = `text=${encoded}`;
+
+	try {
+		const parsed = new URL(url);
+		const existingHash = parsed.hash;
+
+		if (!existingHash) {
+			parsed.hash = `:~:${textDirective}`;
+		} else if (existingHash.includes(":~:text=")) {
+			parsed.hash = existingHash.replace(/:~:text=[^&]*/, `:~:${textDirective}`);
+		} else {
+			parsed.hash = `${existingHash}:~:${textDirective}`;
+		}
+
+		return parsed.toString();
+	} catch {
+		const hashIdx = url.indexOf("#");
+		if (hashIdx === -1) {
+			return `${url}#:~:${textDirective}`;
+		}
+
+		const base = url.slice(0, hashIdx);
+		const existingHash = url.slice(hashIdx);
+
+		if (existingHash.includes(":~:text=")) {
+			return base + existingHash.replace(/:~:text=[^&]*/, `:~:${textDirective}`);
+		}
+
+		return `${url}:~:${textDirective}`;
+	}
+}

package/src/utils/tool-output-preview.ts

@@ -0,0 +1,250 @@
+type UnknownRecord = Record<string, unknown>;
+
+function isRecord(value: unknown): value is UnknownRecord {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function normalizeWhitespace(text: string): string {
+	return text.replace(/\r\n/g, "\n").replace(/\t/g, "  ");
+}
+
+function truncateText(text: string, maxChars: number): { text: string; truncated: boolean } {
+	if (text.length <= maxChars) return { text, truncated: false };
+	if (maxChars <= 1) return { text: "…", truncated: true };
+	return { text: `${text.slice(0, maxChars - 1)}…`, truncated: true };
+}
+
+function splitPreviewLines(text: string, maxLines: number): { lines: string[]; truncated: boolean } {
+	const normalized = normalizeWhitespace(text);
+	const rawLines = normalized.split("\n");
+	const trimmedLines = rawLines.map((l) => l.trimEnd()).filter((l) => l.length > 0);
+	if (trimmedLines.length <= maxLines) return { lines: trimmedLines, truncated: false };
+	return { lines: trimmedLines.slice(0, maxLines), truncated: true };
+}
+
+function pickFirstNonEmpty(...parts: Array<string | undefined | null>): string {
+	for (const part of parts) {
+		if (typeof part === "string" && part.trim().length > 0) return part;
+	}
+	return "";
+}
+
+function formatBashResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	const success = "success" in result ? result.success : undefined;
+	const exitCode =
+		typeof result.exitCode === "number" || result.exitCode === null ? result.exitCode : undefined;
+
+	const stdout = typeof result.stdout === "string" ? result.stdout : "";
+	const stderr = typeof result.stderr === "string" ? result.stderr : "";
+	const error = typeof result.error === "string" ? result.error : "";
+
+	const body = pickFirstNonEmpty(stdout, stderr, error);
+	if (!body) {
+		if (typeof success === "boolean") {
+			return `success=${success}${exitCode !== undefined ? ` exit=${String(exitCode)}` : ""}`;
+		}
+		return null;
+	}
+
+	const label = stdout.trim().length > 0 ? "stdout" : stderr.trim().length > 0 ? "stderr" : "error";
+	const meta =
+		typeof success === "boolean" || exitCode !== undefined
+			? ` (${typeof success === "boolean" ? `success=${success}` : ""}${exitCode !== undefined ? `${typeof success === "boolean" ? " " : ""}exit=${String(exitCode)}` : ""})`
+			: "";
+	return `${label}${meta}: ${body}`;
+}
+
+type ExaLikeItem = {
+	title?: unknown;
+	url?: unknown;
+	text?: unknown;
+	lineOffset?: unknown;
+	lineLimit?: unknown;
+};
+
+function extractExaItems(data: unknown): ExaLikeItem[] | null {
+	if (!isRecord(data)) return null;
+	const direct = data.results;
+	if (Array.isArray(direct)) return direct as ExaLikeItem[];
+	const contents = data.contents;
+	if (Array.isArray(contents)) return contents as ExaLikeItem[];
+	return null;
+}
+
+function extractToolDataContainer(result: UnknownRecord): unknown {
+	if ("data" in result) return result.data;
+	return result;
+}
+
+function formatExaItemLabel(item: ExaLikeItem): string {
+	const title = typeof item.title === "string" ? item.title : "";
+	const url = typeof item.url === "string" ? item.url : "";
+	return pickFirstNonEmpty(title, url, "(untitled)");
+}
+
+function formatExaSearchResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return `error: ${result.error}`;
+	}
+	if (result.success !== true) return null;
+	const data = extractToolDataContainer(result);
+	const items = extractExaItems(data);
+	if (!items) return null;
+
+	const top = items.slice(0, 4).map((item, idx) => {
+		const url = typeof item.url === "string" ? item.url : "";
+		const title = typeof item.title === "string" ? item.title : "";
+		const label = formatExaItemLabel(item);
+		const urlSuffix = url && title ? ` — ${url}` : "";
+		return `${idx + 1}) ${label}${urlSuffix}`;
+	});
+
+	return top.length > 0 ? top.join("\n") : null;
+}
+
+function formatExaFetchResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return `error: ${result.error}`;
+	}
+	if (result.success !== true) return null;
+	const data = extractToolDataContainer(result);
+	const candidate = isRecord(data) ? (data as ExaLikeItem & { remainingLines?: unknown }) : {};
+	const label = formatExaItemLabel(candidate);
+	const url = typeof candidate.url === "string" ? candidate.url : "";
+	const title = typeof candidate.title === "string" ? candidate.title : "";
+	const lineOffset = typeof candidate.lineOffset === "number" ? candidate.lineOffset : undefined;
+	const lineLimit = typeof candidate.lineLimit === "number" ? candidate.lineLimit : undefined;
+	const remainingLines =
+		typeof (candidate as { remainingLines?: unknown }).remainingLines === "number" ||
+		(candidate as { remainingLines?: unknown }).remainingLines === null
+			? (candidate as { remainingLines: number | null }).remainingLines
+			: undefined;
+	const rangeParts: string[] = [];
+	if (lineOffset !== undefined) rangeParts.push(`lineOffset=${lineOffset}`);
+	if (lineLimit !== undefined) rangeParts.push(`lineLimit=${lineLimit}`);
+	if (remainingLines !== undefined) {
+		rangeParts.push(remainingLines === null ? "remainingLines=unknown" : `remainingLines=${remainingLines}`);
+	}
+	const remainingSuffix = rangeParts.length > 0 ? ` (${rangeParts.join(", ")})` : "";
+
+	const headerBase = url && title ? `${label} — ${url}` : label;
+	const header = `${headerBase}${remainingSuffix}`;
+
+	const text = typeof candidate.text === "string" ? candidate.text : "";
+	if (!text.trim()) return header;
+
+	// Provide a small snippet; downstream truncation enforces the hard caps.
+	const snippet = normalizeWhitespace(text)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+
+	return `${header}\n${snippet}`;
+}
+
+function formatRenderUrlResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return `error: ${result.error}`;
+	}
+	if (result.success !== true) return null;
+
+	const url = typeof result.url === "string" ? result.url : "(unknown url)";
+	const lineOffset = typeof result.lineOffset === "number" ? result.lineOffset : undefined;
+	const lineLimit = typeof result.lineLimit === "number" ? result.lineLimit : undefined;
+	const remainingLines = typeof result.remainingLines === "number" ? result.remainingLines : null;
+	const rangeParts: string[] = [];
+	if (lineOffset !== undefined) rangeParts.push(`lineOffset=${lineOffset}`);
+	if (lineLimit !== undefined) rangeParts.push(`lineLimit=${lineLimit}`);
+	rangeParts.push(remainingLines === null ? "remainingLines=unknown" : `remainingLines=${remainingLines}`);
+	const remainingSuffix = rangeParts.length > 0 ? ` (${rangeParts.join(", ")})` : "";
+
+	const header = `${url}${remainingSuffix}`;
+
+	const text = typeof result.text === "string" ? result.text : "";
+	if (!text.trim()) return header;
+
+	const snippet = normalizeWhitespace(text)
+		.replace(/\n{3,}/g, "\n\n")
+		.trim();
+
+	return `${header}\n${snippet}`;
+}
+
+function formatReadFileResult(result: unknown): string | null {
+	if (!isRecord(result)) return null;
+	if (result.success === false && typeof result.error === "string") {
+		return `error: ${result.error}`;
+	}
+	if (result.success !== true) return null;
+	const path = typeof result.path === "string" ? result.path : "";
+	const startLine = typeof result.startLine === "number" ? result.startLine : undefined;
+	const endLine = typeof result.endLine === "number" ? result.endLine : undefined;
+	const hasMore = typeof result.hasMore === "boolean" ? result.hasMore : undefined;
+	const content = typeof result.content === "string" ? result.content : "";
+
+	const range =
+		startLine !== undefined && endLine !== undefined && startLine > 0 && endLine > 0
+			? ` (${startLine}-${endLine}${hasMore ? "+" : ""})`
+			: "";
+
+	if (!content.trim()) return path ? `${path}${range}` : null;
+	return `${path}${range}:\n${content}`;
+}
+
+/**
+ * Format a very small, terminal-safe preview of a tool result.
+ * Intended for the tool call UI box (not full logs).
+ */
+export function formatToolOutputPreview(toolName: string, result: unknown): string[] | null {
+	if (result === undefined) return null;
+
+	let raw: string | null = null;
+	if (toolName === "runBash") raw = formatBashResult(result);
+	if (toolName === "webSearch") raw = formatExaSearchResult(result);
+	if (toolName === "fetchUrls") raw = formatExaFetchResult(result);
+	if (toolName === "renderUrl") raw = formatRenderUrlResult(result);
+	if (toolName === "readFile") raw = formatReadFileResult(result);
+
+	if (!raw) {
+		if (isRecord(result) && result.success === false && typeof result.error === "string") {
+			raw = `error: ${result.error}`;
+		} else {
+			return null;
+		}
+	}
+
+	const MAX_LINES = 4;
+	const MAX_CHARS_PER_LINE = 160;
+	const MAX_TOTAL_CHARS = 260;
+
+	const { lines, truncated: lineTruncated } = splitPreviewLines(raw, MAX_LINES);
+
+	let usedChars = 0;
+	const outputLines: string[] = [];
+	let anyTruncated = lineTruncated;
+
+	for (const line of lines) {
+		const remaining = Math.max(0, MAX_TOTAL_CHARS - usedChars);
+		if (remaining <= 0) {
+			anyTruncated = true;
+			break;
+		}
+		const { text: truncatedLine, truncated } = truncateText(line, Math.min(MAX_CHARS_PER_LINE, remaining));
+		anyTruncated = anyTruncated || truncated;
+		outputLines.push(truncatedLine);
+		usedChars += truncatedLine.length;
+	}
+
+	if (anyTruncated && outputLines.length > 0) {
+		const last = outputLines[outputLines.length - 1] ?? "";
+		if (!last.endsWith("…")) {
+			const { text } = truncateText(last, Math.max(1, last.length - 1));
+			outputLines[outputLines.length - 1] = `${text}…`.replace(/……$/, "…");
+		}
+	}
+
+	return outputLines.length > 0 ? outputLines : null;
+}