khal-os 1.260324.2

package/src/lib/nats-client.ts

@@ -0,0 +1,255 @@
+'use client';
+
+type MessageCallback = (data: unknown, subject: string) => void;
+type StatusCallback = (connected: boolean) => void;
+
+interface PendingRequest {
+	resolve: (data: unknown) => void;
+	reject: (error: Error) => void;
+	timer: ReturnType<typeof setTimeout>;
+}
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
+const MAX_RECONNECT_DELAY_MS = 30_000;
+
+/**
+ * Match a concrete NATS subject against a subscription pattern.
+ *  - `*` matches exactly one token
+ *  - `>` (must be last token) matches one or more tokens
+ *  - everything else is a literal match
+ */
+function subjectMatches(pattern: string, subject: string): boolean {
+	if (pattern === subject) return true;
+
+	const patParts = pattern.split('.');
+	const subParts = subject.split('.');
+
+	for (let i = 0; i < patParts.length; i++) {
+		const p = patParts[i];
+		if (p === '>') return i === patParts.length - 1 && subParts.length > i;
+		if (i >= subParts.length) return false;
+		if (p !== '*' && p !== subParts[i]) return false;
+	}
+
+	return patParts.length === subParts.length;
+}
+
+class NatsClient {
+	private ws: WebSocket | null = null;
+	private _connected = false;
+
+	// subject -> Set of callbacks (refcounted)
+	private subscribers = new Map<string, Set<MessageCallback>>();
+
+	// correlation id -> pending request
+	private pendingRequests = new Map<string, PendingRequest>();
+
+	// status change listeners
+	private statusListeners = new Set<StatusCallback>();
+
+	// reconnect state
+	private reconnectAttempt = 0;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private intentionallyClosed = false;
+
+	// Identity scoping
+	private _orgId = '';
+	private _userId = '';
+
+	constructor() {
+		this.connect();
+	}
+
+	// --- Public API ---
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	get orgId(): string {
+		return this._orgId;
+	}
+
+	get userId(): string {
+		return this._userId;
+	}
+
+	setOrgId(orgId: string): void {
+		this._orgId = orgId;
+	}
+
+	setUserId(userId: string): void {
+		this._userId = userId;
+	}
+
+	onStatusChange(callback: StatusCallback): () => void {
+		this.statusListeners.add(callback);
+		return () => {
+			this.statusListeners.delete(callback);
+		};
+	}
+
+	subscribe(subject: string, callback: MessageCallback): () => void {
+		let callbacks = this.subscribers.get(subject);
+		if (!callbacks) {
+			callbacks = new Set();
+			this.subscribers.set(subject, callbacks);
+			// First subscriber for this subject: send sub frame
+			this.send({ op: 'sub', subject });
+		}
+		callbacks.add(callback);
+
+		// Return unsubscribe function
+		return () => {
+			const cbs = this.subscribers.get(subject);
+			if (!cbs) return;
+			cbs.delete(callback);
+			if (cbs.size === 0) {
+				this.subscribers.delete(subject);
+				// Last subscriber removed: send unsub frame
+				this.send({ op: 'unsub', subject });
+			}
+		};
+	}
+
+	publish(subject: string, data?: unknown): void {
+		this.send({ op: 'pub', subject, data });
+	}
+
+	request(subject: string, data?: unknown, timeoutMs?: number): Promise<unknown> {
+		const id = crypto.randomUUID();
+		const timeout = timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+
+		return new Promise<unknown>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pendingRequests.delete(id);
+				reject(new Error(`request to "${subject}" timed out after ${timeout}ms`));
+			}, timeout);
+
+			this.pendingRequests.set(id, { resolve, reject, timer });
+			this.send({ op: 'req', id, subject, data });
+		});
+	}
+
+	// --- Connection management ---
+
+	private connect(): void {
+		if (typeof window === 'undefined') return;
+
+		const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+		const url = `${wsProtocol}//${window.location.host}/ws/nats`;
+
+		const ws = new WebSocket(url);
+		this.ws = ws;
+
+		ws.addEventListener('open', () => {
+			this.reconnectAttempt = 0;
+			this.setConnected(true);
+			// Re-subscribe all active subjects
+			for (const subject of this.subscribers.keys()) {
+				this.send({ op: 'sub', subject });
+			}
+		});
+
+		ws.addEventListener('message', (event) => {
+			this.handleMessage(event.data);
+		});
+
+		ws.addEventListener('close', () => {
+			this.setConnected(false);
+			this.ws = null;
+			if (!this.intentionallyClosed) {
+				this.scheduleReconnect();
+			}
+		});
+
+		ws.addEventListener('error', () => {
+			// The close event will fire after error, so reconnect is handled there.
+		});
+	}
+
+	private handleMessage(raw: string | ArrayBuffer | Blob): void {
+		if (typeof raw !== 'string') return;
+
+		let frame: Record<string, unknown>;
+		try {
+			frame = JSON.parse(raw);
+		} catch {
+			return;
+		}
+
+		if ('error' in frame) {
+			this.handleErrorFrame(frame);
+		} else if ('id' in frame && typeof frame.id === 'string') {
+			this.handleReplyFrame(frame.id, frame.data);
+		} else if ('subject' in frame && typeof frame.subject === 'string') {
+			this.handleMsgFrame(frame.subject, frame.data);
+		}
+	}
+
+	private handleErrorFrame(frame: Record<string, unknown>): void {
+		// biome-ignore lint/suspicious/noConsole: client-side debug logging for NATS errors
+		console.warn('[nats-client] server error:', frame.error);
+	}
+
+	private handleReplyFrame(id: string, data: unknown): void {
+		const pending = this.pendingRequests.get(id);
+		if (!pending) return;
+		clearTimeout(pending.timer);
+		this.pendingRequests.delete(id);
+		pending.resolve(data);
+	}
+
+	private handleMsgFrame(subject: string, data: unknown): void {
+		for (const [pattern, callbacks] of this.subscribers) {
+			if (!subjectMatches(pattern, subject)) continue;
+			for (const cb of callbacks) {
+				try {
+					cb(data, subject);
+				} catch {
+					// Subscriber callback threw; ignore to protect other subscribers.
+				}
+			}
+		}
+	}
+
+	private send(frame: Record<string, unknown>): void {
+		if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+			this.ws.send(JSON.stringify(frame));
+		}
+	}
+
+	private setConnected(value: boolean): void {
+		if (this._connected === value) return;
+		this._connected = value;
+		for (const listener of this.statusListeners) {
+			try {
+				listener(value);
+			} catch {
+				// Protect against listener errors.
+			}
+		}
+	}
+
+	private scheduleReconnect(): void {
+		if (this.reconnectTimer) return;
+
+		const delay = Math.min(1000 * 2 ** this.reconnectAttempt, MAX_RECONNECT_DELAY_MS);
+		this.reconnectAttempt++;
+
+		this.reconnectTimer = setTimeout(() => {
+			this.reconnectTimer = null;
+			this.connect();
+		}, delay);
+	}
+}
+
+// Singleton
+let instance: NatsClient | null = null;
+
+export function getNatsClient(): NatsClient {
+	if (!instance) {
+		instance = new NatsClient();
+	}
+	return instance;
+}

package/src/lib/nats.ts

@@ -0,0 +1,35 @@
+import { connect, type NatsConnection } from '@nats-io/transport-node';
+
+let connection: NatsConnection | null = null;
+let connecting: Promise<NatsConnection> | null = null;
+
+export async function getNatsConnection(): Promise<NatsConnection> {
+	if (connection && !connection.isClosed()) {
+		return connection;
+	}
+
+	if (connecting) {
+		return connecting;
+	}
+
+	connecting = (async () => {
+		const nc = await connect({
+			servers: process.env.NATS_URL || 'nats://localhost:4222',
+			maxReconnectAttempts: -1,
+			reconnectTimeWait: 2000,
+		});
+
+		nc.closed().then((err) => {
+			connection = null;
+			if (err) {
+				console.error('[nats] connection closed with error:', err.message);
+			}
+		});
+
+		connection = nc;
+		connecting = null;
+		return nc;
+	})();
+
+	return connecting;
+}

package/src/lib/notifications/schema.ts

@@ -0,0 +1,12 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+export const NatsNotification = Type.Object({
+	summary: Type.String(),
+	body: Type.Optional(Type.String()),
+	appName: Type.Optional(Type.String()),
+	icon: Type.Optional(Type.String()),
+	urgency: Type.Optional(Type.Union([Type.Literal('low'), Type.Literal('normal'), Type.Literal('critical')])),
+	category: Type.Optional(Type.String()),
+	transient: Type.Optional(Type.Boolean()),
+});
+export type NatsNotification = Static<typeof NatsNotification>;

package/src/lib/service-loader.ts

@@ -0,0 +1,171 @@
+// @ts-nocheck
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { relative, resolve } from 'node:path';
+import { ensureO11yStreams } from '@genie-os/sdk/service/o11y-streams';
+import { connect } from '@nats-io/transport-node';
+
+const ROOT = resolve(import.meta.dir, '../components/apps');
+const MAX_RETRIES = 5;
+const RETRY_DELAY_MS = 2000;
+const HEALTH_INTERVAL_MS = 30_000;
+
+interface ManagedService {
+	name: string;
+	path: string;
+	runtime: 'bun' | 'node';
+	process: ReturnType<typeof Bun.spawn> | null;
+	retries: number;
+	running: boolean;
+}
+
+function discoverServices(): ManagedService[] {
+	const services: ManagedService[] = [];
+
+	if (!existsSync(ROOT)) {
+		console.warn('[service-loader] apps directory not found:', ROOT);
+		return services;
+	}
+
+	const entries = readdirSync(ROOT, { withFileTypes: true });
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const servicePath = resolve(ROOT, entry.name, 'service', 'index.ts');
+		if (existsSync(servicePath)) {
+			// Check for runtime marker (e.g. service/runtime containing "node")
+			const runtimeFile = resolve(ROOT, entry.name, 'service', 'runtime');
+			let runtime: 'bun' | 'node' = 'bun';
+			if (existsSync(runtimeFile)) {
+				const content = readFileSync(runtimeFile, 'utf8').trim();
+				if (content === 'node') runtime = 'node';
+			}
+
+			services.push({
+				name: entry.name,
+				path: servicePath,
+				runtime,
+				process: null,
+				retries: 0,
+				running: false,
+			});
+		}
+	}
+
+	return services;
+}
+
+function spawnService(service: ManagedService): void {
+	const relPath = relative(process.cwd(), service.path);
+	const runtimeLabel = service.runtime === 'node' ? 'node/tsx' : 'bun';
+	console.log(`[service-loader] starting ${service.name} (${relPath}) [${runtimeLabel}]`);
+
+	// node-pty and other native addons may not work under Bun;
+	// services can opt into Node via a `service/runtime` file containing "node"
+	const cmd = service.runtime === 'node' ? ['npx', 'tsx', service.path] : ['bun', 'run', service.path];
+
+	const proc = Bun.spawn(cmd, {
+		stdout: 'inherit',
+		stderr: 'inherit',
+		env: { ...process.env },
+	});
+
+	service.process = proc;
+	service.running = true;
+
+	proc.exited.then((code) => {
+		service.running = false;
+		service.process = null;
+
+		if (code !== 0 && code !== null) {
+			console.warn(`[service-loader] ${service.name} exited with code ${code}`);
+		} else {
+			console.log(`[service-loader] ${service.name} exited`);
+		}
+
+		if (service.retries < MAX_RETRIES) {
+			service.retries++;
+			console.log(
+				`[service-loader] restarting ${service.name} (attempt ${service.retries}/${MAX_RETRIES}) in ${RETRY_DELAY_MS}ms`
+			);
+			setTimeout(() => spawnService(service), RETRY_DELAY_MS);
+		} else {
+			console.error(`[service-loader] ${service.name} exceeded max retries (${MAX_RETRIES}), giving up`);
+		}
+	});
+}
+
+async function publishHealth(services: ManagedService[]): Promise<void> {
+	try {
+		const nc = await connect({
+			servers: process.env.NATS_URL || 'nats://localhost:4222',
+		});
+
+		const status = services.map((s) => ({
+			name: s.name,
+			running: s.running,
+			retries: s.retries,
+			pid: s.process?.pid ?? null,
+		}));
+
+		const payload = JSON.stringify({
+			ts: new Date().toISOString(),
+			loader: 'service-loader',
+			services: status,
+		});
+
+		nc.publish('khal._internal.system.health', payload);
+		await nc.flush();
+		await nc.close();
+	} catch (err) {
+		console.error('[service-loader] failed to publish health:', err);
+	}
+}
+
+async function main(): Promise<void> {
+	const services = discoverServices();
+
+	if (services.length === 0) {
+		console.warn('[service-loader] no services discovered');
+		return;
+	}
+
+	console.log(`[service-loader] discovered ${services.length} service(s):`, services.map((s) => s.name).join(', '));
+
+	// Provision observability JetStream streams before spawning services
+	try {
+		const nc = await connect({ servers: process.env.NATS_URL || 'nats://localhost:4222' });
+		await ensureO11yStreams(nc);
+		await nc.close();
+	} catch (err) {
+		console.error('[service-loader] failed to provision o11y streams:', err);
+	}
+
+	for (const service of services) {
+		spawnService(service);
+	}
+
+	// Initial health publish after a short delay to let services start
+	setTimeout(() => publishHealth(services), 2000);
+
+	// Periodic health publishing
+	setInterval(() => publishHealth(services), HEALTH_INTERVAL_MS);
+
+	// Handle graceful shutdown
+	const shutdown = () => {
+		console.log('[service-loader] shutting down...');
+		for (const service of services) {
+			if (service.process) {
+				service.retries = MAX_RETRIES; // prevent restart
+				service.process.kill();
+			}
+		}
+		process.exit(0);
+	};
+
+	process.on('SIGINT', shutdown);
+	process.on('SIGTERM', shutdown);
+}
+
+main().catch((err) => {
+	console.error('[service-loader] fatal:', err);
+	process.exit(1);
+});

package/src/lib/subjects.ts

@@ -0,0 +1,64 @@
+export const SUBJECTS = {
+	echo: (orgId: string) => `khal.${orgId}.echo`,
+	system: {
+		health: (orgId: string) => `khal.${orgId}.system.health`,
+	},
+	pty: {
+		create: (orgId: string) => `khal.${orgId}.pty.create`,
+		destroy: (orgId: string) => `khal.${orgId}.pty.destroy`,
+		list: (orgId: string) => `khal.${orgId}.pty.list`,
+		data: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.data`,
+		input: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.input`,
+		resize: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.resize`,
+		exit: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.exit`,
+		replay: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.replay`,
+		buffer: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.buffer`,
+		bufferEnd: (orgId: string, sessionId: string) => `khal.${orgId}.pty.${sessionId}.buffer-end`,
+	},
+	fs: {
+		list: (orgId: string) => `khal.${orgId}.fs.list`,
+		read: (orgId: string) => `khal.${orgId}.fs.read`,
+		write: (orgId: string) => `khal.${orgId}.fs.write`,
+		search: (orgId: string) => `khal.${orgId}.fs.search`,
+		watch: (orgId: string, pathHash: string) => `khal.${orgId}.fs.watch.${pathHash}`,
+	},
+	notify: {
+		broadcast: (orgId: string) => `khal.${orgId}.notify.broadcast`,
+		user: (orgId: string, userId: string) => `khal.${orgId}.notify.user.${userId}`,
+	},
+	d3k: {
+		log: (orgId: string) => `khal.${orgId}.d3k.log`,
+		cmd: (orgId: string) => `khal.${orgId}.d3k.cmd`,
+		status: (orgId: string) => `khal.${orgId}.d3k.status`,
+	},
+	auth: {
+		roleChanged: 'os.auth.role-changed',
+		membershipRevoked: 'os.auth.membership-revoked',
+	},
+	desktop: {
+		cmd: {
+			open: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.open`,
+			close: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.close`,
+			focus: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.focus`,
+			minimize: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.minimize`,
+			maximize: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.maximize`,
+			restore: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.restore`,
+			notify: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.notify`,
+			sync: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.sync`,
+			all: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.cmd.>`,
+		},
+		event: {
+			opened: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.opened`,
+			closed: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.closed`,
+			focused: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.focused`,
+			minimized: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.minimized`,
+			maximized: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.maximized`,
+			restored: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.restored`,
+			state: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.state`,
+			metaUpdated: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.meta-updated`,
+			moved: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.moved`,
+			resized: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.resized`,
+			all: (orgId: string, userId: string) => `khal.${orgId}.desktop.${userId}.event.>`,
+		},
+	},
+} as const;

package/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+	return twMerge(clsx(inputs));
+}