khal-os 1.260324.2

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

@@ -0,0 +1,191 @@
+/**
+ * Teams domain — NATS handlers for team lifecycle management.
+ *
+ * Exports a ServiceHandler[] array to be spread into the main service subscriptions.
+ */
+
+import type { ServiceHandler } from '@genie-os/sdk/service';
+import { SUBJECTS } from '../../../lib/subjects';
+import { runGenie, runGenieAsync } from './cli';
+
+// Use require() to avoid @types/node dependency (matches index.ts pattern)
+const fs = require('node:fs') as typeof import('node:fs');
+const path = require('node:path') as typeof import('node:path');
+
+const TEAMS_DIR = path.join(process.env.HOME ?? '', '.genie', 'teams');
+
+export const teamsHandlers: ServiceHandler[] = [
+	// --- List all teams ---
+	{
+		subject: SUBJECTS.teams.list(),
+		handler: (msg) => {
+			try {
+				const result = runGenie<unknown[]>(['team', 'ls', '--json']);
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ error: result.error, teams: [] }));
+					return;
+				}
+				msg.respond(JSON.stringify({ teams: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err), teams: [] }));
+			}
+		},
+	},
+
+	// --- Get full team config ---
+	{
+		subject: SUBJECTS.teams.get(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ name: string }>();
+				if (!req.name) {
+					msg.respond(JSON.stringify({ error: 'Missing required field: name' }));
+					return;
+				}
+				const teamFile = path.join(TEAMS_DIR, `${req.name}.json`);
+				const raw = fs.readFileSync(teamFile, 'utf-8');
+				const team = JSON.parse(raw);
+				msg.respond(JSON.stringify({ team }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ error: String(err) }));
+			}
+		},
+	},
+
+	// --- Create team (async — spawns worktree + team-lead) ---
+	{
+		subject: SUBJECTS.teams.create(),
+		handler: async (msg) => {
+			try {
+				const req = msg.json<{ name: string; repo: string; branch?: string; wish?: string }>();
+				if (!req.name || !req.repo) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required fields: name, repo' }));
+					return;
+				}
+
+				const args = ['team', 'create', req.name, '--repo', req.repo];
+				if (req.branch) args.push('--branch', req.branch);
+				if (req.wish) args.push('--wish', req.wish);
+
+				const result = await runGenieAsync(args, { json: false, timeout: 120_000 });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true, output: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+
+	// --- Disband team ---
+	{
+		subject: SUBJECTS.teams.disband(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ name: string }>();
+				if (!req.name) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required field: name' }));
+					return;
+				}
+				const result = runGenie(['team', 'disband', req.name], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+
+	// --- Mark team done ---
+	{
+		subject: SUBJECTS.teams.done(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ name: string }>();
+				if (!req.name) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required field: name' }));
+					return;
+				}
+				const result = runGenie(['team', 'done', req.name], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+
+	// --- Mark team blocked ---
+	{
+		subject: SUBJECTS.teams.blocked(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ name: string }>();
+				if (!req.name) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required field: name' }));
+					return;
+				}
+				const result = runGenie(['team', 'blocked', req.name], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+
+	// --- Hire agent into team ---
+	{
+		subject: SUBJECTS.teams.hire(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ agent: string; team: string }>();
+				if (!req.agent || !req.team) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required fields: agent, team' }));
+					return;
+				}
+				const result = runGenie(['team', 'hire', req.agent, '--team', req.team], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true, output: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+
+	// --- Fire agent from team ---
+	{
+		subject: SUBJECTS.teams.fire(),
+		handler: (msg) => {
+			try {
+				const req = msg.json<{ agent: string; team: string }>();
+				if (!req.agent || !req.team) {
+					msg.respond(JSON.stringify({ ok: false, error: 'Missing required fields: agent, team' }));
+					return;
+				}
+				const result = runGenie(['team', 'fire', req.agent, '--team', req.team], { json: false });
+				if (!result.ok) {
+					msg.respond(JSON.stringify({ ok: false, error: result.error }));
+					return;
+				}
+				msg.respond(JSON.stringify({ ok: true, output: result.data }));
+			} catch (err) {
+				msg.respond(JSON.stringify({ ok: false, error: String(err) }));
+			}
+		},
+	},
+];

package/packages/genie-app/views/genie/service/terminal-proxy.ts

@@ -0,0 +1,184 @@
+/**
+ * Terminal proxy — uses tmux control mode to stream pane I/O.
+ * One control mode connection per tmux session, multiplexing all pane output.
+ * Zero linked sessions, zero PTY processes.
+ *
+ * Subjects:
+ *   os.genie.term.create   → { tmuxPaneId, cols?, rows? } → { sessionId }
+ *   os.genie.term.destroy  → { sessionId }
+ *   os.genie.term.<id>.data     (service → browser, base64)
+ *   os.genie.term.<id>.input    (browser → service, raw text)
+ *   os.genie.term.<id>.resize   (browser → service, cols/rows)
+ *   os.genie.term.<id>.exit     (service → browser)
+ */
+// ARCHITECTURE DECISION: Terminal I/O uses tmux control mode (-CC). NEVER use node-pty, linked sessions, or _genie_proxy_* patterns. See wish tmux-control-mode-terminal.
+
+import { execSync } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import type { NatsConnection } from '@nats-io/transport-node';
+import type { ControlSession, TmuxControl } from './tmux-control';
+
+const PREFIX = 'os.genie.term';
+
+interface ProxySession {
+	sessionId: string;
+	tmuxPaneId: string;
+	tmuxSessionName: string;
+	controlSession: ControlSession;
+	outputHandler: (paneId: string, data: Buffer) => void;
+}
+
+interface ControlEntry {
+	controlSession: ControlSession;
+	refCount: number;
+}
+
+export function createTerminalProxy(nc: NatsConnection, tmux: TmuxControl) {
+	const sessions = new Map<string, ProxySession>();
+	const controlSessions = new Map<string, ControlEntry>();
+
+	function getOrCreateControl(sessionName: string): ControlSession {
+		let entry = controlSessions.get(sessionName);
+		if (entry) {
+			entry.refCount++;
+			return entry.controlSession;
+		}
+
+		const cs = tmux.attachSession(sessionName);
+		entry = { controlSession: cs, refCount: 1 };
+		controlSessions.set(sessionName, entry);
+
+		// If the control session exits, notify all proxy sessions using it
+		cs.on('exit', () => {
+			for (const [sid, session] of sessions) {
+				if (session.tmuxSessionName === sessionName) {
+					nc.publish(`${PREFIX}.${sid}.exit`, JSON.stringify({ sessionId: sid, code: 0 }));
+				}
+			}
+		});
+
+		return cs;
+	}
+
+	function releaseControl(sessionName: string): void {
+		const entry = controlSessions.get(sessionName);
+		if (!entry) return;
+		entry.refCount--;
+		if (entry.refCount <= 0) {
+			entry.controlSession.detach();
+			controlSessions.delete(sessionName);
+		}
+	}
+
+	function create(tmuxPaneId: string, cols = 80, rows = 24): string {
+		const sessionId = randomUUID();
+
+		// Find the tmux session that owns this pane
+		let sessionName: string;
+		try {
+			sessionName = execSync(`tmux display -t '${tmuxPaneId}' -p '#{session_name}'`, {
+				encoding: 'utf-8',
+				timeout: 3000,
+			}).trim();
+		} catch {
+			throw new Error(`Cannot find tmux pane ${tmuxPaneId}`);
+		}
+
+		const controlSession = getOrCreateControl(sessionName);
+
+		// Register output listener filtered to this pane
+		const outputHandler = (paneId: string, data: Buffer) => {
+			if (paneId !== tmuxPaneId) return;
+			nc.publish(`${PREFIX}.${sessionId}.data`, JSON.stringify({ sessionId, data: data.toString('base64') }));
+		};
+		controlSession.on('output', outputHandler);
+
+		const session: ProxySession = {
+			sessionId,
+			tmuxPaneId,
+			tmuxSessionName: sessionName,
+			controlSession,
+			outputHandler,
+		};
+		sessions.set(sessionId, session);
+
+		// Set initial size
+		controlSession.resizeClient(cols, rows);
+
+		// Initial buffer fill via capture-pane
+		try {
+			const content = tmux.capturePane(tmuxPaneId);
+			if (content) {
+				nc.publish(
+					`${PREFIX}.${sessionId}.buffer`,
+					JSON.stringify({ sessionId, data: Buffer.from(content, 'utf-8').toString('base64') })
+				);
+				nc.publish(`${PREFIX}.${sessionId}.buffer-end`, JSON.stringify({ sessionId }));
+			}
+		} catch {
+			// capture errors are non-fatal
+		}
+
+		return sessionId;
+	}
+
+	function destroy(sessionId: string): boolean {
+		const session = sessions.get(sessionId);
+		if (!session) return false;
+
+		// Unregister the output listener
+		session.controlSession.removeListener('output', session.outputHandler);
+		sessions.delete(sessionId);
+
+		// Release control session (detaches when refcount hits zero)
+		releaseControl(session.tmuxSessionName);
+
+		return true;
+	}
+
+	function write(sessionId: string, data: string): void {
+		const session = sessions.get(sessionId);
+		if (session) {
+			session.controlSession.sendKeys(session.tmuxPaneId, data);
+		}
+	}
+
+	function resize(sessionId: string, cols: number, rows: number): void {
+		const session = sessions.get(sessionId);
+		if (session) {
+			session.controlSession.resizeClient(Math.max(1, cols), Math.max(1, rows));
+		}
+	}
+
+	function replay(sessionId: string): void {
+		const session = sessions.get(sessionId);
+		if (!session) return;
+
+		try {
+			const content = tmux.capturePane(session.tmuxPaneId);
+			if (content) {
+				nc.publish(
+					`${PREFIX}.${sessionId}.buffer`,
+					JSON.stringify({ sessionId, data: Buffer.from(content, 'utf-8').toString('base64') })
+				);
+			}
+		} catch {
+			// capture errors are non-fatal
+		}
+		nc.publish(`${PREFIX}.${sessionId}.buffer-end`, JSON.stringify({ sessionId }));
+	}
+
+	function shutdown(): void {
+		// Destroy all proxy sessions
+		for (const sessionId of [...sessions.keys()]) {
+			destroy(sessionId);
+		}
+		// Detach any remaining control sessions
+		for (const [, entry] of controlSessions) {
+			entry.controlSession.detach();
+		}
+		controlSessions.clear();
+	}
+
+	return { create, destroy, write, resize, replay, shutdown };
+}

package/packages/genie-app/views/genie/service/tmux-control.ts

@@ -0,0 +1,318 @@
+/**
+ * tmux client — uses direct exec for queries (reliable) and
+ * control mode for pane I/O streaming + event notifications.
+ */
+
+import { type ChildProcess, execSync, spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import * as readline from 'node:readline';
+
+function isOctalDigit(ch: string): boolean {
+	return ch >= '0' && ch <= '7';
+}
+
+function pushUtf8Bytes(bytes: number[], code: number): void {
+	if (code <= 0x7f) {
+		bytes.push(code);
+	} else if (code <= 0x7ff) {
+		bytes.push(0xc0 | (code >> 6), 0x80 | (code & 0x3f));
+	} else if (code <= 0xffff) {
+		bytes.push(0xe0 | (code >> 12), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+	} else {
+		bytes.push(0xf0 | (code >> 18), 0x80 | ((code >> 12) & 0x3f), 0x80 | ((code >> 6) & 0x3f), 0x80 | (code & 0x3f));
+	}
+}
+
+/**
+ * Decode tmux control mode octal escape format.
+ * - \ooo → byte value (3-digit octal)
+ * - \\ → literal backslash
+ * - All other characters pass through as UTF-8
+ */
+export function decodeOctalEscapes(input: string): Buffer {
+	const bytes: number[] = [];
+	let i = 0;
+	while (i < input.length) {
+		if (input[i] === '\\' && i + 1 < input.length) {
+			if (input[i + 1] === '\\') {
+				bytes.push(0x5c);
+				i += 2;
+			} else if (
+				i + 3 < input.length &&
+				isOctalDigit(input[i + 1]) &&
+				isOctalDigit(input[i + 2]) &&
+				isOctalDigit(input[i + 3])
+			) {
+				bytes.push(Number.parseInt(input.substring(i + 1, i + 4), 8));
+				i += 4;
+			} else {
+				bytes.push(input.charCodeAt(i));
+				i++;
+			}
+		} else {
+			const code = input.codePointAt(i)!;
+			pushUtf8Bytes(bytes, code);
+			i += code > 0xffff ? 2 : 1;
+		}
+	}
+	return Buffer.from(bytes);
+}
+
+/**
+ * A control mode connection to a single tmux session.
+ * Emits 'output' events with (paneId, data) for all panes in the session.
+ * Emits 'exit' when the control connection ends.
+ */
+export class ControlSession extends EventEmitter {
+	private proc: ChildProcess | null = null;
+	private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+	private _connected = false;
+	private _detached = false;
+
+	constructor(readonly sessionName: string) {
+		super();
+		this.connect();
+	}
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	private connect(): void {
+		if (this._detached) return;
+
+		// Double -C disables echo of input commands
+		this.proc = spawn('tmux', ['-CC', 'attach-session', '-t', this.sessionName], {
+			stdio: ['pipe', 'pipe', 'pipe'],
+			env: { ...process.env, LC_ALL: 'C.UTF-8', LANG: 'C.UTF-8' },
+		});
+
+		const rl = readline.createInterface({ input: this.proc.stdout! });
+
+		rl.on('line', (line) => {
+			if (!line.startsWith('%')) return;
+
+			if (line.startsWith('%output ')) {
+				this.handleOutput(line);
+			} else if (line.startsWith('%exit')) {
+				this._connected = false;
+				this.emit('exit', line.slice(6).trim());
+			}
+			// Ignore %begin, %end, %error — those are command responses
+		});
+
+		this.proc.on('close', (code) => {
+			this._connected = false;
+			this.proc = null;
+			if (!this._detached) {
+				// Auto-reconnect after 1 second
+				this.reconnectTimer = setTimeout(() => this.connect(), 1000);
+			}
+			this.emit('close', code);
+		});
+
+		this._connected = true;
+	}
+
+	private handleOutput(line: string): void {
+		// Format: %output %<pane_id> <data>
+		// Find pane ID: starts after "%output " and is like "%0", "%42"
+		const afterOutput = line.substring(8); // skip "%output "
+		const spaceIdx = afterOutput.indexOf(' ');
+		if (spaceIdx === -1) return;
+
+		const paneId = afterOutput.substring(0, spaceIdx);
+		const rawData = afterOutput.substring(spaceIdx + 1);
+		const data = decodeOctalEscapes(rawData);
+		this.emit('output', paneId, data);
+	}
+
+	/**
+	 * Send raw input bytes to a pane using hex mode.
+	 * Converts each byte to two-digit hex for send-keys -H.
+	 */
+	sendKeys(paneId: string, data: string): void {
+		if (!this.proc?.stdin?.writable) return;
+		const buf = Buffer.from(data, 'utf-8');
+		const hex = Array.from(buf)
+			.map((b) => b.toString(16).padStart(2, '0'))
+			.join(' ');
+		this.proc.stdin.write(`send-keys -H -t '${paneId}' ${hex}\n`);
+	}
+
+	/**
+	 * Resize the control client's view.
+	 */
+	resizeClient(cols: number, rows: number): void {
+		if (!this.proc?.stdin?.writable) return;
+		this.proc.stdin.write(`refresh-client -C ${cols},${rows}\n`);
+	}
+
+	/**
+	 * Detach and clean up the control connection.
+	 */
+	detach(): void {
+		this._detached = true;
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		if (this.proc) {
+			this.proc.stdin?.end();
+			this.proc.kill();
+			this.proc = null;
+		}
+		this._connected = false;
+		this.removeAllListeners();
+	}
+}
+
+export interface TmuxSession {
+	id: string;
+	name: string;
+	windows: number;
+	attached: number;
+	created: number;
+}
+
+export interface TmuxWindow {
+	id: string;
+	name: string;
+	panes: number;
+	active: boolean;
+	sessionId: string;
+	width: number;
+	height: number;
+}
+
+export interface TmuxPane {
+	id: string;
+	windowId: string;
+	active: boolean;
+	pid: number;
+	command: string;
+	title: string;
+	left: number;
+	top: number;
+	width: number;
+	height: number;
+	dead: boolean;
+}
+
+/**
+ * Run a tmux command and return stdout.
+ */
+function tmuxExec(args: string): string {
+	return execSync(`tmux ${args}`, { encoding: 'utf-8', timeout: 5000 }).trim();
+}
+
+export class TmuxControl extends EventEmitter {
+	/**
+	 * List all tmux sessions.
+	 */
+	listSessions(): TmuxSession[] {
+		try {
+			const output = tmuxExec(
+				"list-sessions -F '#{session_id}|#{session_name}|#{session_windows}|#{session_attached}|#{session_created}'"
+			);
+			if (!output) return [];
+			return output.split('\n').map((line) => {
+				const [id, name, windows, attached, created] = line.split('|');
+				return {
+					id,
+					name,
+					windows: Number.parseInt(windows, 10),
+					attached: Number.parseInt(attached, 10),
+					created: Number.parseInt(created, 10),
+				};
+			});
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * List all windows across all sessions.
+	 */
+	listWindows(): TmuxWindow[] {
+		try {
+			const output = tmuxExec(
+				"list-windows -a -F '#{window_id}|#{window_name}|#{window_panes}|#{window_active}|#{session_id}|#{window_width}|#{window_height}'"
+			);
+			if (!output) return [];
+			return output.split('\n').map((line) => {
+				const [id, name, panes, active, sessionId, width, height] = line.split('|');
+				return {
+					id,
+					name,
+					panes: Number.parseInt(panes, 10),
+					active: active === '1',
+					sessionId,
+					width: Number.parseInt(width, 10),
+					height: Number.parseInt(height, 10),
+				};
+			});
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * List all panes across all sessions.
+	 */
+	listPanes(): TmuxPane[] {
+		try {
+			const output = tmuxExec(
+				"list-panes -a -F '#{pane_id}|#{window_id}|#{pane_active}|#{pane_pid}|#{pane_current_command}|#{pane_title}|#{pane_left}|#{pane_top}|#{pane_width}|#{pane_height}|#{pane_dead}'"
+			);
+			if (!output) return [];
+			return output.split('\n').map((line) => {
+				const [id, windowId, active, pid, command, title, left, top, width, height, dead] = line.split('|');
+				return {
+					id,
+					windowId,
+					active: active === '1',
+					pid: Number.parseInt(pid, 10),
+					command,
+					title,
+					left: Number.parseInt(left, 10),
+					top: Number.parseInt(top, 10),
+					width: Number.parseInt(width, 10),
+					height: Number.parseInt(height, 10),
+					dead: dead === '1',
+				};
+			});
+		} catch {
+			return [];
+		}
+	}
+
+	/**
+	 * Capture pane content (snapshot).
+	 */
+	capturePane(paneId: string, lines = 50): string {
+		try {
+			return tmuxExec(`capture-pane -t '${paneId}' -p -S ${-lines} -J`);
+		} catch {
+			return '';
+		}
+	}
+
+	/**
+	 * Send keys to a pane.
+	 */
+	sendKeys(paneId: string, keys: string): void {
+		const escaped = keys.replace(/'/g, "'\\''");
+		tmuxExec(`send-keys -t '${paneId}' -l '${escaped}'`);
+		tmuxExec(`send-keys -t '${paneId}' Enter`);
+	}
+
+	/**
+	 * Attach to an existing tmux session in control mode.
+	 * Returns a ControlSession that streams pane output and accepts input.
+	 * Creates zero additional tmux sessions.
+	 */
+	attachSession(sessionName: string): ControlSession {
+		return new ControlSession(sessionName);
+	}
+}