heyio 1.12.1 → 3.0.0

package/src/api/routes/schedules.ts

@@ -0,0 +1,121 @@
+import { Router } from 'express';
+import {
+	type ScheduleTargetType,
+	createSchedule,
+	deleteSchedule,
+	getSchedule,
+	listSchedules,
+	updateSchedule,
+} from '../../store/schedules.js';
+
+export function schedulesRouter(): Router {
+	const router = Router();
+
+	/**
+	 * GET /api/schedules
+	 * List all schedules. Query param: enabled=true to filter.
+	 */
+	router.get('/schedules', async (req, res) => {
+		try {
+			const enabledOnly = req.query.enabled === 'true';
+			const schedules = await listSchedules(enabledOnly || undefined);
+			res.json({ schedules });
+		} catch {
+			res.status(500).json({ error: 'Failed to list schedules' });
+		}
+	});
+
+	/**
+	 * GET /api/schedules/:id
+	 * Get a single schedule.
+	 */
+	router.get('/schedules/:id', async (req, res) => {
+		try {
+			const schedule = await getSchedule(req.params.id);
+			if (!schedule) {
+				res.status(404).json({ error: 'Schedule not found' });
+				return;
+			}
+			res.json({ schedule });
+		} catch {
+			res.status(500).json({ error: 'Failed to get schedule' });
+		}
+	});
+
+	/**
+	 * POST /api/schedules
+	 * Create a new schedule.
+	 * Body: { name, targetType, targetId?, cron, prompt, enabled? }
+	 */
+	router.post('/schedules', async (req, res) => {
+		try {
+			const { name, targetType, targetId, cron, prompt, enabled } = req.body as {
+				name?: string;
+				targetType?: ScheduleTargetType;
+				targetId?: string;
+				cron?: string;
+				prompt?: string;
+				enabled?: boolean;
+			};
+
+			if (!name || !targetType || !cron || !prompt) {
+				res.status(400).json({ error: 'name, targetType, cron, and prompt are required' });
+				return;
+			}
+
+			if (targetType !== 'squad' && targetType !== 'orchestrator') {
+				res.status(400).json({ error: 'targetType must be "squad" or "orchestrator"' });
+				return;
+			}
+
+			const schedule = await createSchedule({ name, targetType, targetId, cron, prompt, enabled });
+			res.status(201).json({ schedule });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : 'Failed to create schedule';
+			res.status(400).json({ error: msg });
+		}
+	});
+
+	/**
+	 * PATCH /api/schedules/:id
+	 * Update a schedule (partial). Body: { name?, cron?, prompt?, enabled? }
+	 */
+	router.patch('/schedules/:id', async (req, res) => {
+		try {
+			const existing = await getSchedule(req.params.id);
+			if (!existing) {
+				res.status(404).json({ error: 'Schedule not found' });
+				return;
+			}
+
+			const { name, cron, prompt, enabled } = req.body as {
+				name?: string;
+				cron?: string;
+				prompt?: string;
+				enabled?: boolean;
+			};
+
+			await updateSchedule(req.params.id, { name, cron, prompt, enabled });
+			const updated = await getSchedule(req.params.id);
+			res.json({ schedule: updated });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : 'Failed to update schedule';
+			res.status(400).json({ error: msg });
+		}
+	});
+
+	/**
+	 * DELETE /api/schedules/:id
+	 * Delete a schedule.
+	 */
+	router.delete('/schedules/:id', async (req, res) => {
+		try {
+			await deleteSchedule(req.params.id);
+			res.json({ status: 'ok' });
+		} catch {
+			res.status(500).json({ error: 'Failed to delete schedule' });
+		}
+	});
+
+	return router;
+}

package/src/api/routes/skills.ts

@@ -0,0 +1,105 @@
+import { Router } from 'express';
+import {
+	activateSkill,
+	deactivateSkill,
+	getActiveSkills,
+	getSkill,
+	installSkill,
+	installSkillFromUrl,
+	listInstalledSkills,
+	removeSkill,
+} from '../../skills/index.js';
+
+export const skillsRouter = Router();
+
+// List installed skills
+skillsRouter.get('/skills', async (_req, res) => {
+	const skills = listInstalledSkills();
+	const orchestratorActivations = await getActiveSkills('orchestrator');
+
+	const result = skills.map((s) => ({
+		name: s.name,
+		activatedForOrchestrator: orchestratorActivations.some((a) => a.skillName === s.name),
+		preview: s.content.slice(0, 200),
+	}));
+
+	res.json({ skills: result });
+});
+
+// Get a specific skill
+skillsRouter.get('/skills/:name', (req, res) => {
+	const skill = getSkill(req.params.name);
+	if (!skill) {
+		res.status(404).json({ error: `Skill '${req.params.name}' not found` });
+		return;
+	}
+	res.json(skill);
+});
+
+// Install a skill (from URL or content)
+skillsRouter.post('/skills/install', async (req, res) => {
+	const { name, url, content } = req.body;
+
+	if (!name) {
+		res.status(400).json({ error: 'name is required' });
+		return;
+	}
+
+	try {
+		if (url) {
+			const skill = await installSkillFromUrl(name, url);
+			res.status(201).json({ installed: true, name: skill.name });
+		} else if (content) {
+			const skill = installSkill(name, content);
+			res.status(201).json({ installed: true, name: skill.name });
+		} else {
+			res.status(400).json({ error: 'Either "url" or "content" is required' });
+		}
+	} catch (err) {
+		res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+	}
+});
+
+// Activate a skill
+skillsRouter.post('/skills/:name/activate', async (req, res) => {
+	const { targetType, targetId } = req.body;
+	if (!targetType || !['orchestrator', 'squad'].includes(targetType)) {
+		res.status(400).json({ error: 'targetType must be "orchestrator" or "squad"' });
+		return;
+	}
+
+	const skill = getSkill(req.params.name);
+	if (!skill) {
+		res.status(404).json({ error: `Skill '${req.params.name}' not found` });
+		return;
+	}
+
+	await activateSkill(req.params.name, targetType, targetId);
+	res.json({ activated: true, skillName: req.params.name, targetType, targetId });
+});
+
+// Deactivate a skill
+skillsRouter.post('/skills/:name/deactivate', async (req, res) => {
+	const { targetType, targetId } = req.body;
+	if (!targetType || !['orchestrator', 'squad'].includes(targetType)) {
+		res.status(400).json({ error: 'targetType must be "orchestrator" or "squad"' });
+		return;
+	}
+
+	await deactivateSkill(req.params.name, targetType, targetId);
+	res.json({ deactivated: true, skillName: req.params.name });
+});
+
+// Remove a skill
+skillsRouter.delete('/skills/:name', (req, res) => {
+	removeSkill(req.params.name);
+	res.status(204).end();
+});
+
+// Get activations for a target
+skillsRouter.get('/skills-activations', async (req, res) => {
+	const targetType = (req.query.targetType as string) ?? 'orchestrator';
+	const targetId = req.query.targetId as string | undefined;
+	const activations = await getActiveSkills(targetType as 'orchestrator' | 'squad', targetId);
+	res.json({ activations });
+});

package/src/api/routes/squads.ts

@@ -0,0 +1,145 @@
+import { Router } from 'express';
+import { getSquadInstances } from '../../squad/execution/instance.js';
+import { runInstance } from '../../squad/execution/runner.js';
+import { getSquadByName, getSquadMembers, listSquads } from '../../squad/manager.js';
+
+export function squadsRouter(): Router {
+	const router = Router();
+
+	/**
+	 * GET /api/squads
+	 * List all active squads.
+	 */
+	router.get('/squads', async (_req, res) => {
+		try {
+			const squads = await listSquads();
+			const results = await Promise.all(
+				squads.map(async (s) => {
+					const members = await getSquadMembers(s.id);
+					const instances = getSquadInstances(s.id);
+					return {
+						id: s.id,
+						name: s.name,
+						projectPath: s.projectPath,
+						repoUrl: s.repoUrl,
+						universe: s.universe,
+						autonomyTier: s.autonomyTier,
+						status: s.status,
+						memberCount: members.length,
+						activeInstances: instances.filter(
+							(i) => i.status !== 'complete' && i.status !== 'failed',
+						).length,
+						createdAt: s.createdAt.toISOString(),
+					};
+				}),
+			);
+			res.json({ squads: results });
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to list squads' });
+		}
+	});
+
+	/**
+	 * GET /api/squads/:name
+	 * Get detailed squad info.
+	 */
+	router.get('/squads/:name', async (req, res) => {
+		try {
+			const squad = await getSquadByName(req.params.name);
+			if (!squad) {
+				res.status(404).json({ error: `Squad '${req.params.name}' not found` });
+				return;
+			}
+
+			const members = await getSquadMembers(squad.id);
+			const instances = getSquadInstances(squad.id);
+
+			// Build a map of role -> current task (from active instances)
+			const currentTasks = new Map<string, string>();
+			for (const inst of instances) {
+				if (inst.status !== 'complete' && inst.status !== 'failed') {
+					for (const task of inst.tasks) {
+						if (task.status === 'in_progress') {
+							currentTasks.set(task.assignedTo, task.description);
+						}
+					}
+				}
+			}
+
+			res.json({
+				squad: {
+					id: squad.id,
+					name: squad.name,
+					projectPath: squad.projectPath,
+					repoUrl: squad.repoUrl,
+					universe: squad.universe,
+					autonomyTier: squad.autonomyTier,
+					autonomyConfig: squad.autonomyConfig,
+					status: squad.status,
+					createdAt: squad.createdAt.toISOString(),
+				},
+				members: members.map((m) => ({
+					id: m.id,
+					displayName: m.displayName,
+					role: m.roleName,
+					persona: m.persona,
+					veto: m.isVetoMember,
+					tools: m.toolsAllowed,
+					status: m.status,
+					currentTask: currentTasks.get(m.roleName) ?? null,
+				})),
+				instances: instances.map((i) => ({
+					id: i.id,
+					status: i.status,
+					issueRef: i.issueRef,
+					branch: i.branch,
+					taskCount: i.tasks.length,
+					tasksComplete: i.tasks.filter((t) => t.status === 'done').length,
+				})),
+			});
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to get squad' });
+		}
+	});
+
+	/**
+	 * POST /api/squads/:name/run
+	 * Spawn a new instance for a squad.
+	 * Body: { objective: string, issueRef?: string }
+	 */
+	router.post('/squads/:name/run', async (req, res) => {
+		try {
+			const squad = await getSquadByName(req.params.name);
+			if (!squad) {
+				res.status(404).json({ error: `Squad '${req.params.name}' not found` });
+				return;
+			}
+
+			const { objective, issueRef } = req.body as {
+				objective?: string;
+				issueRef?: string;
+			};
+
+			if (!objective) {
+				res.status(400).json({ error: 'objective is required' });
+				return;
+			}
+
+			// Run asynchronously — return immediately with instance ID
+			const instancePromise = runInstance({ squad, objective, issueRef });
+
+			// We don't await — return accepted status
+			// The client can poll /api/squads/:name for progress
+			instancePromise.catch(() => {}); // prevent unhandled rejection
+
+			res.status(202).json({
+				message: `Instance starting for squad '${squad.name}'`,
+				objective,
+			});
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to start instance' });
+		}
+	});
+
+	return router;
+}

package/src/api/routes/usage.ts

@@ -0,0 +1,57 @@
+import { Router } from 'express';
+import { getAllPricing, queryUsage, refreshPricing } from '../../models/index.js';
+
+export function usageRouter(): Router {
+	const router = Router();
+
+	/**
+	 * GET /api/usage
+	 * Query token usage with optional filters.
+	 * Query params: squadId, agentRole, model, since, until
+	 */
+	router.get('/usage', async (req, res) => {
+		try {
+			const filters = {
+				squadId: req.query.squadId as string | undefined,
+				agentRole: req.query.agentRole as string | undefined,
+				model: req.query.model as string | undefined,
+				since: req.query.since as string | undefined,
+				until: req.query.until as string | undefined,
+			};
+
+			const result = await queryUsage(filters);
+			res.json(result);
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to query usage' });
+		}
+	});
+
+	/**
+	 * GET /api/usage/pricing
+	 * Get current model pricing.
+	 */
+	router.get('/usage/pricing', async (_req, res) => {
+		try {
+			const pricing = await getAllPricing();
+			res.json({ pricing });
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to get pricing' });
+		}
+	});
+
+	/**
+	 * POST /api/usage/pricing/refresh
+	 * Trigger a pricing refresh.
+	 */
+	router.post('/usage/pricing/refresh', async (_req, res) => {
+		try {
+			await refreshPricing();
+			const pricing = await getAllPricing();
+			res.json({ message: 'Pricing refreshed', pricing });
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to refresh pricing' });
+		}
+	});
+
+	return router;
+}

package/src/api/routes/wiki.ts

@@ -0,0 +1,49 @@
+import { Router } from 'express';
+import { listWikiPages, readWikiPage, searchWiki, writeWikiPage } from '../../wiki/index.js';
+
+export const wikiRouter = Router();
+
+// List pages in a scope
+wikiRouter.get('/:scope', (req, res) => {
+	const { scope } = req.params;
+	const pages = listWikiPages(scope);
+	res.json({ scope, pages });
+});
+
+// Read a specific page
+wikiRouter.get('/:scope/:page', (req, res) => {
+	const { scope, page } = req.params;
+	const result = readWikiPage(scope, page);
+	if (!result) {
+		res.status(404).json({ error: `Page '${page}' not found in '${scope}' wiki` });
+		return;
+	}
+	res.json(result);
+});
+
+// Write (create/overwrite) a page
+wikiRouter.put('/:scope/:page', (req, res) => {
+	const { scope, page } = req.params;
+	const { content } = req.body;
+	if (!content || typeof content !== 'string') {
+		res.status(400).json({ error: 'Body must include "content" (string)' });
+		return;
+	}
+	const result = writeWikiPage(scope, page, content);
+	res.json(result);
+});
+
+// Search across scopes
+wikiRouter.get('/', (req, res) => {
+	const keyword = req.query.q as string;
+	const scopesParam = req.query.scopes as string | undefined;
+
+	if (!keyword) {
+		res.status(400).json({ error: 'Query parameter "q" is required' });
+		return;
+	}
+
+	const scopes = scopesParam ? scopesParam.split(',') : ['io', 'shared'];
+	const results = searchWiki(keyword, scopes);
+	res.json({ keyword, results });
+});

package/src/api/server.ts

@@ -0,0 +1,186 @@
+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

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