@tekmidian/pai 0.1.0

package/dist/daemon-v5O897D4.mjs

@@ -0,0 +1,773 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as openRegistry } from "./db-4lSqLFb8.mjs";
+import { r as indexAll } from "./indexer-B20bPHL-.mjs";
+import { t as configureEmbeddingModel } from "./embeddings-mfqv-jFu.mjs";
+import { a as toolProjectHealth, c as toolProjectTodo, d as toolSessionRoute, i as toolProjectDetect, l as toolRegistrySearch, n as toolMemorySearch, o as toolProjectInfo, s as toolProjectList, t as toolMemoryGet, u as toolSessionList } from "./tools-CLK4080-.mjs";
+import { n as CONFIG_FILE, s as DEFAULT_NOTIFICATION_CONFIG, t as CONFIG_DIR } from "./config-DBh1bYM2.mjs";
+import { t as createStorageBackend } from "./factory-BDAiKtYR.mjs";
+import { t as detectTopicShift } from "./detector-DKA83aTZ.mjs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { setPriority } from "node:os";
+import { randomUUID } from "node:crypto";
+import { connect, createServer } from "node:net";
+import { spawn } from "node:child_process";
+
+//#region src/notifications/config.ts
+/**
+* config.ts — Notification config persistence helpers
+*
+* Reads and writes the `notifications` section of ~/.config/pai/config.json.
+* Deep-merges with defaults so partial configs work fine.
+*
+* This module is intentionally separate from the daemon's config loader
+* so it can be used standalone (e.g. from CLI commands).
+*/
+function deepMerge(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const srcVal = source[key];
+		if (srcVal === void 0 || srcVal === null) continue;
+		const tgtVal = target[key];
+		if (typeof srcVal === "object" && !Array.isArray(srcVal) && typeof tgtVal === "object" && tgtVal !== null && !Array.isArray(tgtVal)) result[key] = deepMerge(tgtVal, srcVal);
+		else result[key] = srcVal;
+	}
+	return result;
+}
+/**
+* Load the notification config from the PAI config file.
+* Returns defaults merged with any stored values.
+*/
+function loadNotificationConfig() {
+	if (!existsSync(CONFIG_FILE)) return { ...DEFAULT_NOTIFICATION_CONFIG };
+	let raw;
+	try {
+		raw = readFileSync(CONFIG_FILE, "utf-8");
+	} catch {
+		return { ...DEFAULT_NOTIFICATION_CONFIG };
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return { ...DEFAULT_NOTIFICATION_CONFIG };
+	}
+	const stored = parsed["notifications"];
+	if (!stored || typeof stored !== "object") return { ...DEFAULT_NOTIFICATION_CONFIG };
+	return deepMerge(DEFAULT_NOTIFICATION_CONFIG, stored);
+}
+/**
+* Persist the notification config by merging it into the existing
+* ~/.config/pai/config.json. Creates the file if it does not exist.
+*/
+function saveNotificationConfig(config) {
+	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+	let full = {};
+	if (existsSync(CONFIG_FILE)) try {
+		full = JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
+	} catch {}
+	full["notifications"] = config;
+	writeFileSync(CONFIG_FILE, JSON.stringify(full, null, 2) + "\n", "utf-8");
+}
+/**
+* Apply a partial update to the current notification config and persist it.
+* Returns the new merged config.
+*/
+function patchNotificationConfig(patch) {
+	const current = loadNotificationConfig();
+	if (patch.mode !== void 0) current.mode = patch.mode;
+	if (patch.channels) current.channels = deepMerge(current.channels, patch.channels);
+	if (patch.routing) current.routing = deepMerge(current.routing, patch.routing);
+	saveNotificationConfig(current);
+	return current;
+}
+
+//#endregion
+//#region src/notifications/providers/ntfy.ts
+var NtfyProvider = class {
+	channelId = "ntfy";
+	async send(payload, config) {
+		const cfg = config.channels.ntfy;
+		if (!cfg.enabled || !cfg.url) return false;
+		try {
+			const headers = { "Content-Type": "text/plain; charset=utf-8" };
+			if (payload.title) headers["Title"] = payload.title;
+			if (cfg.priority && cfg.priority !== "default") headers["Priority"] = cfg.priority;
+			return (await fetch(cfg.url, {
+				method: "POST",
+				headers,
+				body: payload.message
+			})).ok;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region src/notifications/providers/whatsapp.ts
+/**
+* whatsapp.ts — WhatsApp notification provider (via Whazaa MCP)
+*
+* Sends notifications via the Whazaa Unix Domain Socket IPC protocol.
+* Falls back gracefully if Whazaa is not running.
+*
+* Whazaa IPC socket: /tmp/whazaa.sock (standard Whazaa path)
+*
+* We use the same connect-per-call pattern as PaiClient to avoid
+* requiring any persistent connection state.
+*/
+const WHAZAA_SOCKET = "/tmp/whazaa.sock";
+const WHAZAA_TIMEOUT_MS = 1e4;
+/**
+* Send a single IPC call to the Whazaa socket.
+* Returns true on success, false if Whazaa is not available or errors.
+*/
+function callWhazaa(method, params) {
+	return new Promise((resolve) => {
+		let done = false;
+		let buffer = "";
+		let timer = null;
+		function finish(ok) {
+			if (done) return;
+			done = true;
+			if (timer) {
+				clearTimeout(timer);
+				timer = null;
+			}
+			try {
+				socket?.destroy();
+			} catch {}
+			resolve(ok);
+		}
+		const socket = connect(WHAZAA_SOCKET, () => {
+			const request = {
+				jsonrpc: "2.0",
+				id: randomUUID(),
+				method,
+				params
+			};
+			socket.write(JSON.stringify(request) + "\n");
+		});
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString();
+			const nl = buffer.indexOf("\n");
+			if (nl === -1) return;
+			try {
+				finish(!JSON.parse(buffer.slice(0, nl)).error);
+			} catch {
+				finish(false);
+			}
+		});
+		socket.on("error", () => finish(false));
+		socket.on("end", () => finish(false));
+		timer = setTimeout(() => finish(false), WHAZAA_TIMEOUT_MS);
+	});
+}
+var WhatsAppProvider = class {
+	channelId = "whatsapp";
+	async send(payload, config) {
+		const cfg = config.channels.whatsapp;
+		if (!cfg.enabled) return false;
+		const isVoiceMode = config.mode === "voice" || config.channels.voice.enabled;
+		const params = { message: payload.message };
+		if (cfg.recipient) params.recipient = cfg.recipient;
+		if (isVoiceMode && config.mode === "voice") params.voice = config.channels.voice.voiceName ?? "bm_george";
+		return callWhazaa("whatsapp_send", params);
+	}
+};
+
+//#endregion
+//#region src/notifications/providers/macos.ts
+/**
+* macos.ts — macOS notification provider
+*
+* Uses the `osascript` command to display a macOS system notification.
+* Non-blocking: spawns the process and returns success without waiting.
+*/
+var MacOsProvider = class {
+	channelId = "macos";
+	async send(payload, config) {
+		if (!config.channels.macos.enabled) return false;
+		try {
+			const safeTitle = (payload.title ?? "PAI").replace(/'/g, "\\'");
+			const script = `display notification "${payload.message.replace(/'/g, "\\'")}" with title "${safeTitle}"`;
+			return new Promise((resolve) => {
+				const child = spawn("osascript", ["-e", script], {
+					detached: true,
+					stdio: "ignore"
+				});
+				child.unref();
+				child.on("error", () => resolve(false));
+				setTimeout(() => resolve(true), 200);
+			});
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+//#region src/notifications/providers/cli.ts
+var CliProvider = class {
+	channelId = "cli";
+	async send(payload, _config) {
+		const prefix = `[pai-notify:${payload.event}]`;
+		const title = payload.title ? ` ${payload.title}:` : "";
+		process.stderr.write(`${prefix}${title} ${payload.message}\n`);
+		return true;
+	}
+};
+
+//#endregion
+//#region src/notifications/router.ts
+const PROVIDERS = {
+	ntfy: new NtfyProvider(),
+	whatsapp: new WhatsAppProvider(),
+	macos: new MacOsProvider(),
+	voice: new WhatsAppProvider(),
+	cli: new CliProvider()
+};
+/**
+* Given the current config, resolve which channels should receive a
+* notification for the given event type.
+*
+* Mode overrides:
+*   "off"       → no channels
+*   "auto"      → use routing table, filtered by enabled channels
+*   "voice"     → whatsapp (TTS enabled in provider)
+*   "whatsapp"  → whatsapp
+*   "ntfy"      → ntfy
+*   "macos"     → macos
+*   "cli"       → cli
+*/
+function resolveChannels(config, event) {
+	const { mode, channels, routing } = config;
+	if (mode === "off") return [];
+	const modeToChannel = {
+		voice: "whatsapp",
+		whatsapp: "whatsapp",
+		ntfy: "ntfy",
+		macos: "macos",
+		cli: "cli"
+	};
+	if (mode !== "auto") {
+		const ch = modeToChannel[mode];
+		if (!ch) return [];
+		const cfg = channels[ch];
+		if (cfg && !cfg.enabled) return [ch];
+		return [ch];
+	}
+	return (routing[event] ?? []).filter((ch) => {
+		const cfg = channels[ch];
+		if (ch === "voice") return false;
+		return cfg?.enabled === true;
+	});
+}
+/**
+* Route a notification to the appropriate channels.
+*
+* Sends to all resolved channels in parallel.
+* Individual channel failures are non-fatal and logged to stderr.
+*
+* @param payload  The notification to send
+* @param config   The current notification config (from daemon state)
+*/
+async function routeNotification(payload, config) {
+	const channels = resolveChannels(config, payload.event);
+	if (channels.length === 0) return {
+		channelsAttempted: [],
+		channelsSucceeded: [],
+		channelsFailed: [],
+		mode: config.mode
+	};
+	const results = await Promise.allSettled(channels.map(async (ch) => {
+		const ok = await PROVIDERS[ch].send(payload, config);
+		if (!ok) process.stderr.write(`[pai-notify] Channel ${ch} failed for event ${payload.event}\n`);
+		return {
+			ch,
+			ok
+		};
+	}));
+	const succeeded = [];
+	const failed = [];
+	for (const r of results) if (r.status === "fulfilled") if (r.value.ok) succeeded.push(r.value.ch);
+	else failed.push(r.value.ch);
+	else failed.push(channels[results.indexOf(r)]);
+	return {
+		channelsAttempted: channels,
+		channelsSucceeded: succeeded,
+		channelsFailed: failed,
+		mode: config.mode
+	};
+}
+
+//#endregion
+//#region src/daemon/daemon.ts
+/**
+* daemon.ts — The persistent PAI Daemon
+*
+* Provides shared database access, tool dispatch, and periodic index scheduling
+* for multiple concurrent Claude Code sessions via a Unix Domain Socket.
+*
+* Architecture:
+*   MCP shims (Claude sessions) → Unix socket → PAI Daemon
+*                                                   ├── registry.db (shared, WAL, always SQLite)
+*                                                   ├── federation (SQLite or Postgres/pgvector)
+*                                                   ├── Embedding model (singleton)
+*                                                   └── Index scheduler (periodic)
+*
+* IPC protocol: NDJSON over Unix Domain Socket
+*
+* Request  (shim → daemon):
+*   { "id": "uuid", "method": "tool_name_or_special", "params": {} }
+*
+* Response (daemon → shim):
+*   { "id": "uuid", "ok": true, "result": <any> }
+*   { "id": "uuid", "ok": false, "error": "message" }
+*
+* Special methods:
+*   status     — Return daemon status (uptime, index state, db stats)
+*   index_now  — Trigger immediate index run (non-blocking)
+*
+* All other methods are dispatched to the corresponding PAI tool function.
+*
+* Design notes:
+* - Registry stays in SQLite (small, simple metadata).
+* - Federation backend is configurable: SQLite (default) or Postgres/pgvector.
+* - Auto-fallback: if Postgres is configured but unavailable, falls back to SQLite.
+* - Index writes guarded by indexInProgress flag (not a mutex — index is idempotent).
+* - Embedding model loaded lazily on first semantic/hybrid request, then kept alive.
+* - Scheduler runs indexAll() every indexIntervalSecs (default 5 minutes).
+*/
+var daemon_exports = /* @__PURE__ */ __exportAll({ serve: () => serve });
+let registryDb;
+let storageBackend;
+let daemonConfig;
+let startTime = Date.now();
+let indexInProgress = false;
+let lastIndexTime = 0;
+let indexSchedulerTimer = null;
+let embedInProgress = false;
+let lastEmbedTime = 0;
+let embedSchedulerTimer = null;
+/** Mutable notification config — loaded from disk at startup, patchable at runtime */
+let notificationConfig;
+/**
+* Set to true when a SIGTERM/SIGINT is received so that long-running loops
+* (embed, index) can detect the signal and exit their inner loops before the
+* pool/backend is closed.  Checked by embedChunksWithBackend() via the
+* `shouldStop` callback passed from runEmbed().
+*/
+let shutdownRequested = false;
+/**
+* Run a full index pass. Guards against overlapping runs with indexInProgress.
+* Called both by the scheduler and by the index_now IPC method.
+*
+* NOTE: We pass the raw SQLite federation DB to indexAll() for SQLite backend,
+* or skip and use the backend interface for Postgres.  The indexer currently
+* uses better-sqlite3 directly; it will be refactored in a future phase.
+* For now, we keep the SQLite indexer path and add a Postgres-aware path.
+*/
+async function runIndex() {
+	if (indexInProgress) {
+		process.stderr.write("[pai-daemon] Index already in progress, skipping.\n");
+		return;
+	}
+	if (embedInProgress) {
+		process.stderr.write("[pai-daemon] Embed in progress, deferring index run.\n");
+		return;
+	}
+	indexInProgress = true;
+	const t0 = Date.now();
+	try {
+		process.stderr.write("[pai-daemon] Starting scheduled index run...\n");
+		if (storageBackend.backendType === "sqlite") {
+			const { SQLiteBackend } = await import("./sqlite-CHUrNtbI.mjs");
+			if (storageBackend instanceof SQLiteBackend) {
+				const { projects, result } = await indexAll(storageBackend.getRawDb(), registryDb);
+				const elapsed = Date.now() - t0;
+				lastIndexTime = Date.now();
+				process.stderr.write(`[pai-daemon] Index complete: ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
+			}
+		} else {
+			const { indexAllWithBackend } = await import("./indexer-backend-BXaocO5r.mjs");
+			const { projects, result } = await indexAllWithBackend(storageBackend, registryDb);
+			const elapsed = Date.now() - t0;
+			lastIndexTime = Date.now();
+			process.stderr.write(`[pai-daemon] Index complete (postgres): ${projects} projects, ${result.filesProcessed} files, ${result.chunksCreated} chunks (${elapsed}ms)\n`);
+		}
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Index error: ${msg}\n`);
+	} finally {
+		indexInProgress = false;
+	}
+}
+/**
+* Start the periodic index scheduler.
+*/
+function startIndexScheduler() {
+	const intervalMs = daemonConfig.indexIntervalSecs * 1e3;
+	process.stderr.write(`[pai-daemon] Index scheduler: every ${daemonConfig.indexIntervalSecs}s\n`);
+	setTimeout(() => {
+		runIndex().catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup index error: ${e}\n`);
+		});
+	}, 2e3);
+	indexSchedulerTimer = setInterval(() => {
+		runIndex().catch((e) => {
+			process.stderr.write(`[pai-daemon] Scheduled index error: ${e}\n`);
+		});
+	}, intervalMs);
+	if (indexSchedulerTimer.unref) indexSchedulerTimer.unref();
+}
+/**
+* Run an embedding pass for all unembedded chunks (Postgres backend only).
+* Guards against overlapping runs with embedInProgress.
+* Skips if an index run is currently in progress to avoid contention.
+*/
+async function runEmbed() {
+	if (embedInProgress) {
+		process.stderr.write("[pai-daemon] Embed already in progress, skipping.\n");
+		return;
+	}
+	if (indexInProgress) {
+		process.stderr.write("[pai-daemon] Index in progress, deferring embed pass.\n");
+		return;
+	}
+	if (storageBackend.backendType !== "postgres") return;
+	embedInProgress = true;
+	const t0 = Date.now();
+	try {
+		process.stderr.write("[pai-daemon] Starting scheduled embed pass...\n");
+		const { embedChunksWithBackend } = await import("./indexer-backend-BXaocO5r.mjs");
+		const count = await embedChunksWithBackend(storageBackend, () => shutdownRequested);
+		const elapsed = Date.now() - t0;
+		lastEmbedTime = Date.now();
+		process.stderr.write(`[pai-daemon] Embed pass complete: ${count} chunks embedded (${elapsed}ms)\n`);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Embed error: ${msg}\n`);
+	} finally {
+		embedInProgress = false;
+	}
+}
+/**
+* Start the periodic embed scheduler.
+* Initial run is 30 seconds after startup (after the 2-second index startup run).
+*/
+function startEmbedScheduler() {
+	const intervalMs = daemonConfig.embedIntervalSecs * 1e3;
+	process.stderr.write(`[pai-daemon] Embed scheduler: every ${daemonConfig.embedIntervalSecs}s\n`);
+	setTimeout(() => {
+		runEmbed().catch((e) => {
+			process.stderr.write(`[pai-daemon] Startup embed error: ${e}\n`);
+		});
+	}, 3e4);
+	embedSchedulerTimer = setInterval(() => {
+		runEmbed().catch((e) => {
+			process.stderr.write(`[pai-daemon] Scheduled embed error: ${e}\n`);
+		});
+	}, intervalMs);
+	if (embedSchedulerTimer.unref) embedSchedulerTimer.unref();
+}
+/**
+* Dispatch an IPC tool call to the appropriate tool function.
+* Returns the tool result or throws.
+*/
+async function dispatchTool(method, params) {
+	const p = params;
+	switch (method) {
+		case "memory_search": return toolMemorySearch(registryDb, storageBackend, p);
+		case "memory_get": return toolMemoryGet(registryDb, p);
+		case "project_info": return toolProjectInfo(registryDb, p);
+		case "project_list": return toolProjectList(registryDb, p);
+		case "session_list": return toolSessionList(registryDb, p);
+		case "registry_search": return toolRegistrySearch(registryDb, p);
+		case "project_detect": return toolProjectDetect(registryDb, p);
+		case "project_health": return toolProjectHealth(registryDb, p);
+		case "project_todo": return toolProjectTodo(registryDb, p);
+		case "topic_check": return detectTopicShift(registryDb, storageBackend, p);
+		case "session_auto_route": return toolSessionRoute(registryDb, storageBackend, p);
+		default: throw new Error(`Unknown method: ${method}`);
+	}
+}
+function sendResponse(socket, response) {
+	try {
+		socket.write(JSON.stringify(response) + "\n");
+	} catch {}
+}
+/**
+* Handle a single IPC request.
+*/
+async function handleRequest(request, socket) {
+	const { id, method, params } = request;
+	if (method === "status") {
+		const dbStats = await (async () => {
+			try {
+				const fedStats = await storageBackend.getStats();
+				const projects = registryDb.prepare("SELECT COUNT(*) AS n FROM projects").get().n;
+				return {
+					files: fedStats.files,
+					chunks: fedStats.chunks,
+					projects
+				};
+			} catch {
+				return null;
+			}
+		})();
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: {
+				uptime: Math.floor((Date.now() - startTime) / 1e3),
+				indexInProgress,
+				lastIndexTime: lastIndexTime ? new Date(lastIndexTime).toISOString() : null,
+				indexIntervalSecs: daemonConfig.indexIntervalSecs,
+				embedInProgress,
+				lastEmbedTime: lastEmbedTime ? new Date(lastEmbedTime).toISOString() : null,
+				embedIntervalSecs: daemonConfig.embedIntervalSecs,
+				socketPath: daemonConfig.socketPath,
+				storageBackend: storageBackend.backendType,
+				db: dbStats
+			}
+		});
+		socket.end();
+		return;
+	}
+	if (method === "index_now") {
+		runIndex().catch((e) => {
+			process.stderr.write(`[pai-daemon] index_now error: ${e}\n`);
+		});
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: { triggered: true }
+		});
+		socket.end();
+		return;
+	}
+	if (method === "notification_get_config") {
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: {
+				config: notificationConfig,
+				activeChannels: Object.entries(notificationConfig.channels).filter(([ch, cfg]) => ch !== "voice" && cfg.enabled).map(([ch]) => ch)
+			}
+		});
+		socket.end();
+		return;
+	}
+	if (method === "notification_set_config") {
+		try {
+			const p = params;
+			notificationConfig = patchNotificationConfig({
+				mode: p.mode,
+				channels: p.channels,
+				routing: p.routing
+			});
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result: { config: notificationConfig }
+			});
+		} catch (e) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+		}
+		socket.end();
+		return;
+	}
+	if (method === "notification_send") {
+		const p = params;
+		if (!p.message) {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: "notification_send: message is required"
+			});
+			socket.end();
+			return;
+		}
+		routeNotification({
+			event: p.event ?? "info",
+			message: p.message,
+			title: p.title
+		}, notificationConfig).then((result) => {
+			sendResponse(socket, {
+				id,
+				ok: true,
+				result
+			});
+			socket.end();
+		}).catch((e) => {
+			sendResponse(socket, {
+				id,
+				ok: false,
+				error: e instanceof Error ? e.message : String(e)
+			});
+			socket.end();
+		});
+		return;
+	}
+	try {
+		sendResponse(socket, {
+			id,
+			ok: true,
+			result: await dispatchTool(method, params)
+		});
+	} catch (e) {
+		sendResponse(socket, {
+			id,
+			ok: false,
+			error: e instanceof Error ? e.message : String(e)
+		});
+	}
+	socket.end();
+}
+/**
+* Check whether an existing socket file is actually being served by a live process.
+* Returns true if a daemon is already accepting connections, false otherwise.
+*/
+function isSocketLive(path) {
+	return new Promise((resolve) => {
+		const client = connect(path);
+		const timer = setTimeout(() => {
+			client.destroy();
+			resolve(false);
+		}, 500);
+		client.on("connect", () => {
+			clearTimeout(timer);
+			client.end();
+			resolve(true);
+		});
+		client.on("error", () => {
+			clearTimeout(timer);
+			resolve(false);
+		});
+	});
+}
+/**
+* Start the Unix Domain Socket IPC server.
+*/
+async function startIpcServer(socketPath) {
+	if (existsSync(socketPath)) {
+		if (await isSocketLive(socketPath)) throw new Error("Another daemon is already running — socket is live. Aborting startup.");
+		try {
+			unlinkSync(socketPath);
+			process.stderr.write("[pai-daemon] Removed stale socket file.\n");
+		} catch {}
+	}
+	const server = createServer((socket) => {
+		let buffer = "";
+		socket.on("data", (chunk) => {
+			buffer += chunk.toString();
+			let nl;
+			while ((nl = buffer.indexOf("\n")) !== -1) {
+				const line = buffer.slice(0, nl);
+				buffer = buffer.slice(nl + 1);
+				if (line.trim() === "") continue;
+				let request;
+				try {
+					request = JSON.parse(line);
+				} catch {
+					sendResponse(socket, {
+						id: "?",
+						ok: false,
+						error: "Invalid JSON"
+					});
+					socket.destroy();
+					return;
+				}
+				handleRequest(request, socket).catch((e) => {
+					const msg = e instanceof Error ? e.message : String(e);
+					sendResponse(socket, {
+						id: request.id,
+						ok: false,
+						error: msg
+					});
+					socket.destroy();
+				});
+			}
+		});
+		socket.on("error", () => {});
+	});
+	server.on("error", (e) => {
+		process.stderr.write(`[pai-daemon] IPC server error: ${e}\n`);
+	});
+	server.listen(socketPath, () => {
+		process.stderr.write(`[pai-daemon] IPC server listening on ${socketPath}\n`);
+	});
+	return server;
+}
+async function serve(config) {
+	daemonConfig = config;
+	startTime = Date.now();
+	notificationConfig = loadNotificationConfig();
+	process.stderr.write("[pai-daemon] Starting daemon...\n");
+	process.stderr.write(`[pai-daemon] Socket: ${config.socketPath}\n`);
+	process.stderr.write(`[pai-daemon] Storage backend: ${config.storageBackend}\n`);
+	process.stderr.write(`[pai-daemon] Notification mode: ${notificationConfig.mode}\n`);
+	try {
+		setPriority(process.pid, 10);
+	} catch {}
+	configureEmbeddingModel(config.embeddingModel);
+	try {
+		registryDb = openRegistry();
+		process.stderr.write("[pai-daemon] Registry database opened.\n");
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Fatal: Could not open registry: ${msg}\n`);
+		process.exit(1);
+	}
+	try {
+		storageBackend = await createStorageBackend(config);
+		process.stderr.write(`[pai-daemon] Federation backend: ${storageBackend.backendType}\n`);
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		process.stderr.write(`[pai-daemon] Fatal: Could not open federation storage: ${msg}\n`);
+		process.exit(1);
+	}
+	startIndexScheduler();
+	if (storageBackend.backendType === "postgres") startEmbedScheduler();
+	else process.stderr.write("[pai-daemon] Embed scheduler: disabled (SQLite backend)\n");
+	const server = await startIpcServer(config.socketPath);
+	const shutdown = async (signal) => {
+		process.stderr.write(`\n[pai-daemon] ${signal} received. Stopping.\n`);
+		shutdownRequested = true;
+		if (indexSchedulerTimer) clearInterval(indexSchedulerTimer);
+		if (embedSchedulerTimer) clearInterval(embedSchedulerTimer);
+		server.close();
+		const SHUTDOWN_TIMEOUT_MS = 1e4;
+		const POLL_INTERVAL_MS = 100;
+		const deadline = Date.now() + SHUTDOWN_TIMEOUT_MS;
+		if (indexInProgress || embedInProgress) {
+			process.stderr.write(`[pai-daemon] Waiting for in-progress operations to finish (index=${indexInProgress}, embed=${embedInProgress})...\n`);
+			while ((indexInProgress || embedInProgress) && Date.now() < deadline) await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+			if (indexInProgress || embedInProgress) process.stderr.write("[pai-daemon] Shutdown timeout reached — forcing exit.\n");
+			else process.stderr.write("[pai-daemon] In-progress operations finished.\n");
+		}
+		try {
+			await storageBackend.close();
+		} catch {}
+		try {
+			unlinkSync(config.socketPath);
+		} catch {}
+		process.exit(0);
+	};
+	process.on("SIGINT", () => {
+		shutdown("SIGINT").catch(() => process.exit(0));
+	});
+	process.on("SIGTERM", () => {
+		shutdown("SIGTERM").catch(() => process.exit(0));
+	});
+	await new Promise(() => {});
+}
+
+//#endregion
+export { serve as n, daemon_exports as t };
+//# sourceMappingURL=daemon-v5O897D4.mjs.map