@makefinks/daemon 0.1.0

package/src/types/index.ts

@@ -0,0 +1,405 @@
+/**
+ * Shared type definitions for the DAEMON application.
+ * Consolidates types used across multiple modules.
+ */
+
+import type { ModelMessage } from "ai";
+
+// Re-export AI SDK types for convenience
+export type { ModelMessage } from "ai";
+
+/**
+ * Tool result output format expected by the AI SDK.
+ */
+export type ToolResultOutput =
+	| { type: "text"; value: string }
+	| { type: "json"; value: Record<string, unknown> | unknown[] | string | number | boolean | null }
+	| { type: "error-text"; value: string }
+	| { type: "error-json"; value: Record<string, unknown> | unknown[] | string | number | boolean | null };
+
+/**
+ * DAEMON operational states
+ */
+export enum DaemonState {
+	IDLE = "idle",
+	LISTENING = "listening",
+	TRANSCRIBING = "transcribing",
+	RESPONDING = "responding",
+	SPEAKING = "speaking",
+	TYPING = "typing",
+}
+
+/**
+ * Token usage information from API response
+ */
+export interface TokenUsage {
+	promptTokens: number;
+	completionTokens: number;
+	totalTokens: number;
+	reasoningTokens?: number;
+	cachedInputTokens?: number;
+	cost?: number;
+	subagentTotalTokens?: number;
+	subagentPromptTokens?: number;
+	subagentCompletionTokens?: number;
+}
+
+/**
+ * Status of a tool call or subagent step
+ * - "streaming": Tool call detected, name known, but input still streaming
+ * - "running": Tool call input complete, execution in progress
+ * - "completed": Tool execution finished successfully
+ * - "failed": Tool execution failed
+ */
+export type ToolCallStatus = "streaming" | "running" | "completed" | "failed" | "awaiting_approval";
+
+/**
+ * A step/action taken by a subagent, displayed in the UI
+ */
+export interface SubagentStep {
+	toolName: string;
+	status: ToolCallStatus;
+	input?: unknown;
+	summary?: string;
+}
+
+/**
+ * Tool call representation for UI rendering
+ */
+export interface ToolCall {
+	name: string;
+	input: unknown;
+	toolCallId?: string;
+	/** For subagent tool calls - tracks nested tool invocations */
+	subagentSteps?: SubagentStep[];
+	/** Current status of the tool call */
+	status?: ToolCallStatus;
+	/** Snapshot of todos at the time of the tool call (for todoManager) */
+	todoSnapshot?: Array<{ content: string; status: string }>;
+	/** Error message when status is "failed" */
+	error?: string;
+	/** Result of user approval decision (only set for tools that required approval) */
+	approvalResult?: "approved" | "denied";
+}
+
+/**
+ * Content block types for interleaved UI display.
+ * These are derived from ModelMessage content for rendering.
+ */
+export type ContentBlock =
+	| { type: "reasoning"; content: string; durationMs?: number }
+	| { type: "tool"; call: ToolCall; result?: unknown }
+	| { type: "text"; content: string };
+
+/**
+ * UI-specific conversation message that wraps the core AI SDK messages.
+ * The `messages` field contains the actual AI SDK messages for API calls.
+ * The other fields are for UI display convenience.
+ */
+export interface ConversationMessage {
+	id: number;
+	type: "user" | "daemon";
+	content: string;
+	messages: ModelMessage[];
+	contentBlocks?: ContentBlock[];
+	pending?: boolean;
+}
+
+/**
+ * Persisted session snapshot for reloading UI and model context.
+ */
+export interface SessionSnapshot {
+	conversationHistory: ConversationMessage[];
+	sessionUsage: TokenUsage;
+}
+
+/**
+ * Session metadata for listing and selection.
+ */
+export interface SessionInfo {
+	id: string;
+	title: string;
+	createdAt: string;
+	updatedAt: string;
+}
+
+/**
+ * Color theme for avatar states.
+ * Used by both daemon-state.ts and daemon-avatar-rig.ts.
+ */
+export interface AvatarColorTheme {
+	primary: number;
+	glow: number;
+	eye: number;
+}
+
+/**
+ * Alias for avatar color theme used by the rig.
+ * @deprecated Use AvatarColorTheme directly
+ */
+export type DaemonColorTheme = AvatarColorTheme;
+
+/**
+ * Transcription result from voice input
+ */
+export interface TranscriptionResult {
+	text: string;
+}
+
+/**
+ * Callbacks for streaming AI responses
+ */
+export interface StreamCallbacks {
+	onToken?: (token: string) => void;
+	onReasoningToken?: (token: string) => void;
+	onToolCallStart?: (toolName: string, toolCallId: string) => void;
+	onToolCall?: (toolName: string, args: unknown, toolCallId?: string) => void;
+	onToolResult?: (toolName: string, result: unknown, toolCallId?: string) => void;
+	onToolApprovalRequest?: (request: ToolApprovalRequest) => void;
+	onAwaitingApprovals?: (
+		pendingApprovals: ToolApprovalRequest[],
+		respondToApprovals: (responses: ToolApprovalResponse[]) => void
+	) => void;
+	onSubagentToolCall?: (toolCallId: string, toolName: string, input?: unknown) => void;
+	onSubagentUsage?: (usage: TokenUsage) => void;
+	onSubagentToolResult?: (toolCallId: string, toolName: string, success: boolean) => void;
+	onSubagentComplete?: (toolCallId: string, success: boolean) => void;
+	onStepUsage?: (usage: TokenUsage) => void;
+	onComplete?: (
+		fullText: string,
+		responseMessages: ModelMessage[],
+		usage?: TokenUsage,
+		/** The final assistant text only (for TTS - excludes intermediate text from tool-call steps) */
+		finalText?: string
+	) => void;
+	onError?: (error: Error) => void;
+}
+
+/**
+ * Audio device information
+ */
+export interface AudioDevice {
+	name: string;
+	isDefault?: boolean;
+}
+
+/**
+ * Interaction mode for DAEMON responses.
+ * - "text": Terminal output with markdown formatting
+ * - "voice": Speech-to-speech, natural conversational responses
+ */
+export type InteractionMode = "text" | "voice";
+
+/**
+ * Speech speed settings (1.0x to 2.0x)
+ */
+export type SpeechSpeed = 1.0 | 1.25 | 1.5 | 1.75 | 2.0;
+
+/**
+ * Reasoning effort / cognitive depth settings.
+ * Controls how deeply the model reasons about responses.
+ * - "low": SURFACE - minimal reasoning
+ * - "medium": DEEP - moderate reasoning (default)
+ * - "high": ABYSSAL - maximum reasoning depth
+ */
+export type ReasoningEffort = "low" | "medium" | "high";
+
+/** Display labels for reasoning effort levels */
+export const REASONING_EFFORT_LABELS: Record<ReasoningEffort, string> = {
+	low: "LOW",
+	medium: "MEDIUM",
+	high: "HIGH",
+};
+
+/** Ordered list of reasoning effort levels for cycling */
+export const REASONING_EFFORT_LEVELS: ReasoningEffort[] = ["low", "medium", "high"];
+
+/**
+ * Bash tool approval level settings.
+ * Controls when user approval is required for bash commands.
+ * - "none": No approval required for any bash commands
+ * - "dangerous": Approval required only for potentially dangerous commands
+ * - "all": Approval required for all bash commands
+ */
+export type BashApprovalLevel = "none" | "dangerous" | "all";
+
+/** Display labels for bash approval levels */
+export const BASH_APPROVAL_LABELS: Record<BashApprovalLevel, string> = {
+	none: "NONE",
+	dangerous: "DANGEROUS",
+	all: "ALL",
+};
+
+/** Ordered list of bash approval levels for cycling */
+export const BASH_APPROVAL_LEVELS: BashApprovalLevel[] = ["none", "dangerous", "all"];
+
+/**
+ * Onboarding flow steps.
+ * - intro: Welcome screen
+ * - openrouter_key: OpenRouter API key input (for AI models)
+ * - openai_key: OpenAI API key input (for transcription)
+ * - exa_key: Exa API key input (for web search)
+ * - device: Audio device selection
+ * - model: AI model selection
+ * - complete: Onboarding finished
+ */
+export type OnboardingStep =
+	| "intro"
+	| "openrouter_key"
+	| "openai_key"
+	| "exa_key"
+	| "device"
+	| "model"
+	| "settings"
+	| "complete";
+
+export type VoiceInteractionType = "direct" | "review";
+
+/**
+ * Persisted user preferences.
+ */
+export interface AppPreferences {
+	version: number;
+	createdAt: string;
+	updatedAt: string;
+	onboardingCompleted: boolean;
+	audioDeviceName?: string;
+	audioOutputDeviceName?: string;
+	modelId?: string;
+	/**
+	 * OpenRouter inference provider slug (aka `provider` routing tag), e.g. "openai".
+	 * When unset, OpenRouter will automatically route to the best available provider.
+	 */
+	openRouterProviderTag?: string;
+	interactionMode?: InteractionMode;
+	voiceInteractionType?: VoiceInteractionType;
+	speechSpeed?: SpeechSpeed;
+	reasoningEffort?: ReasoningEffort;
+	/** OpenRouter API key for AI model responses */
+	openRouterApiKey?: string;
+	/** OpenAI API key for voice transcription */
+	openAiApiKey?: string;
+	/** Exa API key for web search */
+	exaApiKey?: string;
+	/** Show full reasoning blocks instead of compact ticker */
+	showFullReasoning?: boolean;
+	/** Show tool output previews */
+	showToolOutput?: boolean;
+	/** Bash command approval level */
+	bashApprovalLevel?: BashApprovalLevel;
+	/** Recent user inputs for up/down history navigation (max 20) */
+	inputHistory?: string[];
+}
+
+/**
+ * Model pricing information (per 1M tokens)
+ */
+export interface ModelPricing {
+	prompt: number;
+	completion: number;
+	/**
+	 * Discounted price for cache reads (per 1M input tokens).
+	 * Present only for some providers/models on OpenRouter.
+	 */
+	inputCacheRead?: number;
+	/**
+	 * Price for cache writes (per 1M input tokens).
+	 * Present only for some providers/models on OpenRouter.
+	 */
+	inputCacheWrite?: number;
+}
+
+/**
+ * Model option for selection menus
+ */
+export interface ModelOption {
+	id: string;
+	name: string;
+	pricing?: ModelPricing;
+	contextLength?: number;
+	supportsCaching?: boolean;
+}
+
+/**
+ * Todo item status
+ */
+export type TodoStatus = "pending" | "in_progress" | "completed" | "cancelled";
+
+/**
+ * Tool approval request from the AI SDK.
+ * Emitted when a tool with needsApproval: true is called.
+ */
+export interface ToolApprovalRequest {
+	approvalId: string;
+	toolName: string;
+	toolCallId: string;
+	input: unknown;
+}
+
+/**
+ * Tool approval response to send back to the agent.
+ */
+export interface ToolApprovalResponse {
+	approvalId: string;
+	approved: boolean;
+	reason?: string;
+}
+
+/**
+ * Todo item for task tracking
+ */
+export interface TodoItem {
+	content: string;
+	status: TodoStatus;
+}
+
+/**
+ * Event emitter interface for subagent progress updates.
+ * Used to connect subagent tool execution to the UI.
+ */
+export interface SubagentProgressEmitter {
+	onSubagentToolCall: (toolCallId: string, toolName: string, input?: unknown) => void;
+	onSubagentUsage: (usage: {
+		promptTokens: number;
+		completionTokens: number;
+		totalTokens: number;
+		reasoningTokens?: number;
+		cachedInputTokens?: number;
+		cost?: number;
+	}) => void;
+	onSubagentToolResult: (toolCallId: string, toolName: string, success: boolean) => void;
+	onSubagentComplete: (toolCallId: string, success: boolean) => void;
+}
+
+/**
+ * Grounding: Source information for a grounded statement.
+ */
+export interface GroundingSource {
+	url: string;
+	title?: string;
+	/** Short excerpt copied from fetched content (human-readable). */
+	quote: string;
+	/** Text fragment for deep-linking (short verbatim phrase from source). */
+	textFragment: string;
+}
+
+/**
+ * Grounding: A single grounded statement with its source.
+ */
+export interface GroundedStatement {
+	id: string;
+	statement: string;
+	source: GroundingSource;
+}
+
+/**
+ * Grounding: A map of grounded statements for a single response.
+ */
+export interface GroundingMap {
+	id: string;
+	sessionId: string;
+	/** The DAEMON response message this map belongs to (or turn id). */
+	messageId: number;
+	createdAt: string;
+	items: GroundedStatement[];
+}

package/src/types/theme.ts

@@ -0,0 +1,52 @@
+/**
+ * Avatar and UI color themes for different daemon states.
+ */
+
+import { DaemonState } from "./index";
+import type { AvatarColorTheme } from "./index";
+
+/**
+ * Avatar color themes for each daemon state
+ */
+export const STATE_COLORS: Record<DaemonState, AvatarColorTheme> = {
+	[DaemonState.IDLE]: {
+		primary: 0x9ca3af, // Gray
+		glow: 0x67e8f9, // Cyan glow
+		eye: 0xff0000, // Red
+	},
+	[DaemonState.LISTENING]: {
+		primary: 0x22d3ee, // Bright cyan
+		glow: 0x67e8f9,
+		eye: 0x22d3ee,
+	},
+	[DaemonState.TRANSCRIBING]: {
+		primary: 0xa78bfa, // Purple
+		glow: 0xc4b5fd,
+		eye: 0xa78bfa,
+	},
+	[DaemonState.RESPONDING]: {
+		primary: 0x4ade80, // Green
+		glow: 0x86efac,
+		eye: 0x4ade80,
+	},
+	[DaemonState.SPEAKING]: {
+		primary: 0x22d3ee, // Cyan - voice output
+		glow: 0x67e8f9,
+		eye: 0x22d3ee,
+	},
+	[DaemonState.TYPING]: {
+		primary: 0x9ca3af,
+		glow: 0x67e8f9,
+		eye: 0xff0000,
+	},
+};
+
+/**
+ * Special color theme for reasoning phase (before speaking).
+ * Soft blue-gray - contemplative, calm, less aggressive.
+ */
+export const REASONING_COLORS: AvatarColorTheme = {
+	primary: 0x64748b, // Slate gray-blue
+	glow: 0x94a3b8, // Lighter slate
+	eye: 0x94a3b8, // Soft glow
+};

package/src/ui/constants.ts

@@ -0,0 +1,157 @@
+/**
+ * UI constants including colors, status text, and markdown syntax styles.
+ */
+
+import { SyntaxStyle, RGBA } from "@opentui/core";
+import { DaemonState } from "../types";
+
+// Status text displayed for each daemon state
+export const STATUS_TEXT: Record<DaemonState, string> = {
+	[DaemonState.IDLE]: "SPACE speak · SHIFT+TAB type · M models · S settings · L sessions · ? hotkeys",
+	[DaemonState.LISTENING]: "LISTENING · SPACE stop · ESC cancel",
+	[DaemonState.TRANSCRIBING]: "PROCESSING VOICE... · ESC cancel",
+	[DaemonState.RESPONDING]: "DAEMON SPEAKS... · ESC cancel · T reasoning",
+	[DaemonState.SPEAKING]: "DAEMON SPEAKS... · ESC stop",
+	[DaemonState.TYPING]: "TYPE MODE · ENTER submit · ESC cancel",
+};
+
+// Hex colors for status bar text per state
+export const STATE_COLOR_HEX: Record<DaemonState, string> = {
+	[DaemonState.IDLE]: "#9ca3af",
+	[DaemonState.LISTENING]: "#22d3ee",
+	[DaemonState.TRANSCRIBING]: "#a78bfa",
+	[DaemonState.RESPONDING]: "#4ade80",
+	[DaemonState.SPEAKING]: "#22d3ee",
+	[DaemonState.TYPING]: "#fbbf24",
+};
+
+// Animation settings for reasoning text ticker
+export const REASONING_ANIMATION = {
+	LINE_WIDTH: 120,
+	CHARS_PER_TICK: 6,
+	TICK_INTERVAL_MS: 16,
+	INTENSITY: 0.5,
+} as const;
+
+// UI colors
+export const COLORS = {
+	BACKGROUND: "#050509",
+	LISTENING_DIM: "#050509A8",
+	ERROR: "#ef4444",
+	DAEMON_ERROR: "#ef4444",
+	REASONING: "#a78bfa",
+	REASONING_DIM: "#525252",
+	TOOLS: "#3f4651",
+	TOOL_INPUT_BG: "#0a0a0f60",
+	TOOL_INPUT_BORDER: "#3f465180",
+	TOOL_INPUT_TEXT: "#9ca3af",
+	USER_LABEL: "#bfdbfe",
+	USER_TEXT: "#ffffff",
+	USER_BG: "#1e293b",
+	DAEMON_LABEL: "#22d3ee",
+	DAEMON_TEXT: "#4ade80",
+	TYPING_PROMPT: "#fbbf24",
+	EMPTY_STATE: "#374151",
+	MENU_BORDER: "#22d3ee",
+	MENU_BG: "#0a0a0f",
+	MENU_SELECTED_BG: "#1a1a2e",
+	MENU_TEXT: "#9ca3af",
+	TOKEN_USAGE: "#6b7280",
+	TOKEN_USAGE_LABEL: "#525252",
+	STATUS_BORDER: "#3f4651",
+	WORKING_SPINNER_BORDER: "#1e293b",
+
+	// General status colors (used across tool views, todos, subagent steps)
+	STATUS_RUNNING: "#fbbf24",
+	STATUS_COMPLETED: "#4ade80",
+	STATUS_FAILED: "#ef4444",
+	STATUS_PENDING: "#9ca3af",
+	STATUS_DONE_DIM: "#2d333d",
+	STATUS_APPROVAL: "#f472b6",
+} as const;
+
+// Markdown syntax style for daemon responses - alien/cultic aesthetic
+export const DAEMON_MARKDOWN_STYLE = SyntaxStyle.fromStyles({
+	// Default text inherits daemon green
+	default: { fg: RGBA.fromHex(COLORS.DAEMON_TEXT) },
+	// Headings - cyan hierarchy (daemon label color)
+	"markup.heading.1": { fg: RGBA.fromHex("#22d3ee"), bold: true },
+	"markup.heading.2": { fg: RGBA.fromHex("#06b6d4"), bold: true },
+	"markup.heading.3": { fg: RGBA.fromHex("#0891b2"), bold: true },
+	"markup.heading.4": { fg: RGBA.fromHex("#0e7490") },
+	"markup.heading.5": { fg: RGBA.fromHex("#155e75") },
+	"markup.heading.6": { fg: RGBA.fromHex("#164e63") },
+	// Emphasis
+	"markup.strong": { fg: RGBA.fromHex("#ffffff"), bold: true },
+	"markup.italic": { fg: RGBA.fromHex("#a78bfa"), italic: true },
+	"markup.strikethrough": { fg: RGBA.fromHex("#6b7280"), dim: true },
+	// Code - purple/violet (reasoning color)
+	"markup.raw": { fg: RGBA.fromHex("#c4b5fd") },
+	"markup.raw.block": { fg: RGBA.fromHex("#c4b5fd") },
+	// Links - cyan like daemon label
+	"markup.link": { fg: RGBA.fromHex("#22d3ee") },
+	"markup.link.url": { fg: RGBA.fromHex("#67e8f9"), underline: true },
+	"markup.link.label": { fg: RGBA.fromHex("#22d3ee") },
+	// Lists
+	"markup.list": { fg: RGBA.fromHex("#9ca3af") },
+	"markup.list.checked": { fg: RGBA.fromHex("#4ade80") },
+	"markup.list.unchecked": { fg: RGBA.fromHex("#6b7280") },
+	// Quotes - dimmed
+	"markup.quote": { fg: RGBA.fromHex("#9ca3af"), italic: true },
+	// Code block syntax highlighting
+	keyword: { fg: RGBA.fromHex("#f472b6") },
+	string: { fg: RGBA.fromHex("#a5d6ff") },
+	comment: { fg: RGBA.fromHex("#6b7280"), italic: true },
+	number: { fg: RGBA.fromHex("#fbbf24") },
+	function: { fg: RGBA.fromHex("#7dd3fc") },
+	type: { fg: RGBA.fromHex("#c4b5fd") },
+	variable: { fg: RGBA.fromHex("#4ade80") },
+	constant: { fg: RGBA.fromHex("#fbbf24") },
+	operator: { fg: RGBA.fromHex("#f472b6") },
+	punctuation: { fg: RGBA.fromHex("#9ca3af") },
+	"punctuation.special": { fg: RGBA.fromHex("#6b7280") },
+	label: { fg: RGBA.fromHex("#67e8f9") },
+});
+
+// Markdown syntax style for reasoning - dimmed/gray aesthetic
+export const REASONING_MARKDOWN_STYLE = SyntaxStyle.fromStyles({
+	// Default text inherits reasoning dim color
+	default: { fg: RGBA.fromHex(COLORS.REASONING_DIM) },
+	// Headings - slightly brighter
+	"markup.heading.1": { fg: RGBA.fromHex("#a3a3a3"), bold: true },
+	"markup.heading.2": { fg: RGBA.fromHex("#a3a3a3"), bold: true },
+	"markup.heading.3": { fg: RGBA.fromHex("#a3a3a3"), bold: true },
+	"markup.heading.4": { fg: RGBA.fromHex("#a3a3a3") },
+	"markup.heading.5": { fg: RGBA.fromHex("#a3a3a3") },
+	"markup.heading.6": { fg: RGBA.fromHex("#a3a3a3") },
+	// Emphasis
+	"markup.strong": { fg: RGBA.fromHex("#d4d4d4"), bold: true },
+	"markup.italic": { fg: RGBA.fromHex("#a78bfa"), italic: true }, // Keep purple for italic
+	"markup.strikethrough": { fg: RGBA.fromHex("#404040"), dim: true },
+	// Code - keep purple theme but distinct
+	"markup.raw": { fg: RGBA.fromHex("#8b5cf6") }, // Violet-500
+	"markup.raw.block": { fg: RGBA.fromHex("#8b5cf6") },
+	// Links
+	"markup.link": { fg: RGBA.fromHex("#0891b2") }, // Cyan-600
+	"markup.link.url": { fg: RGBA.fromHex("#0891b2"), underline: true },
+	"markup.link.label": { fg: RGBA.fromHex("#0891b2") },
+	// Lists
+	"markup.list": { fg: RGBA.fromHex("#525252") },
+	"markup.list.checked": { fg: RGBA.fromHex("#a3a3a3") },
+	"markup.list.unchecked": { fg: RGBA.fromHex("#525252") },
+	// Quotes
+	"markup.quote": { fg: RGBA.fromHex("#525252"), italic: true },
+	// Code block syntax highlighting - dimmed versions
+	keyword: { fg: RGBA.fromHex("#db2777") }, // Pink-600
+	string: { fg: RGBA.fromHex("#60a5fa") }, // Blue-400
+	comment: { fg: RGBA.fromHex("#404040"), italic: true },
+	number: { fg: RGBA.fromHex("#d97706") }, // Amber-600
+	function: { fg: RGBA.fromHex("#0ea5e9") }, // Sky-500
+	type: { fg: RGBA.fromHex("#8b5cf6") }, // Violet-500
+	variable: { fg: RGBA.fromHex("#22c55e") }, // Green-500
+	constant: { fg: RGBA.fromHex("#d97706") },
+	operator: { fg: RGBA.fromHex("#db2777") },
+	punctuation: { fg: RGBA.fromHex("#525252") },
+	"punctuation.special": { fg: RGBA.fromHex("#525252") },
+	label: { fg: RGBA.fromHex("#0891b2") },
+});

package/src/utils/clipboard.ts

@@ -0,0 +1,89 @@
+import { platform, release } from "os";
+
+async function readFromCommand(command: string, args: string[]): Promise<string> {
+	try {
+		const proc = Bun.spawn([command, ...args], {
+			stdout: "pipe",
+			stderr: "ignore",
+		});
+		const text = await new Response(proc.stdout).text();
+		await proc.exited;
+		return text;
+	} catch {
+		return "";
+	}
+}
+
+async function writeToCommand(command: string, args: string[], text: string): Promise<boolean> {
+	try {
+		const proc = Bun.spawn([command, ...args], {
+			stdin: "pipe",
+			stdout: "ignore",
+			stderr: "ignore",
+		});
+		proc.stdin.write(text);
+		proc.stdin.end();
+		const exitCode = await proc.exited;
+		return exitCode === 0;
+	} catch {
+		return false;
+	}
+}
+
+export async function readClipboardText(): Promise<string> {
+	const os = platform();
+
+	if (os === "darwin" && Bun.which("pbpaste")) {
+		return readFromCommand("pbpaste", []);
+	}
+
+	if (os === "win32" || release().includes("WSL")) {
+		return readFromCommand("powershell", ["-command", "Get-Clipboard -Raw"]);
+	}
+
+	if (os === "linux") {
+		if (process.env.WAYLAND_DISPLAY && Bun.which("wl-paste")) {
+			return readFromCommand("wl-paste", ["-n"]);
+		}
+		if (Bun.which("xclip")) {
+			return readFromCommand("xclip", ["-selection", "clipboard", "-o"]);
+		}
+		if (Bun.which("xsel")) {
+			return readFromCommand("xsel", ["--clipboard", "--output"]);
+		}
+	}
+
+	return "";
+}
+
+export async function writeClipboardText(text: string): Promise<boolean> {
+	if (!text) return false;
+
+	const os = platform();
+
+	if (os === "darwin" && Bun.which("pbcopy")) {
+		return writeToCommand("pbcopy", [], text);
+	}
+
+	if (os === "win32" || release().includes("WSL")) {
+		return writeToCommand(
+			"powershell",
+			["-command", "Set-Clipboard -Value ([Console]::In.ReadToEnd())"],
+			text
+		);
+	}
+
+	if (os === "linux") {
+		if (process.env.WAYLAND_DISPLAY && Bun.which("wl-copy")) {
+			return writeToCommand("wl-copy", [], text);
+		}
+		if (Bun.which("xclip")) {
+			return writeToCommand("xclip", ["-selection", "clipboard"], text);
+		}
+		if (Bun.which("xsel")) {
+			return writeToCommand("xsel", ["--clipboard", "--input"], text);
+		}
+	}
+
+	return false;
+}