khal-os 1.260324.2

package/packages/genie-app/views/genie/service/comms.ts

@@ -0,0 +1,141 @@
+/**
+ * Communication domain — inter-agent messaging and team chat.
+ *
+ * Endpoints:
+ *   os.genie.comms.send      — send message to a specific agent
+ *   os.genie.comms.broadcast  — broadcast message to all/team agents
+ *   os.genie.comms.inbox      — read agent inbox
+ *   os.genie.comms.chat.post  — post to team chat
+ *   os.genie.comms.chat.read  — read team chat history
+ */
+
+import type { ServiceHandler } from '@genie-os/sdk/service';
+import { SUBJECTS } from '../../../lib/subjects';
+import { runGenie } from './cli';
+
+export const commsHandlers: ServiceHandler[] = [
+	// --- Send message to agent ---
+	{
+		subject: SUBJECTS.comms.send(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ body: string; to: string; from?: string }>();
+				if (!req.body || !req.to) {
+					msg.respond(JSON.stringify({ error: 'Missing required fields: body, to' }));
+					return;
+				}
+
+				const args = ['send', req.body, '--to', req.to];
+				if (req.from) args.push('--from', req.from);
+
+				const result = runGenie(args, { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Broadcast message ---
+	{
+		subject: SUBJECTS.comms.broadcast(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ body: string; team?: string }>();
+				if (!req.body) {
+					msg.respond(JSON.stringify({ error: 'Missing required field: body' }));
+					return;
+				}
+
+				const args = ['broadcast', req.body];
+				if (req.team) args.push('--team', req.team);
+
+				const result = runGenie(args, { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Read inbox ---
+	{
+		subject: SUBJECTS.comms.inbox(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ agent?: string; unread?: boolean }>();
+				const args = ['inbox'];
+				if (req.agent) args.push(req.agent);
+				args.push('--json');
+				if (req.unread) args.push('--unread');
+
+				const result = runGenie<unknown[]>(args);
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				const messages = Array.isArray(result.data) ? result.data : [];
+				msg.respond(JSON.stringify({ messages }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Post to team chat ---
+	{
+		subject: SUBJECTS.comms.chat.post(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ message: string; team?: string }>();
+				if (!req.message) {
+					msg.respond(JSON.stringify({ error: 'Missing required field: message' }));
+					return;
+				}
+
+				const args = ['chat', req.message];
+				if (req.team) args.push('--team', req.team);
+
+				const result = runGenie(args, { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Read team chat ---
+	{
+		subject: SUBJECTS.comms.chat.read(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ team?: string; since?: string }>();
+				const args = ['chat', 'read', '--json'];
+				if (req.team) args.push('--team', req.team);
+				if (req.since) args.push('--since', req.since);
+
+				const result = runGenie<unknown[]>(args);
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				const messages = Array.isArray(result.data) ? result.data : [];
+				msg.respond(JSON.stringify({ messages }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+];

package/packages/genie-app/views/genie/service/directory.ts

@@ -0,0 +1,167 @@
+import { SUBJECTS } from '../../../lib/subjects';
+import { runGenie } from './cli';
+
+interface DirListPayload {
+	builtins?: boolean;
+}
+
+interface DirGetPayload {
+	name: string;
+}
+
+interface DirAddPayload {
+	name: string;
+	dir?: string;
+	repo?: string;
+	model?: string;
+	roles?: string[];
+}
+
+interface DirRemovePayload {
+	name: string;
+}
+
+interface DirEditPayload {
+	name: string;
+	model?: string;
+	dir?: string;
+	repo?: string;
+	roles?: string[];
+	description?: string;
+}
+
+export const directorySubscriptions = [
+	// --- List directory entries ---
+	{
+		subject: SUBJECTS.dir.list(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const payload = msg.data.length > 0 ? msg.json<DirListPayload>() : {};
+				const args = ['dir', 'ls', '--json'];
+				if (payload.builtins) args.push('--builtins');
+
+				const result = runGenie(args);
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ entries: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Get single directory entry ---
+	{
+		subject: SUBJECTS.dir.get(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const { name } = msg.json<DirGetPayload>();
+				if (!name) {
+					msg.respond(JSON.stringify({ error: 'name is required' }));
+					return;
+				}
+
+				const result = runGenie(['dir', 'ls', name, '--json']);
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ entry: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Add directory entry ---
+	{
+		subject: SUBJECTS.dir.add(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const { name, dir, repo, model, roles } = msg.json<DirAddPayload>();
+				if (!name) {
+					msg.respond(JSON.stringify({ error: 'name is required' }));
+					return;
+				}
+
+				const args = ['dir', 'add', name];
+				if (dir) args.push('--dir', dir);
+				if (repo) args.push('--repo', repo);
+				if (model) args.push('--model', model);
+				if (roles) {
+					for (const role of roles) {
+						args.push('--role', role);
+					}
+				}
+
+				const result = runGenie(args, { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Remove directory entry ---
+	{
+		subject: SUBJECTS.dir.remove(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const { name } = msg.json<DirRemovePayload>();
+				if (!name) {
+					msg.respond(JSON.stringify({ error: 'name is required' }));
+					return;
+				}
+
+				const result = runGenie(['dir', 'rm', name], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Edit directory entry ---
+	{
+		subject: SUBJECTS.dir.edit(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const { name, model, dir, repo, roles, description } = msg.json<DirEditPayload>();
+				if (!name) {
+					msg.respond(JSON.stringify({ error: 'name is required' }));
+					return;
+				}
+
+				const args = ['dir', 'edit', name];
+				if (model) args.push('--model', model);
+				if (dir) args.push('--dir', dir);
+				if (repo) args.push('--repo', repo);
+				if (description) args.push('--description', description);
+				if (roles) {
+					for (const role of roles) {
+						args.push('--role', role);
+					}
+				}
+
+				const result = runGenie(args, { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+];

package/packages/genie-app/views/genie/service/index.ts

@@ -0,0 +1,219 @@
+import type { NatsConnection } from '@genie-os/sdk/service';
+import { createService } from '@genie-os/sdk/service';
+import { agentLifecycleHandlers } from './agent-lifecycle';
+import { commsHandlers } from './comms';
+import { directorySubscriptions } from './directory';
+import { systemSubscriptions } from './system';
+import { teamsHandlers } from './teams';
+import { createTerminalProxy } from './terminal-proxy';
+import { TmuxControl } from './tmux-control';
+import { wishHandlers } from './wishes';
+
+let tmux: TmuxControl;
+let nc: NatsConnection;
+let termProxy: ReturnType<typeof createTerminalProxy>;
+
+/**
+ * Merge tmux pane data with genie agent registry for richer agent info.
+ */
+function loadAgentRegistry(): Record<string, { name: string; color: string; state: string; role: string }> {
+	try {
+		const fs = require('node:fs');
+		const data = fs.readFileSync(`${process.env.HOME}/.genie/workers.json`, 'utf-8');
+		const workers = JSON.parse(data);
+		const map: Record<string, { name: string; color: string; state: string; role: string }> = {};
+		for (const [id, worker] of Object.entries(workers as Record<string, Record<string, unknown>>)) {
+			const paneId = worker.paneId as string | undefined;
+			if (paneId) {
+				map[paneId] = {
+					name: (worker.name || worker.agentName || id) as string,
+					color: (worker.nativeColor || worker.color || 'blue') as string,
+					state: (worker.state || 'unknown') as string,
+					role: (worker.role || worker.agentRole || '') as string,
+				};
+			}
+		}
+		return map;
+	} catch {
+		return {};
+	}
+}
+
+createService({
+	name: 'genie-control',
+	onReady: (_nc: NatsConnection) => {
+		nc = _nc;
+		tmux = new TmuxControl();
+		termProxy = createTerminalProxy(nc, tmux);
+
+		// Event stream disabled — polling is sufficient for the dashboard refresh cycle
+	},
+
+	onShutdown: () => {
+		termProxy?.shutdown();
+	},
+
+	subscriptions: [
+		// --- List all agents ---
+		{
+			subject: 'os.genie.agents.list',
+			handler: (msg) => {
+				try {
+					const sessions = tmux.listSessions();
+					const windows = tmux.listWindows();
+					const panes = tmux.listPanes();
+					const registry = loadAgentRegistry();
+
+					const tree = sessions.map((session) => ({
+						...session,
+						windows: windows
+							.filter((w) => w.sessionId === session.id)
+							.map((window) => ({
+								...window,
+								panes: panes
+									.filter((p) => p.windowId === window.id)
+									.map((pane) => ({ ...pane, agent: registry[pane.id] || null })),
+							})),
+					}));
+
+					msg.respond(JSON.stringify({ sessions: tree, ts: Date.now() }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ error: String(err), sessions: [] }));
+				}
+			},
+		},
+
+		// --- List sessions only ---
+		{
+			subject: 'os.genie.sessions.list',
+			handler: (msg) => {
+				try {
+					msg.respond(JSON.stringify({ sessions: tmux.listSessions() }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ error: String(err), sessions: [] }));
+				}
+			},
+		},
+
+		// --- Capture pane content ---
+		{
+			subject: 'os.genie.pane.*.capture',
+			handler: (msg) => {
+				const paneId = `%${msg.subject.split('.')[3]}`;
+				try {
+					let lines = 50;
+					if (msg.data.length > 0) {
+						const req = msg.json<{ lines?: number }>();
+						if (req.lines) lines = req.lines;
+					}
+					msg.respond(JSON.stringify({ paneId, content: tmux.capturePane(paneId, lines) }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ paneId, error: String(err), content: '' }));
+				}
+			},
+		},
+
+		// --- Send keys to pane ---
+		{
+			subject: 'os.genie.pane.*.send',
+			handler: (msg) => {
+				const paneId = `%${msg.subject.split('.')[3]}`;
+				try {
+					const req = msg.json<{ keys: string }>();
+					tmux.sendKeys(paneId, req.keys);
+					msg.respond(JSON.stringify({ ok: true }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+				}
+			},
+		},
+
+		// --- Spawn agent ---
+		{
+			subject: 'os.genie.spawn',
+			handler: (msg) => {
+				try {
+					const { execSync } = require('node:child_process');
+					const req = msg.json<{ role: string; team?: string; repo?: string }>();
+					const args = [req.role];
+					if (req.team) args.push('--team', req.team);
+					const result = execSync(`genie spawn ${args.join(' ')}`, {
+						cwd: req.repo || process.env.HOME,
+						timeout: 15000,
+						encoding: 'utf-8',
+					});
+					msg.respond(JSON.stringify({ ok: true, output: result.trim() }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+				}
+			},
+		},
+
+		// --- Terminal proxy: create PTY attached to tmux pane ---
+		{
+			subject: 'os.genie.term.create',
+			handler: (msg) => {
+				try {
+					const req = msg.json<{ tmuxPaneId: string; cols?: number; rows?: number }>();
+					const sessionId = termProxy.create(req.tmuxPaneId, req.cols, req.rows);
+					msg.respond(JSON.stringify({ sessionId }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ error: String(err) }));
+				}
+			},
+		},
+
+		// --- Terminal proxy: destroy ---
+		{
+			subject: 'os.genie.term.destroy',
+			handler: (msg) => {
+				try {
+					const req = msg.json<{ sessionId: string }>();
+					termProxy.destroy(req.sessionId);
+					msg.respond(JSON.stringify({ ok: true }));
+				} catch (err) {
+					msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+				}
+			},
+		},
+
+		// --- Terminal proxy: input (fire-and-forget) ---
+		{
+			subject: 'os.genie.term.*.input',
+			handler: (msg) => {
+				const sessionId = msg.subject.split('.')[3];
+				if (msg.data.length > 0) {
+					const parsed = msg.json<{ data: string }>();
+					termProxy.write(sessionId, parsed.data);
+				}
+			},
+		},
+
+		// --- Terminal proxy: resize (fire-and-forget) ---
+		{
+			subject: 'os.genie.term.*.resize',
+			handler: (msg) => {
+				const sessionId = msg.subject.split('.')[3];
+				const req = msg.json<{ cols: number; rows: number }>();
+				termProxy.resize(sessionId, req.cols, req.rows);
+			},
+		},
+
+		// --- Terminal proxy: replay buffer ---
+		{
+			subject: 'os.genie.term.*.replay',
+			handler: (msg) => {
+				const sessionId = msg.subject.split('.')[3];
+				termProxy.replay(sessionId);
+			},
+		},
+
+		// --- Domain modules ---
+		...teamsHandlers,
+		...agentLifecycleHandlers,
+		...commsHandlers,
+		...wishHandlers,
+		...directorySubscriptions,
+		...systemSubscriptions,
+	],
+});

package/packages/genie-app/views/genie/service/system.ts

@@ -0,0 +1,123 @@
+import { SUBJECTS } from '../../../lib/subjects';
+import { runGenie } from './cli';
+
+interface DoctorCheck {
+	name: string;
+	status: 'pass' | 'warn' | 'fail';
+	detail: string;
+}
+
+interface DoctorResult {
+	prerequisites: DoctorCheck[];
+	configuration: DoctorCheck[];
+	tmux: DoctorCheck[];
+	workerProfiles: DoctorCheck[];
+}
+
+/**
+ * Parse `genie doctor` text output into structured sections.
+ *
+ * The output uses ANSI-colored lines like:
+ *   ✓ tmux                → pass
+ *   ! Session 'genie'...  → warn
+ *   ✗ something           → fail
+ */
+function parseDoctorOutput(text: string): DoctorResult {
+	const result: DoctorResult = {
+		prerequisites: [],
+		configuration: [],
+		tmux: [],
+		workerProfiles: [],
+	};
+
+	// Strip ANSI escape codes
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape stripping requires matching \x1b
+	const clean = text.replace(/\x1b\[[0-9;]*m/g, '');
+
+	let currentSection: keyof DoctorResult | null = null;
+
+	for (const line of clean.split('\n')) {
+		const trimmed = line.trim();
+
+		// Detect section headers
+		if (/^prerequisites:/i.test(trimmed)) {
+			currentSection = 'prerequisites';
+			continue;
+		}
+		if (/^configuration:/i.test(trimmed)) {
+			currentSection = 'configuration';
+			continue;
+		}
+		if (/^tmux:/i.test(trimmed)) {
+			currentSection = 'tmux';
+			continue;
+		}
+		if (/^worker\s*profiles?:/i.test(trimmed)) {
+			currentSection = 'workerProfiles';
+			continue;
+		}
+
+		if (!currentSection) continue;
+
+		// Parse check lines: ✓ / ! / ✗ followed by description
+		let status: 'pass' | 'warn' | 'fail' | null = null;
+		let detail = '';
+
+		if (trimmed.startsWith('✓') || trimmed.startsWith('√')) {
+			status = 'pass';
+			detail = trimmed.slice(1).trim();
+		} else if (trimmed.startsWith('!')) {
+			status = 'warn';
+			detail = trimmed.slice(1).trim();
+		} else if (trimmed.startsWith('✗') || trimmed.startsWith('×') || trimmed.startsWith('x ')) {
+			status = 'fail';
+			detail = trimmed.slice(1).trim();
+		}
+
+		if (status && detail) {
+			// Extract a short name from the first word(s) before any version/path info
+			const name = detail.split(/\s+/)[0].toLowerCase();
+			result[currentSection].push({ name, status, detail });
+		}
+	}
+
+	return result;
+}
+
+export const systemSubscriptions = [
+	// --- System doctor ---
+	{
+		subject: SUBJECTS.system.doctor(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const result = runGenie(['doctor'], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				const parsed = parseDoctorOutput(result.data as string);
+				msg.respond(JSON.stringify(parsed));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- System version ---
+	{
+		subject: SUBJECTS.system.version(),
+		handler: (msg: { data: Uint8Array; json: <T>() => T; respond: (data: string) => void }) => {
+			try {
+				const result = runGenie(['--version'], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error }));
+					return;
+				}
+				const version = (result.data as string).trim();
+				msg.respond(JSON.stringify({ version }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+];