khal-os 1.260324.2

package/src/components/apps/terminal/service/index.ts

@@ -0,0 +1,189 @@
+import { connect } from '@nats-io/transport-node';
+import type {
+	PtyCreateRequest,
+	PtyDestroyRequest,
+	PtyInputMessage,
+	PtyListRequest,
+	PtyReplayRequest,
+	PtyResizeRequest,
+} from '../schema';
+import { createSessionManager } from './session';
+
+async function main() {
+	const nc = await connect({
+		servers: process.env.NATS_URL || 'nats://localhost:4222',
+	});
+
+	console.log('[pty-service] connected to NATS, subscribing to khal.*.pty.*');
+
+	const sessionManager = createSessionManager(nc);
+
+	// --- khal.*.pty.create (request-reply, wildcard for any orgId) ---
+	const createSub = nc.subscribe('khal.*.pty.create');
+	(async () => {
+		for await (const msg of createSub) {
+			try {
+				const orgId = msg.subject.split('.')[1];
+				let request: PtyCreateRequest & { _authUserId?: string } = {};
+				if (msg.data.length > 0) {
+					request = msg.json<PtyCreateRequest & { _authUserId?: string }>();
+				}
+				const userId = request._authUserId || '';
+
+				// If sessionId provided and session exists, reattach (no buffer replay yet -- client requests it after subscribing)
+				if (request.sessionId && sessionManager.hasSession(request.sessionId)) {
+					if (!userId || !sessionManager.isOwner(request.sessionId, userId)) {
+						console.warn(
+							`[pty-service] reattach denied: user ${userId || '<empty>'} does not own session ${request.sessionId}`
+						);
+						msg.respond(JSON.stringify({ error: 'ownership check failed' }));
+						continue;
+					}
+					console.log(`[pty-service] reattaching to existing session ${request.sessionId}`);
+					msg.respond(
+						JSON.stringify({
+							sessionId: request.sessionId,
+							created: false,
+						})
+					);
+					continue;
+				}
+
+				const response = sessionManager.createSession(request, orgId, userId);
+				msg.respond(JSON.stringify(response));
+			} catch (err) {
+				console.error('[pty-service] create error:', err);
+				msg.respond(JSON.stringify({ error: (err as Error).message }));
+			}
+		}
+	})();
+
+	// --- khal.*.pty.destroy (request-reply) ---
+	const destroySub = nc.subscribe('khal.*.pty.destroy');
+	(async () => {
+		for await (const msg of destroySub) {
+			try {
+				const request = msg.json<PtyDestroyRequest & { _authUserId?: string }>();
+				const userId = request._authUserId;
+				const destroyed = sessionManager.destroySession(request.sessionId, userId);
+				if (!destroyed) {
+					msg.respond(JSON.stringify({ ok: false, error: 'ownership check failed or session not found' }));
+				} else {
+					msg.respond(JSON.stringify({ ok: true }));
+				}
+			} catch (err) {
+				console.error('[pty-service] destroy error:', err);
+				msg.respond(JSON.stringify({ error: (err as Error).message }));
+			}
+		}
+	})();
+
+	// --- khal.*.pty.list (request-reply) ---
+	const listSub = nc.subscribe('khal.*.pty.list');
+	(async () => {
+		for await (const msg of listSub) {
+			try {
+				const orgId = msg.subject.split('.')[1];
+				let listRequest: PtyListRequest & { _authUserId?: string } = {};
+				if (msg.data.length > 0) {
+					listRequest = msg.json<PtyListRequest & { _authUserId?: string }>();
+				}
+				const response = sessionManager.listSessions(orgId, listRequest._authUserId);
+				msg.respond(JSON.stringify(response));
+			} catch (err) {
+				console.error('[pty-service] list error:', err);
+				msg.respond(JSON.stringify({ error: (err as Error).message }));
+			}
+		}
+	})();
+
+	// --- khal.*.pty.*.input (wildcard for orgId AND sessionId, fire-and-forget) ---
+	const inputSub = nc.subscribe('khal.*.pty.*.input');
+	(async () => {
+		for await (const msg of inputSub) {
+			try {
+				const sessionId = msg.subject.split('.')[3];
+				let data = '';
+				let userId: string | undefined;
+
+				if (msg.data.length > 0) {
+					const parsed = msg.json<PtyInputMessage & { _authUserId?: string }>();
+					data = parsed.data;
+					userId = parsed._authUserId;
+				}
+
+				if (sessionId && data) {
+					sessionManager.writeToSession(sessionId, data, userId);
+				}
+			} catch (err) {
+				console.error('[pty-service] input error:', err);
+			}
+		}
+	})();
+
+	// --- khal.*.pty.*.resize (wildcard, fire-and-forget) ---
+	const resizeSub = nc.subscribe('khal.*.pty.*.resize');
+	(async () => {
+		for await (const msg of resizeSub) {
+			try {
+				const sessionId = msg.subject.split('.')[3];
+				const request = msg.json<PtyResizeRequest & { _authUserId?: string }>();
+
+				if (sessionId) {
+					sessionManager.resizeSession(sessionId, request.cols, request.rows, request._authUserId);
+				}
+			} catch (err) {
+				console.error('[pty-service] resize error:', err);
+			}
+		}
+	})();
+
+	// --- khal.*.pty.*.replay (wildcard, fire-and-forget) ---
+	// Client sends this AFTER subscribing to buffer/buffer-end subjects
+	const replaySub = nc.subscribe('khal.*.pty.*.replay');
+	(async () => {
+		for await (const msg of replaySub) {
+			try {
+				const sessionId = msg.subject.split('.')[3];
+				let userId: string | undefined;
+				if (msg.data.length > 0) {
+					const request = msg.json<PtyReplayRequest & { _authUserId?: string }>();
+					userId = request._authUserId;
+				}
+				if (sessionId) {
+					console.log(`[pty-service] replaying buffer for session ${sessionId}`);
+					sessionManager.replayBuffer(sessionId, userId);
+				}
+			} catch (err) {
+				console.error('[pty-service] replay error:', err);
+			}
+		}
+	})();
+
+	// --- Graceful shutdown ---
+	const shutdown = async () => {
+		console.log('[pty-service] shutting down...');
+		sessionManager.shutdown();
+
+		createSub.unsubscribe();
+		destroySub.unsubscribe();
+		listSub.unsubscribe();
+		inputSub.unsubscribe();
+		resizeSub.unsubscribe();
+		replaySub.unsubscribe();
+
+		await nc.close();
+		process.exit(0);
+	};
+
+	process.on('SIGINT', shutdown);
+	process.on('SIGTERM', shutdown);
+
+	// Keep alive
+	await nc.closed();
+}
+
+main().catch((err) => {
+	console.error('[pty-service] fatal:', err);
+	process.exit(1);
+});

package/src/components/apps/terminal/service/runtime

@@ -0,0 +1 @@
+node

package/src/components/apps/terminal/service/session.ts

@@ -0,0 +1,296 @@
+import { randomUUID } from 'node:crypto';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { NatsConnection } from '@nats-io/transport-node';
+import * as pty from 'node-pty';
+import { SUBJECTS } from '@/lib/subjects';
+import type {
+	PtyBufferEndMessage,
+	PtyBufferMessage,
+	PtyCreateRequest,
+	PtyCreateResponse,
+	PtyDataMessage,
+	PtyExitMessage,
+	PtyListResponse,
+} from '../schema';
+
+const SHELL = process.env.SHELL || '/bin/bash';
+const MAX_BUFFER_BYTES = parseInt(process.env.PTY_MAX_BUFFER_BYTES || '1048576', 10); // 1MB
+const SESSION_TTL_MS = parseInt(process.env.PTY_SESSION_TTL_MS || '259200000', 10); // 72h
+const CLEANUP_INTERVAL_MS = 3600000; // 1 hour
+
+const __dir = import.meta.dirname ?? dirname(fileURLToPath(import.meta.url));
+const BASHRC_HOOK_PATH = resolve(__dir, 'shell-hooks', 'bashrc-hook.sh');
+
+interface PTYSession {
+	sessionId: string;
+	orgId: string;
+	ownerId: string;
+	process: pty.IPty;
+	buffer: Buffer[];
+	bufferBytes: number;
+	createdAt: number;
+	lastActivity: number;
+	subscribers: number;
+}
+
+function addToBuffer(session: PTYSession, data: string): void {
+	const chunk = Buffer.from(data, 'utf8');
+	session.buffer.push(chunk);
+	session.bufferBytes += chunk.length;
+
+	// Enforce byte cap by removing oldest chunks
+	while (session.bufferBytes > MAX_BUFFER_BYTES && session.buffer.length > 0) {
+		const removed = session.buffer.shift();
+		if (removed) {
+			session.bufferBytes -= removed.length;
+		}
+	}
+
+	session.lastActivity = Date.now();
+}
+
+export function createSessionManager(nc: NatsConnection) {
+	const sessions = new Map<string, PTYSession>();
+	let cleanupTimer: ReturnType<typeof setInterval> | null = null;
+
+	function createSession(request: PtyCreateRequest, orgId: string, userId: string): PtyCreateResponse {
+		const sessionId = request.sessionId || randomUUID();
+		const cols = request.cols || 80;
+		const rows = request.rows || 24;
+
+		console.log(`[pty] Creating session ${sessionId} (org=${orgId}, user=${userId}) -- spawning ${SHELL}`);
+
+		// Determine shell args -- for bash, use --rcfile for OSC integration
+		let shellArgs: string[] = [];
+		const shellName = SHELL.split('/').pop();
+		if (shellName === 'bash') {
+			shellArgs = ['--rcfile', BASHRC_HOOK_PATH];
+		}
+
+		const ptyProcess = pty.spawn(SHELL, shellArgs, {
+			name: 'xterm-256color',
+			cols,
+			rows,
+			cwd: process.env.HOME || '/home/genie',
+			env: {
+				...(process.env as Record<string, string>),
+				TERM: 'xterm-256color',
+				COLORTERM: 'truecolor',
+			},
+		});
+
+		const session: PTYSession = {
+			sessionId,
+			orgId,
+			ownerId: userId,
+			process: ptyProcess,
+			buffer: [],
+			bufferBytes: 0,
+			createdAt: Date.now(),
+			lastActivity: Date.now(),
+			subscribers: 0,
+		};
+
+		// PTY output -> buffer + publish to NATS
+		ptyProcess.onData((data: string) => {
+			addToBuffer(session, data);
+
+			const msg: PtyDataMessage = {
+				sessionId,
+				data: Buffer.from(data, 'utf8').toString('base64'),
+			};
+			nc.publish(SUBJECTS.pty.data(session.orgId, sessionId), JSON.stringify(msg));
+		});
+
+		// PTY exit -> publish exit message + cleanup
+		ptyProcess.onExit(({ exitCode, signal }) => {
+			console.log(`[pty] Session ${sessionId} exited (code=${exitCode}, signal=${signal})`);
+
+			const msg: PtyExitMessage = {
+				sessionId,
+				code: exitCode,
+				...(signal !== undefined ? { signal } : {}),
+			};
+			nc.publish(SUBJECTS.pty.exit(session.orgId, sessionId), JSON.stringify(msg));
+
+			sessions.delete(sessionId);
+		});
+
+		sessions.set(sessionId, session);
+
+		return { sessionId, created: true };
+	}
+
+	function destroySession(sessionId: string, userId?: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+
+		// Strict ownership: if session has an owner, userId must match
+		if (session.ownerId && (!userId || session.ownerId !== userId)) {
+			console.warn(
+				`[pty] Ownership check failed: user ${userId || '<empty>'} tried to destroy session ${sessionId} owned by ${session.ownerId}`
+			);
+			return false;
+		}
+
+		console.log(`[pty] Destroying session ${sessionId}`);
+
+		try {
+			session.process.kill();
+		} catch (err) {
+			console.error(`[pty] Error killing PTY ${sessionId}:`, (err as Error).message);
+		}
+
+		sessions.delete(sessionId);
+		return true;
+	}
+
+	function replayBuffer(sessionId: string, userId?: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+
+		if (session.ownerId && (!userId || session.ownerId !== userId)) {
+			console.warn(
+				`[pty] Ownership check failed: user ${userId || '<empty>'} tried to replay session ${sessionId} owned by ${session.ownerId}`
+			);
+			// Send buffer-end with error so the client doesn't hang
+			const endMsg: PtyBufferEndMessage = { sessionId, error: 'access_denied' };
+			nc.publish(SUBJECTS.pty.bufferEnd(session.orgId, sessionId), JSON.stringify(endMsg));
+			return false;
+		}
+
+		// Publish each buffered chunk as base64
+		for (const chunk of session.buffer) {
+			const msg: PtyBufferMessage = {
+				sessionId,
+				data: chunk.toString('base64'),
+			};
+			nc.publish(SUBJECTS.pty.buffer(session.orgId, sessionId), JSON.stringify(msg));
+		}
+
+		// Signal end of buffer replay
+		const endMsg: PtyBufferEndMessage = { sessionId };
+		nc.publish(SUBJECTS.pty.bufferEnd(session.orgId, sessionId), JSON.stringify(endMsg));
+
+		return true;
+	}
+
+	function resizeSession(sessionId: string, cols: number, rows: number, userId?: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+
+		if (session.ownerId && (!userId || session.ownerId !== userId)) {
+			console.warn(
+				`[pty] Ownership check failed: user ${userId || '<empty>'} tried to resize session ${sessionId} owned by ${session.ownerId}`
+			);
+			return false;
+		}
+
+		const newCols = Math.max(1, Math.floor(cols));
+		const newRows = Math.max(1, Math.floor(rows));
+
+		// Skip if dimensions haven't changed — avoids redundant SIGWINCH
+		if (session.process.cols === newCols && session.process.rows === newRows) {
+			return true;
+		}
+
+		session.process.resize(newCols, newRows);
+		session.lastActivity = Date.now();
+		return true;
+	}
+
+	function writeToSession(sessionId: string, data: string, userId?: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+
+		if (session.ownerId && (!userId || session.ownerId !== userId)) {
+			console.warn(
+				`[pty] Ownership check failed: user ${userId || '<empty>'} tried to write to session ${sessionId} owned by ${session.ownerId}`
+			);
+			return false;
+		}
+
+		session.process.write(data);
+		session.lastActivity = Date.now();
+		return true;
+	}
+
+	function hasSession(sessionId: string): boolean {
+		return sessions.has(sessionId);
+	}
+
+	function isOwner(sessionId: string, userId: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+		return session.ownerId === userId;
+	}
+
+	function listSessions(orgId?: string, userId?: string): PtyListResponse {
+		let entries = Array.from(sessions.values());
+
+		if (orgId) {
+			entries = entries.filter((s) => s.orgId === orgId);
+		}
+
+		if (userId) {
+			entries = entries.filter((s) => s.ownerId === userId);
+		}
+
+		const list = entries.map((s) => ({
+			sessionId: s.sessionId,
+			createdAt: s.createdAt,
+			lastActivity: s.lastActivity,
+			bufferBytes: s.bufferBytes,
+			connected: s.subscribers > 0,
+		}));
+
+		return { sessions: list };
+	}
+
+	function setSubscribers(sessionId: string, count: number): void {
+		const session = sessions.get(sessionId);
+		if (session) {
+			session.subscribers = count;
+		}
+	}
+
+	function cleanupExpiredSessions(): void {
+		const now = Date.now();
+		for (const [sessionId, session] of sessions.entries()) {
+			if (now - session.lastActivity > SESSION_TTL_MS) {
+				console.log(`[pty] Session ${sessionId} expired (TTL exceeded)`);
+				destroySession(sessionId);
+			}
+		}
+	}
+
+	// Start TTL cleanup interval
+	cleanupTimer = setInterval(cleanupExpiredSessions, CLEANUP_INTERVAL_MS);
+
+	function shutdown(): void {
+		console.log('[pty] Shutting down session manager...');
+
+		if (cleanupTimer) {
+			clearInterval(cleanupTimer);
+			cleanupTimer = null;
+		}
+
+		for (const sessionId of sessions.keys()) {
+			destroySession(sessionId);
+		}
+	}
+
+	return {
+		createSession,
+		destroySession,
+		replayBuffer,
+		resizeSession,
+		writeToSession,
+		hasSession,
+		isOwner,
+		listSessions,
+		setSubscribers,
+		shutdown,
+	};
+}

package/src/components/apps/terminal/service/shell-hooks/bashrc-hook.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Khal Terminal Integration Hook
+# This file is sourced by bash when spawned by the PTY server.
+# It provides shell integration for CWD tracking via OSC 7.
+
+# Source user's existing bashrc first to preserve customizations
+if [ -f ~/.bashrc ]; then
+  source ~/.bashrc
+fi
+
+# OSC 7 CWD reporting — sends current directory to terminal after each command
+__khal_precmd() {
+  printf '\e]7;file://%s%s\e\\' "$HOSTNAME" "$PWD"
+}
+
+# Add to PROMPT_COMMAND (append, don't overwrite)
+if [ -z "$PROMPT_COMMAND" ]; then
+  PROMPT_COMMAND="__khal_precmd"
+else
+  PROMPT_COMMAND="__khal_precmd;${PROMPT_COMMAND}"
+fi

package/src/components/apps/terminal/types.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal tab data model for multi-tab terminal.
+ */
+export interface TerminalTab {
+	id: string;
+	ptySessionId: string | null; // assigned on connect (legacy, kept for compatibility)
+	title: string; // from OSC or fallback
+	cwd: string | null; // from OSC 7
+	lastCommand: string | null; // from input tracking
+	splitTree: SplitNode; // recursive split tree (root starts as single leaf)
+	focusedPaneId: string; // which pane in the split tree is focused
+}
+
+/**
+ * Recursive split pane tree structure.
+ * A tab's content is either a single pane (leaf) or a split container (branch).
+ */
+export type SplitNode =
+	| { type: 'leaf'; id: string; ptySessionId: string | null; cwd: string | null; lastCommand: string | null }
+	| {
+			type: 'branch';
+			id: string;
+			direction: 'horizontal' | 'vertical';
+			children: [SplitNode, SplitNode];
+			ratio: number;
+	  };