heyio 3.0.2 → 3.0.3

package/src/api/server.ts

@@ -1,186 +0,0 @@
-import { existsSync } from 'node:fs';
-import { createServer } from 'node:http';
-import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import express from 'express';
-import { type WebSocket, WebSocketServer } from 'ws';
-import type { IOConfig } from '../config.js';
-import { sendMessage } from '../copilot/orchestrator.js';
-import { createChildLogger } from '../logging/logger.js';
-import { authMiddleware, verifyWsToken } from './middleware/auth.js';
-import { initNotifications, subscribeClient, unsubscribeClient } from './notifications.js';
-import { activityRouter } from './routes/activity.js';
-import { attachmentsRouter } from './routes/attachments.js';
-import { configRouter } from './routes/config.js';
-import { conversationsRouter } from './routes/conversations.js';
-import { healthRouter } from './routes/health.js';
-import { inboxRouter } from './routes/inbox.js';
-import { schedulesRouter } from './routes/schedules.js';
-import { skillsRouter } from './routes/skills.js';
-import { squadsRouter } from './routes/squads.js';
-import { usageRouter } from './routes/usage.js';
-import { wikiRouter } from './routes/wiki.js';
-
-export interface ApiServer {
-	start(): Promise<void>;
-	stop(): Promise<void>;
-}
-
-// Connected WebSocket clients keyed by connection ID
-const wsClients = new Map<string, WebSocket>();
-
-export function createApiServer(config: IOConfig): ApiServer {
-	const logger = createChildLogger('api');
-	const app = express();
-	app.use(express.json());
-
-	// Auth middleware — verifies Supabase JWT if configured
-	app.use('/api', authMiddleware(config));
-
-	// Routes
-	app.use('/api', healthRouter());
-	app.use('/api', usageRouter());
-	app.use('/api', squadsRouter());
-	app.use('/api', activityRouter());
-	app.use('/api', attachmentsRouter(config.dataDir));
-	app.use('/api', inboxRouter());
-	app.use('/api', schedulesRouter());
-	app.use('/api', conversationsRouter());
-	app.use('/api', configRouter());
-	app.use('/api/wiki', wikiRouter);
-	app.use('/api', skillsRouter);
-
-	// POST /api/messages — send a message to the orchestrator
-	app.post('/api/messages', async (req, res) => {
-		const { content, source, connectionId } = req.body as {
-			content?: string;
-			source?: 'tui' | 'telegram' | 'web';
-			connectionId?: string;
-		};
-
-		if (!content) {
-			res.status(400).json({ error: 'content is required' });
-			return;
-		}
-
-		const ws = connectionId ? wsClients.get(connectionId) : undefined;
-
-		const onDelta = (accumulated: string, done: boolean) => {
-			if (ws && ws.readyState === ws.OPEN) {
-				ws.send(
-					JSON.stringify({
-						type: done ? 'message' : 'delta',
-						content: accumulated,
-					}),
-				);
-			}
-		};
-
-		try {
-			const response = await sendMessage(content, source ?? 'web', onDelta);
-			res.json({ status: 'ok', content: response });
-		} catch (err) {
-			logger.error({ err }, 'Error processing message');
-			res.status(500).json({ error: 'Failed to process message' });
-		}
-	});
-
-	// Serve web frontend static files (production build)
-	const __dirname = fileURLToPath(new URL('.', import.meta.url));
-	const webDistPath = resolve(__dirname, '../../../web/dist');
-	if (existsSync(webDistPath)) {
-		app.use(express.static(webDistPath));
-		// SPA fallback: serve index.html for any non-API route
-		app.get('*', (_req, res) => {
-			res.sendFile(join(webDistPath, 'index.html'));
-		});
-		logger.info({ path: webDistPath }, 'Serving web frontend');
-	}
-
-	const server = createServer(app);
-
-	// WebSocket server for streaming
-	const wss = new WebSocketServer({ server, path: '/ws' });
-
-	wss.on('connection', (ws, req) => {
-		// Verify token from query string if auth is configured
-		const url = new URL(req.url ?? '', `http://${req.headers.host}`);
-		const token = url.searchParams.get('token');
-		if (!verifyWsToken(config, token)) {
-			ws.close(4001, 'Unauthorized');
-			return;
-		}
-		const connectionId = crypto.randomUUID();
-		wsClients.set(connectionId, ws);
-		subscribeClient(connectionId, ws);
-		logger.info({ connectionId }, 'WebSocket client connected');
-
-		// Send the connection ID to the client
-		ws.send(JSON.stringify({ type: 'connected', connectionId }));
-
-		ws.on('message', (data) => {
-			try {
-				const parsed = JSON.parse(data.toString()) as {
-					type?: string;
-					content?: string;
-					source?: string;
-				};
-
-				if (parsed.type === 'message' && parsed.content) {
-					const source = (parsed.source as 'tui' | 'telegram' | 'web') ?? 'tui';
-
-					const onDelta = (accumulated: string, done: boolean) => {
-						if (ws.readyState === ws.OPEN) {
-							ws.send(
-								JSON.stringify({
-									type: done ? 'message' : 'delta',
-									content: accumulated,
-								}),
-							);
-						}
-					};
-
-					sendMessage(parsed.content, source, onDelta).catch((err) => {
-						logger.error({ err }, 'Error processing WebSocket message');
-						if (ws.readyState === ws.OPEN) {
-							ws.send(JSON.stringify({ type: 'error', content: 'Failed to process message' }));
-						}
-					});
-				}
-			} catch (err) {
-				logger.error({ err }, 'Failed to parse WebSocket message');
-			}
-		});
-
-		ws.on('close', () => {
-			wsClients.delete(connectionId);
-			unsubscribeClient(connectionId);
-			logger.info({ connectionId }, 'WebSocket client disconnected');
-		});
-	});
-
-	return {
-		async start() {
-			return new Promise<void>((resolve) => {
-				server.listen(config.apiPort, () => {
-					logger.info({ port: config.apiPort }, 'API server listening');
-					resolve();
-				});
-			});
-		},
-
-		async stop() {
-			return new Promise<void>((resolve, reject) => {
-				for (const ws of wsClients.values()) {
-					ws.close();
-				}
-				wsClients.clear();
-				wss.close();
-				server.close((err) => {
-					if (err) reject(err);
-					else resolve();
-				});
-			});
-		},
-	};
-}

package/src/config.ts

@@ -1,3 +0,0 @@
-// Re-export shared config loader
-export { loadConfig } from '@io/shared';
-export type { IOConfig } from '@io/shared';

package/src/copilot/client.ts

@@ -1,42 +0,0 @@
-import { CopilotClient } from '@github/copilot-sdk';
-import type { Logger } from 'pino';
-import { createChildLogger } from '../logging/logger.js';
-
-let client: CopilotClient | undefined;
-let logger: Logger;
-
-function getLogger(): Logger {
-	if (!logger) {
-		logger = createChildLogger('copilot-client');
-	}
-	return logger;
-}
-
-export async function getClient(): Promise<CopilotClient> {
-	if (!client) {
-		client = new CopilotClient();
-		await client.start();
-		getLogger().info('Copilot client started');
-	}
-	return client;
-}
-
-export async function resetClient(): Promise<void> {
-	if (client) {
-		getLogger().warn('Resetting Copilot client');
-		try {
-			await client.stop();
-		} catch (err) {
-			getLogger().error({ err }, 'Error stopping client during reset');
-		}
-		client = undefined;
-	}
-}
-
-export async function stopClient(): Promise<void> {
-	if (client) {
-		await client.stop();
-		client = undefined;
-		getLogger().info('Copilot client stopped');
-	}
-}

package/src/copilot/health-monitor.ts

@@ -1,85 +0,0 @@
-import { createChildLogger } from '../logging/logger.js';
-import { getClient, resetClient } from './client.js';
-
-const logger = () => createChildLogger('health-monitor');
-
-let healthCheckInterval: ReturnType<typeof setInterval> | null = null;
-let startTime: number = Date.now();
-
-export interface HealthStatus {
-	status: 'healthy' | 'degraded' | 'unhealthy';
-	uptime: number;
-	copilotConnected: boolean;
-	lastCheck: Date;
-}
-
-let lastStatus: HealthStatus = {
-	status: 'healthy',
-	uptime: 0,
-	copilotConnected: false,
-	lastCheck: new Date(),
-};
-
-/**
- * Start periodic health monitoring of the Copilot SDK connection.
- * Attempts reconnect if connection is lost.
- */
-export function startHealthMonitor(intervalMs = 30_000): void {
-	startTime = Date.now();
-
-	healthCheckInterval = setInterval(async () => {
-		await checkHealth();
-	}, intervalMs);
-
-	// Initial check
-	checkHealth();
-}
-
-export function stopHealthMonitor(): void {
-	if (healthCheckInterval) {
-		clearInterval(healthCheckInterval);
-		healthCheckInterval = null;
-	}
-}
-
-export function getHealthStatus(): HealthStatus {
-	return {
-		...lastStatus,
-		uptime: Math.floor((Date.now() - startTime) / 1000),
-	};
-}
-
-async function checkHealth(): Promise<void> {
-	const log = logger();
-
-	try {
-		// Verify we can get the client (it auto-starts if needed)
-		const client = await getClient();
-		lastStatus = {
-			status: 'healthy',
-			uptime: Math.floor((Date.now() - startTime) / 1000),
-			copilotConnected: true,
-			lastCheck: new Date(),
-		};
-	} catch (err) {
-		log.warn({ err }, 'Health check failed — Copilot client unavailable');
-		lastStatus = {
-			status: 'unhealthy',
-			uptime: Math.floor((Date.now() - startTime) / 1000),
-			copilotConnected: false,
-			lastCheck: new Date(),
-		};
-
-		// Attempt reconnect
-		try {
-			log.info('Attempting Copilot client reconnect...');
-			await resetClient();
-			await getClient();
-			log.info('Copilot client reconnected successfully');
-			lastStatus.status = 'healthy';
-			lastStatus.copilotConnected = true;
-		} catch (reconnectErr) {
-			log.error({ err: reconnectErr }, 'Reconnect failed');
-		}
-	}
-}

package/src/copilot/orchestrator.ts

@@ -1,222 +0,0 @@
-import { approveAll } from '@github/copilot-sdk';
-import type { IOConfig } from '../config.js';
-import { createChildLogger } from '../logging/logger.js';
-import { getActiveSkillsContent } from '../skills/index.js';
-import { listSquads } from '../squad/manager.js';
-import { getDatabase } from '../store/db.js';
-import { getOrchestratorScopes, getPageListing } from '../wiki/index.js';
-import { getClient } from './client.js';
-import { createOrchestratorTools } from './tools.js';
-
-type Session = Awaited<ReturnType<Awaited<ReturnType<typeof getClient>>['createSession']>>;
-
-let logger: ReturnType<typeof createChildLogger>;
-
-let session: Session | undefined;
-let sessionId: string | undefined;
-
-interface QueuedMessage {
-	prompt: string;
-	source?: 'tui' | 'telegram' | 'web';
-	onDelta: (accumulated: string, done: boolean) => void;
-	resolve: (value: string) => void;
-	reject: (reason: unknown) => void;
-}
-
-const messageQueue: QueuedMessage[] = [];
-let processing = false;
-
-const SYSTEM_MESSAGE_BASE = `You are IO, an AI orchestrator daemon. You help users manage their software projects through intelligent conversation and by coordinating specialized agent squads.
-
-## Your Capabilities
-- Answer general questions directly
-- Manage squads: create, monitor, and coordinate teams of AI agents for specific projects
-- Delegate project-specific work to the appropriate squad's team lead
-- Track token usage and costs across all squads
-- Manage the inbox: squads send you deliverables and questions that need user attention
-
-## Routing Rules
-- If the user's message relates to a project that has an assigned squad, ALWAYS delegate to that squad using the delegate_to_squad tool
-- If the user asks about squad status, use the appropriate squad tools
-- For general questions unrelated to any squad's project, answer directly
-- NEVER answer project-specific questions yourself if a squad exists for that project
-
-## Inbox Rules
-- When a squad has a pending question, proactively tell the user about it
-- Use list_inbox to check for unread items when the user asks about notifications or inbox
-- When the user answers a squad's question, use respond_to_inbox to deliver their response and unblock the squad
-- Summarize deliverables in a friendly, readable way when presenting them to the user
-`;
-
-/**
- * Build the system message with current squad registry context.
- */
-async function buildSystemMessage(): Promise<string> {
-	try {
-		const squads = await listSquads();
-		const wikiListing = getPageListing(getOrchestratorScopes());
-		const skillsContent = await getActiveSkillsContent('orchestrator');
-
-		const wikiSection = `\n## Wiki Knowledge\n${wikiListing}\n\nUse read_wiki to access page content. Use write_wiki to record important knowledge.\n`;
-
-		if (squads.length === 0) {
-			return `${SYSTEM_MESSAGE_BASE}\n## Active Squads\n(No squads currently active)${wikiSection}${skillsContent}`;
-		}
-
-		const squadList = squads
-			.map(
-				(s) =>
-					`- **${s.name}**: project at \`${s.projectPath}\`${s.repoUrl ? ` (${s.repoUrl})` : ''} [autonomy: ${s.autonomyTier}]`,
-			)
-			.join('\n');
-
-		return `${SYSTEM_MESSAGE_BASE}\n## Active Squads\n${squadList}\n\nWhen a user's message mentions any of the above projects (by name, path, or related topic), delegate to the corresponding squad.${wikiSection}${skillsContent}`;
-	} catch {
-		return `${SYSTEM_MESSAGE_BASE}\n## Active Squads\n(Unable to load squad registry)\n`;
-	}
-}
-
-export async function initOrchestrator(config: IOConfig): Promise<void> {
-	logger = createChildLogger('orchestrator');
-	const client = await getClient();
-
-	const systemMessage = await buildSystemMessage();
-
-	const sessionOptions = {
-		model: config.defaultModel,
-		streaming: true,
-		tools: createOrchestratorTools(),
-		systemMessage: { mode: 'replace' as const, content: systemMessage },
-		onPermissionRequest: approveAll,
-		infiniteSessions: {
-			enabled: true,
-			backgroundCompactionThreshold: 0.8,
-			bufferExhaustionThreshold: 0.95,
-		},
-	};
-
-	// Try to resume existing session
-	const savedSessionId = await getSavedSessionId();
-	if (savedSessionId) {
-		try {
-			session = await client.resumeSession(savedSessionId, sessionOptions);
-			sessionId = savedSessionId;
-			logger.info({ sessionId }, 'Resumed orchestrator session');
-			return;
-		} catch (err) {
-			logger.warn({ err, sessionId: savedSessionId }, 'Failed to resume session, creating new one');
-		}
-	}
-
-	// Create new session
-	session = await client.createSession(sessionOptions);
-	sessionId = session.sessionId;
-	await saveSessionId(sessionId);
-	logger.info({ sessionId }, 'Created new orchestrator session');
-}
-
-export function sendMessage(
-	prompt: string,
-	source: 'tui' | 'telegram' | 'web',
-	onDelta: (accumulated: string, done: boolean) => void,
-): Promise<string> {
-	return new Promise((resolve, reject) => {
-		messageQueue.push({ prompt, source, onDelta, resolve, reject });
-		processQueue();
-	});
-}
-
-async function processQueue(): Promise<void> {
-	if (processing || messageQueue.length === 0) return;
-	processing = true;
-
-	while (messageQueue.length > 0) {
-		const msg = messageQueue.shift()!;
-		try {
-			const response = await processMessage(msg);
-			msg.resolve(response);
-		} catch (err) {
-			logger.error({ err }, 'Error processing message');
-			msg.reject(err);
-		}
-	}
-
-	processing = false;
-}
-
-async function processMessage(msg: QueuedMessage): Promise<string> {
-	if (!session) {
-		throw new Error('Orchestrator session not initialized');
-	}
-
-	let accumulated = '';
-
-	// Subscribe to streaming deltas
-	const unsubDelta = session.on('assistant.message_delta', (event) => {
-		accumulated += event.data.deltaContent;
-		msg.onDelta(accumulated, false);
-	});
-
-	try {
-		const result = await session.sendAndWait(
-			{ prompt: msg.prompt },
-			600_000, // 10 minute timeout
-		);
-
-		const finalContent = result?.data?.content || accumulated || '(No response)';
-		msg.onDelta(finalContent, true);
-
-		// Persist conversation (fire-and-forget)
-		persistConversation(msg.prompt, finalContent, msg.source);
-
-		return finalContent;
-	} finally {
-		unsubDelta();
-	}
-}
-
-export async function destroyOrchestrator(): Promise<void> {
-	session = undefined;
-	sessionId = undefined;
-}
-
-async function getSavedSessionId(): Promise<string | undefined> {
-	try {
-		const db = getDatabase();
-		const result = await db.execute(
-			"SELECT value FROM io_state WHERE key = 'orchestrator_session_id'",
-		);
-		if (result.rows.length > 0) {
-			return result.rows[0].value as string;
-		}
-		return undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-async function saveSessionId(id: string): Promise<void> {
-	const db = getDatabase();
-	await db.execute({
-		sql: "INSERT OR REPLACE INTO io_state (key, value) VALUES ('orchestrator_session_id', ?)",
-		args: [id],
-	});
-}
-
-function persistConversation(
-	userMessage: string,
-	assistantResponse: string,
-	source?: string,
-): void {
-	const db = getDatabase();
-	const now = new Date().toISOString();
-
-	db.execute({
-		sql: "INSERT INTO conversations (id, role, content, source, created_at) VALUES (?, 'user', ?, ?, ?)",
-		args: [crypto.randomUUID(), userMessage, source ?? null, now],
-	});
-	db.execute({
-		sql: "INSERT INTO conversations (id, role, content, source, created_at) VALUES (?, 'assistant', ?, ?, ?)",
-		args: [crypto.randomUUID(), assistantResponse, source ?? null, now],
-	});
-}