heyio 1.13.0 → 3.0.1

package/src/api/routes/config.ts

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { Router } from 'express';
+import { loadConfig } from '../../config.js';
+
+export function configRouter(): Router {
+	const router = Router();
+
+	function getConfigPath(): string {
+		const dataDir = process.env.IO_DATA_DIR ?? join(homedir(), '.io');
+		const resolved = dataDir.startsWith('~') ? join(homedir(), dataDir.slice(1)) : dataDir;
+		return join(resolved, 'config.json');
+	}
+
+	/**
+	 * GET /api/config
+	 * Return current config with sensitive fields redacted.
+	 */
+	router.get('/config', (_req, res) => {
+		try {
+			const config = loadConfig();
+			// Redact sensitive fields
+			const redacted = {
+				apiPort: config.apiPort,
+				logLevel: config.logLevel,
+				defaultModel: config.defaultModel,
+				maxInstancesPerSquad: config.maxInstancesPerSquad,
+				dataDir: config.dataDir,
+				pricing: config.pricing,
+				telegram: {
+					botToken: config.telegram.botToken ? '••••••••' : null,
+					allowedChatIds: config.telegram.allowedChatIds,
+				},
+				supabase: {
+					projectUrl: config.supabase.projectUrl,
+					anonKey: config.supabase.anonKey,
+					jwtSecret: config.supabase.jwtSecret ? '••••••••' : null,
+				},
+			};
+			res.json({ config: redacted });
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to load config' });
+		}
+	});
+
+	/**
+	 * PATCH /api/config
+	 * Merge partial config into config.json on disk.
+	 * Does NOT accept dataDir changes (immutable).
+	 * Body: partial config object
+	 */
+	router.patch('/config', (req, res) => {
+		try {
+			const updates = req.body as Record<string, any>;
+
+			if (!updates || typeof updates !== 'object') {
+				res.status(400).json({ error: 'Body must be a JSON object' });
+				return;
+			}
+
+			// Disallow changing dataDir (would break running daemon)
+			delete updates.dataDir;
+
+			const configPath = getConfigPath();
+			let existing: Record<string, any> = {};
+			if (existsSync(configPath)) {
+				existing = JSON.parse(readFileSync(configPath, 'utf-8'));
+			}
+
+			// Deep merge one level (telegram, pricing)
+			const merged = { ...existing };
+			for (const [key, value] of Object.entries(updates)) {
+				if (
+					value !== null &&
+					typeof value === 'object' &&
+					!Array.isArray(value) &&
+					typeof merged[key] === 'object'
+				) {
+					merged[key] = { ...merged[key], ...value };
+				} else {
+					merged[key] = value;
+				}
+			}
+
+			writeFileSync(configPath, JSON.stringify(merged, null, 2), 'utf-8');
+
+			// Reload and return redacted
+			const config = loadConfig();
+			res.json({
+				config: {
+					apiPort: config.apiPort,
+					logLevel: config.logLevel,
+					defaultModel: config.defaultModel,
+					maxInstancesPerSquad: config.maxInstancesPerSquad,
+					dataDir: config.dataDir,
+					pricing: config.pricing,
+					telegram: {
+						botToken: config.telegram.botToken ? '••••••••' : null,
+						allowedChatIds: config.telegram.allowedChatIds,
+					},
+					supabase: {
+						projectUrl: config.supabase.projectUrl,
+						anonKey: config.supabase.anonKey,
+						jwtSecret: config.supabase.jwtSecret ? '••••••••' : null,
+					},
+				},
+			});
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to update config' });
+		}
+	});
+
+	return router;
+}

package/src/api/routes/conversations.ts

@@ -0,0 +1,87 @@
+import { Router } from 'express';
+import { getDatabase } from '../../store/db.js';
+
+export function conversationsRouter(): Router {
+	const router = Router();
+
+	/**
+	 * GET /api/conversations
+	 * Load chat history with cursor-based pagination.
+	 * Query params: limit (default 50), before (message id for pagination)
+	 */
+	router.get('/conversations', async (req, res) => {
+		try {
+			const limit = Math.min(Number.parseInt(req.query.limit as string, 10) || 50, 200);
+			const before = req.query.before as string | undefined;
+
+			const db = getDatabase();
+
+			let rows: Array<{
+				id: string;
+				role: string;
+				content: string;
+				source: string | null;
+				attachments: string | null;
+				created_at: string;
+			}>;
+
+			if (before) {
+				// Get the timestamp of the cursor message
+				const cursorResult = await db.execute({
+					sql: 'SELECT created_at FROM conversations WHERE id = ?',
+					args: [before],
+				});
+
+				if (cursorResult.rows.length === 0) {
+					res.status(400).json({ error: 'Invalid cursor: message not found' });
+					return;
+				}
+
+				const cursorTime = cursorResult.rows[0].created_at as string;
+
+				const result = await db.execute({
+					sql: `SELECT id, role, content, source, attachments, created_at
+						FROM conversations
+						WHERE created_at < ? OR (created_at = ? AND id < ?)
+						ORDER BY created_at DESC, id DESC
+						LIMIT ?`,
+					args: [cursorTime, cursorTime, before, limit],
+				});
+
+				rows = result.rows as any;
+			} else {
+				const result = await db.execute({
+					sql: `SELECT id, role, content, source, attachments, created_at
+						FROM conversations
+						ORDER BY created_at DESC, id DESC
+						LIMIT ?`,
+					args: [limit],
+				});
+
+				rows = result.rows as any;
+			}
+
+			// Reverse so messages are in chronological order
+			const messages = rows.reverse().map((row) => ({
+				id: row.id,
+				role: row.role,
+				content: row.content,
+				source: row.source,
+				attachments: row.attachments ? JSON.parse(row.attachments) : null,
+				timestamp: row.created_at,
+			}));
+
+			const cursor = rows.length > 0 ? rows[0].id : null;
+
+			res.json({
+				messages,
+				cursor,
+				hasMore: rows.length === limit,
+			});
+		} catch (err) {
+			res.status(500).json({ error: 'Failed to load conversations' });
+		}
+	});
+
+	return router;
+}

package/src/api/routes/health.ts

@@ -0,0 +1,18 @@
+import { Router } from 'express';
+import { getHealthStatus } from '../../copilot/health-monitor.js';
+
+export function healthRouter(): Router {
+	const router = Router();
+
+	router.get('/health', (_req, res) => {
+		const health = getHealthStatus();
+		res.json({
+			status: health.status,
+			uptime: health.uptime,
+			copilotConnected: health.copilotConnected,
+			lastCheck: health.lastCheck.toISOString(),
+		});
+	});
+
+	return router;
+}

package/src/api/routes/inbox.ts

@@ -0,0 +1,98 @@
+import { Router } from 'express';
+import {
+	type InboxKind,
+	type InboxStatus,
+	getInboxEntry,
+	getUnreadCount,
+	listInboxEntries,
+	markInboxRead,
+	resolveInboxEntry,
+} from '../../store/inbox.js';
+
+export function inboxRouter(): Router {
+	const router = Router();
+
+	/**
+	 * GET /api/inbox
+	 * List inbox entries with optional filters.
+	 * Query params: status, squad, kind, limit
+	 */
+	router.get('/inbox', async (req, res) => {
+		try {
+			const entries = await listInboxEntries({
+				status: req.query.status as InboxStatus | undefined,
+				squadId: req.query.squad as string | undefined,
+				kind: req.query.kind as InboxKind | undefined,
+				limit: req.query.limit ? Number.parseInt(req.query.limit as string, 10) : undefined,
+			});
+			res.json({ entries });
+		} catch {
+			res.status(500).json({ error: 'Failed to list inbox entries' });
+		}
+	});
+
+	/**
+	 * GET /api/inbox/unread-count
+	 * Get the number of unread inbox entries.
+	 */
+	router.get('/inbox/unread-count', async (_req, res) => {
+		try {
+			const count = await getUnreadCount();
+			res.json({ count });
+		} catch {
+			res.status(500).json({ error: 'Failed to get unread count' });
+		}
+	});
+
+	/**
+	 * GET /api/inbox/:id
+	 * Get a single inbox entry.
+	 */
+	router.get('/inbox/:id', async (req, res) => {
+		try {
+			const entry = await getInboxEntry(req.params.id);
+			if (!entry) {
+				res.status(404).json({ error: 'Entry not found' });
+				return;
+			}
+			res.json({ entry });
+		} catch {
+			res.status(500).json({ error: 'Failed to get inbox entry' });
+		}
+	});
+
+	/**
+	 * POST /api/inbox/:id/read
+	 * Mark an entry as read.
+	 */
+	router.post('/inbox/:id/read', async (req, res) => {
+		try {
+			await markInboxRead(req.params.id);
+			res.json({ status: 'ok' });
+		} catch {
+			res.status(500).json({ error: 'Failed to mark entry as read' });
+		}
+	});
+
+	/**
+	 * POST /api/inbox/:id/respond
+	 * Respond to an inbox question. Resolves any blocking squad.
+	 * Body: { response: string }
+	 */
+	router.post('/inbox/:id/respond', async (req, res) => {
+		try {
+			const { response } = req.body as { response?: string };
+			if (!response) {
+				res.status(400).json({ error: 'response is required' });
+				return;
+			}
+
+			const unblocked = await resolveInboxEntry(req.params.id, response);
+			res.json({ status: 'ok', squadUnblocked: unblocked });
+		} catch {
+			res.status(500).json({ error: 'Failed to respond to entry' });
+		}
+	});
+
+	return router;
+}

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;
+}