@makefinks/daemon 0.1.0

package/src/utils/voice-dependencies.ts

@@ -0,0 +1,107 @@
+/**
+ * Voice dependencies detection.
+ * Detects whether sox is available for voice input/output.
+ */
+
+import { spawn } from "node:child_process";
+
+export interface VoiceCapability {
+	available: boolean;
+	reason: string;
+	hint?: string;
+}
+
+export interface VoiceDependencies {
+	sox: VoiceCapability;
+	/** Whether voice input (recording) is available */
+	canRecordAudio: boolean;
+	/** Whether voice output (TTS playback) is available */
+	canPlayAudio: boolean;
+}
+
+// Cache the detection result
+let cachedDependencies: VoiceDependencies | null = null;
+
+/**
+ * Check if a binary exists on PATH by attempting to run it.
+ */
+async function checkBinaryOnPath(binary: string): Promise<boolean> {
+	return new Promise((resolve) => {
+		const proc = spawn(binary, ["--version"], {
+			stdio: ["ignore", "ignore", "ignore"],
+		});
+
+		proc.on("error", () => resolve(false));
+		proc.on("close", (code) => resolve(code === 0));
+
+		// Timeout after 2 seconds
+		setTimeout(() => {
+			proc.kill();
+			resolve(false);
+		}, 2000);
+	});
+}
+
+/**
+ * Detect sox availability.
+ */
+async function detectSox(): Promise<VoiceCapability> {
+	const available = await checkBinaryOnPath("sox");
+
+	if (available) {
+		return {
+			available: true,
+			reason: "sox is installed.",
+		};
+	}
+
+	return {
+		available: false,
+		reason: "sox is not installed.",
+		hint: process.platform === "darwin" ? "Run: brew install sox" : "Install sox using your package manager.",
+	};
+}
+
+/**
+ * Detect all voice dependencies.
+ * Results are cached after first detection.
+ */
+export async function detectVoiceDependencies(): Promise<VoiceDependencies> {
+	if (cachedDependencies) {
+		return cachedDependencies;
+	}
+
+	const sox = await detectSox();
+
+	cachedDependencies = {
+		sox,
+		// Voice input requires sox for recording
+		canRecordAudio: sox.available,
+		// Voice output requires sox for playback
+		canPlayAudio: sox.available,
+	};
+
+	return cachedDependencies;
+}
+
+/**
+ * Get the cached voice dependencies (returns null if not yet detected).
+ */
+export function getCachedVoiceDependencies(): VoiceDependencies | null {
+	return cachedDependencies;
+}
+
+/**
+ * Clear the cached voice dependencies (useful for testing).
+ */
+export function clearVoiceDependenciesCache(): void {
+	cachedDependencies = null;
+}
+
+/**
+ * Synchronously check if sox is available.
+ * Uses cached result if available, otherwise returns false.
+ */
+export function isSoxAvailable(): boolean {
+	return cachedDependencies?.sox.available ?? false;
+}

package/src/utils/workspace-manager.ts

@@ -0,0 +1,85 @@
+/**
+ * Workspace manager for DAEMON sessions.
+ * Each session gets a persistent workspace directory for file operations,
+ * cloning repositories, and other agent tasks that shouldn't pollute
+ * the user's current working directory.
+ */
+
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { getAppConfigDir } from "./preferences";
+import { debug } from "./debug-logger";
+
+const WORKSPACES_DIR = "workspaces";
+
+/**
+ * Get the root directory for all session workspaces.
+ * @returns Path to ~/.config/daemon/workspaces/
+ */
+export function getWorkspacesRoot(): string {
+	return path.join(getAppConfigDir(), WORKSPACES_DIR);
+}
+
+/**
+ * Get the workspace path for a specific session.
+ * Does not create the directory - use ensureWorkspaceExists for that.
+ * @param sessionId - The session UUID
+ * @returns Path to ~/.config/daemon/workspaces/{sessionId}/
+ */
+export function getWorkspacePath(sessionId: string): string {
+	return path.join(getWorkspacesRoot(), sessionId);
+}
+
+/**
+ * Ensure the workspace directory exists for a session.
+ * Creates the directory if it doesn't exist.
+ * @param sessionId - The session UUID
+ * @returns The absolute path to the workspace directory
+ */
+export async function ensureWorkspaceExists(sessionId: string): Promise<string> {
+	const workspacePath = getWorkspacePath(sessionId);
+	try {
+		await fs.mkdir(workspacePath, { recursive: true });
+		debug.info("workspace-created", { sessionId, path: workspacePath });
+	} catch (error) {
+		// If directory already exists, that's fine
+		const err = error instanceof Error ? error : new Error(String(error));
+		if (!err.message.includes("EEXIST")) {
+			debug.error("workspace-create-failed", { sessionId, message: err.message });
+			throw err;
+		}
+	}
+	return workspacePath;
+}
+
+/**
+ * Delete the workspace directory for a session.
+ * Called when a session is deleted.
+ * @param sessionId - The session UUID
+ */
+export async function deleteWorkspace(sessionId: string): Promise<void> {
+	const workspacePath = getWorkspacePath(sessionId);
+	try {
+		await fs.rm(workspacePath, { recursive: true, force: true });
+		debug.info("workspace-deleted", { sessionId, path: workspacePath });
+	} catch (error) {
+		// Log but don't throw - cleanup failures shouldn't break session deletion
+		const err = error instanceof Error ? error : new Error(String(error));
+		debug.error("workspace-delete-failed", { sessionId, message: err.message });
+	}
+}
+
+/**
+ * Check if a workspace exists for a session.
+ * @param sessionId - The session UUID
+ * @returns true if the workspace directory exists
+ */
+export async function workspaceExists(sessionId: string): Promise<boolean> {
+	const workspacePath = getWorkspacePath(sessionId);
+	try {
+		const stat = await fs.stat(workspacePath);
+		return stat.isDirectory();
+	} catch {
+		return false;
+	}
+}