@sulala/agent 0.1.0

package/dist/db/schema.sql

@@ -0,0 +1,74 @@
+-- Sulala Agent — SQLite schema
+-- Tasks, Logs, File States, AI Results
+
+CREATE TABLE IF NOT EXISTS tasks (
+  id TEXT PRIMARY KEY,
+  type TEXT NOT NULL,
+  payload TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  scheduled_at INTEGER,
+  started_at INTEGER,
+  finished_at INTEGER,
+  retry_count INTEGER DEFAULT 0,
+  max_retries INTEGER DEFAULT 3,
+  error TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS logs (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source TEXT NOT NULL,
+  level TEXT NOT NULL,
+  message TEXT NOT NULL,
+  meta TEXT,
+  created_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS file_states (
+  path TEXT PRIMARY KEY,
+  mtime_ms INTEGER NOT NULL,
+  size INTEGER,
+  hash TEXT,
+  last_seen INTEGER NOT NULL,
+  meta TEXT
+);
+
+CREATE TABLE IF NOT EXISTS ai_results (
+  id TEXT PRIMARY KEY,
+  provider TEXT NOT NULL,
+  model TEXT,
+  task_id TEXT,
+  request_meta TEXT,
+  response_meta TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (task_id) REFERENCES tasks(id)
+);
+
+-- Agent runner: sessions and message history
+CREATE TABLE IF NOT EXISTS agent_sessions (
+  id TEXT PRIMARY KEY,
+  session_key TEXT UNIQUE NOT NULL,
+  meta TEXT,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS agent_messages (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  session_id TEXT NOT NULL,
+  role TEXT NOT NULL,
+  content TEXT,
+  tool_calls TEXT,
+  tool_call_id TEXT,
+  name TEXT,
+  created_at INTEGER NOT NULL,
+  FOREIGN KEY (session_id) REFERENCES agent_sessions(id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_agent_messages_session ON agent_messages(session_id);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_scheduled ON tasks(scheduled_at);
+CREATE INDEX IF NOT EXISTS idx_logs_created ON logs(created_at);
+CREATE INDEX IF NOT EXISTS idx_ai_results_created ON ai_results(created_at);

package/dist/gateway/server.d.ts

@@ -0,0 +1,13 @@
+import { type Express } from 'express';
+import { createServer } from 'http';
+import { WebSocketServer, type WebSocket } from 'ws';
+export declare function createGateway(appMount?: Express | null): Express;
+export declare function attachWebSocket(server: ReturnType<typeof createServer>, onConnection?: (ws: WebSocket) => void): {
+    wss: WebSocketServer;
+    broadcast: (data: unknown) => void;
+};
+export declare function startGateway(): {
+    app: Express;
+    server: ReturnType<typeof createServer>;
+};
+//# sourceMappingURL=server.d.ts.map

package/dist/gateway/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/gateway/server.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,KAAK,OAAO,EAA+B,MAAM,SAAS,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAIpC,OAAO,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,IAAI,CAAC;AA+CrD,wBAAgB,aAAa,CAAC,QAAQ,GAAE,OAAO,GAAG,IAAW,GAAG,OAAO,CAwetE;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,EACvC,YAAY,GAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAe,GAC/C;IAAE,GAAG,EAAE,eAAe,CAAC;IAAC,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,CAa9D;AAED,wBAAgB,YAAY,IAAI;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;CAAE,CAmBxF"}

package/dist/gateway/server.js

@@ -0,0 +1,566 @@
+import express from 'express';
+import { createServer } from 'http';
+import { existsSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { WebSocketServer } from 'ws';
+import cors from 'cors';
+import { config } from '../config.js';
+import { initDb, getDb, log, insertTask, getFileStates, updateTaskStatus, setTaskPendingForRetry, getOrCreateAgentSession, getAgentSessionById, getAgentMessages, listAgentSessions, } from '../db/index.js';
+import { runAgentTurn, runAgentTurnStream } from '../agent/loop.js';
+import { listSkills, getAllRequiredBins } from '../agent/skills.js';
+import { getRegistrySkills, getAvailableUpdates, installSkill, uninstallSkill, updateSkillsAll } from '../agent/skill-install.js';
+import { loadSkillsConfig, saveSkillsConfig, getConfigPath, setSkillEnabled } from '../agent/skills-config.js';
+import { withSessionLock } from '../agent/session-queue.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = join(__dirname, '..', '..');
+const dashboardDist = join(projectRoot, 'dashboard', 'dist');
+const registryDir = join(projectRoot, 'registry');
+const rateLimitMap = new Map();
+function rateLimitMiddleware(req, res, next) {
+    if (!config.rateLimitMax || config.rateLimitMax <= 0)
+        return next();
+    const ip = (req.ip || req.socket?.remoteAddress || 'unknown');
+    const now = Date.now();
+    let entry = rateLimitMap.get(ip);
+    if (!entry || now >= entry.resetAt) {
+        entry = { count: 0, resetAt: now + config.rateLimitWindowMs };
+        rateLimitMap.set(ip, entry);
+    }
+    entry.count++;
+    if (entry.count > config.rateLimitMax) {
+        res.status(429).json({ error: 'Too many requests' });
+        return;
+    }
+    next();
+}
+export function createGateway(appMount = null) {
+    const app = appMount || express();
+    app.use(cors());
+    app.use(express.json());
+    app.use(rateLimitMiddleware);
+    if (config.gatewayApiKey) {
+        app.use((req, res, next) => {
+            if (req.path === '/health')
+                return next();
+            const key = req.headers['x-api-key'] || req.query.api_key;
+            if (key === config.gatewayApiKey)
+                return next();
+            res.status(401).json({ error: 'Invalid or missing API key' });
+        });
+    }
+    /** SulalaHub: public skills registry. Set SKILLS_REGISTRY_URL to use this. */
+    app.get('/api/sulalahub/registry', (_req, res) => {
+        try {
+            const baseUrl = process.env.SULALAHUB_BASE_URL || `http://${config.host}:${config.port}`;
+            const registryPath = join(registryDir, 'skills-registry.json');
+            if (!existsSync(registryPath)) {
+                res.json({ skills: [] });
+                return;
+            }
+            const data = JSON.parse(readFileSync(registryPath, 'utf8'));
+            const skills = (data.skills || []).map((s) => ({
+                ...s,
+                url: `${baseUrl}/api/sulalahub/skills/${s.slug}`,
+            }));
+            res.json({ skills });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/sulalahub/skills/:slug', (req, res) => {
+        try {
+            const slug = Array.isArray(req.params.slug) ? req.params.slug[0] : req.params.slug;
+            if (!slug || /[^a-z0-9-]/.test(slug)) {
+                res.status(400).json({ error: 'Invalid slug' });
+                return;
+            }
+            const path = join(registryDir, `${slug}.md`);
+            if (!existsSync(path)) {
+                res.status(404).json({ error: `Skill not found: ${slug}` });
+                return;
+            }
+            res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
+            res.send(readFileSync(path, 'utf8'));
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/health', (_req, res) => {
+        res.json({ status: 'ok', service: 'sulala-gateway' });
+    });
+    app.get('/api/tasks', (req, res) => {
+        try {
+            const db = getDb();
+            const limit = Math.min(parseInt(req.query.limit || '50', 10), 200);
+            const rows = db.prepare('SELECT * FROM tasks ORDER BY created_at DESC LIMIT ?').all(limit);
+            res.json({ tasks: rows });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message, { stack: e.stack });
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/tasks', (req, res) => {
+        try {
+            const { type, payload, scheduled_at } = req.body || {};
+            if (!type) {
+                res.status(400).json({ error: 'type required' });
+                return;
+            }
+            const id = `task_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+            insertTask({ id, type, payload: payload ?? null, scheduled_at: scheduled_at ?? null });
+            log('gateway', 'info', 'Task enqueued', { id, type });
+            res.status(201).json({ id, type, status: 'pending' });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message, { stack: e.stack });
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/logs', (req, res) => {
+        try {
+            const db = getDb();
+            const limit = Math.min(parseInt(req.query.limit || '100', 10), 500);
+            const rows = db.prepare('SELECT * FROM logs ORDER BY created_at DESC LIMIT ?').all(limit);
+            res.json({ logs: rows });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/file-states', (req, res) => {
+        try {
+            const limit = Math.min(parseInt(req.query.limit || '200', 10), 500);
+            const rows = getFileStates(limit);
+            res.json({ fileStates: rows });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/config', (_req, res) => {
+        try {
+            res.json({
+                watchFolders: config.watchFolders || [],
+                aiProviders: [
+                    { id: 'openai', label: 'OpenAI', defaultModel: process.env.AI_OPENAI_DEFAULT_MODEL || 'gpt-4o-mini' },
+                    { id: 'openrouter', label: 'OpenRouter', defaultModel: process.env.AI_OPENROUTER_DEFAULT_MODEL || 'openai/gpt-4o-mini' },
+                    { id: 'claude', label: 'Claude', defaultModel: process.env.AI_CLAUDE_DEFAULT_MODEL || 'claude-sonnet-4-6' },
+                    { id: 'gemini', label: 'Gemini', defaultModel: process.env.AI_GEMINI_DEFAULT_MODEL || 'gemini-2.5-flash' },
+                    { id: 'ollama', label: 'Ollama', defaultModel: process.env.AI_OLLAMA_DEFAULT_MODEL || 'llama3.2' },
+                ],
+            });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/skills/required-bins', (_req, res) => {
+        try {
+            const bins = getAllRequiredBins(config);
+            res.json({ bins });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/skills', (_req, res) => {
+        try {
+            const skills = listSkills(config, { includeDisabled: true });
+            res.json({ skills });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/skills/config', (_req, res) => {
+        try {
+            const cfg = loadSkillsConfig();
+            res.json({ skills: cfg, configPath: getConfigPath() });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.put('/api/agent/skills/config', (req, res) => {
+        try {
+            const { skills } = req.body || {};
+            if (skills && typeof skills === 'object')
+                saveSkillsConfig(skills);
+            res.json({ skills: loadSkillsConfig(), configPath: getConfigPath() });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/skills/updates', async (_req, res) => {
+        try {
+            const updates = await getAvailableUpdates();
+            res.json({ updates });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/skills/registry', async (_req, res) => {
+        try {
+            const skills = await getRegistrySkills();
+            res.json({ skills });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/agent/skills/update', async (_req, res) => {
+        try {
+            const result = await updateSkillsAll();
+            res.json(result);
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/agent/skills/uninstall', (req, res) => {
+        try {
+            const { slug, target } = req.body || {};
+            if (!slug || typeof slug !== 'string') {
+                res.status(400).json({ error: 'slug required' });
+                return;
+            }
+            const t = target === 'managed' ? 'managed' : 'workspace';
+            const result = uninstallSkill(slug, t);
+            if (result.success) {
+                res.json({ uninstalled: slug, path: result.path, target: t });
+            }
+            else {
+                res.status(400).json({ error: result.error || 'Uninstall failed' });
+            }
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/agent/skills/install', async (req, res) => {
+        try {
+            const { slug, target, registryUrl } = req.body || {};
+            if (!slug || typeof slug !== 'string') {
+                res.status(400).json({ error: 'slug required' });
+                return;
+            }
+            const t = target === 'managed' ? 'managed' : 'workspace';
+            const result = await installSkill(slug, t, { registryUrl: typeof registryUrl === 'string' ? registryUrl : undefined });
+            if (result.success) {
+                setSkillEnabled(slug, true);
+                res.status(201).json({ installed: slug, path: result.path, target: t });
+            }
+            else {
+                res.status(400).json({ error: result.error || 'Install failed' });
+            }
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    /** List models for a provider. For openrouter, proxies OpenRouter Models API (id + name). */
+    app.get('/api/agent/models', async (req, res) => {
+        const provider = req.query.provider || '';
+        if (provider !== 'openrouter') {
+            res.json({ models: [] });
+            return;
+        }
+        try {
+            const key = process.env.OPENROUTER_API_KEY;
+            const headers = { Accept: 'application/json' };
+            if (key)
+                headers['Authorization'] = `Bearer ${key}`;
+            const r = await fetch('https://openrouter.ai/api/v1/models', { headers });
+            if (!r.ok) {
+                res.status(r.status).json({ error: `OpenRouter models: ${r.status}`, models: [] });
+                return;
+            }
+            const data = (await r.json());
+            const models = (data.data || []).map((m) => ({ id: m.id, name: m.name || m.id }));
+            res.json({ models });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message, models: [] });
+        }
+    });
+    app.post('/api/complete', async (req, res) => {
+        try {
+            const { provider, model, messages, max_tokens } = req.body || {};
+            if (!messages || !Array.isArray(messages)) {
+                res.status(400).json({ error: 'messages array required' });
+                return;
+            }
+            const { complete } = await import('../ai/orchestrator.js');
+            const result = await complete({ provider, model, messages, max_tokens: max_tokens || 1024 });
+            res.json(result);
+        }
+        catch (e) {
+            log('gateway', 'error', e.message, { stack: e.stack });
+            res.status(500).json({ error: e.message });
+        }
+    });
+    // --- Agent runner (sessions + tool loop) ---
+    app.get('/api/agent/sessions', (req, res) => {
+        try {
+            const limit = Math.min(parseInt(req.query.limit || '50', 10), 200);
+            const sessions = listAgentSessions(limit);
+            res.json({ sessions });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/agent/sessions', (req, res) => {
+        try {
+            const sessionKey = req.body?.session_key || `default_${Date.now()}`;
+            const meta = req.body?.meta;
+            const session = getOrCreateAgentSession(sessionKey, meta);
+            res.status(201).json(session);
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.get('/api/agent/sessions/:id', (req, res) => {
+        try {
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            if (!id) {
+                res.status(400).json({ error: 'Session id required' });
+                return;
+            }
+            const session = getAgentSessionById(id);
+            if (!session) {
+                res.status(404).json({ error: 'Session not found' });
+                return;
+            }
+            const rows = getAgentMessages(id);
+            const messages = rows.map((r) => {
+                const msg = { role: r.role, content: r.content, tool_call_id: r.tool_call_id, name: r.name, created_at: r.created_at };
+                if (r.tool_calls) {
+                    try {
+                        msg.tool_calls = JSON.parse(r.tool_calls);
+                    }
+                    catch {
+                        msg.tool_calls = [];
+                    }
+                }
+                return msg;
+            });
+            res.json({ ...session, messages });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    app.post('/api/agent/sessions/:id/messages', async (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        if (!id) {
+            res.status(400).json({ error: 'Session id required' });
+            return;
+        }
+        const session = getAgentSessionById(id);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        const controller = new AbortController();
+        req.on('close', () => controller.abort());
+        const { message, system_prompt, provider, model, max_tokens, timeout_ms } = req.body || {};
+        const timeoutMs = typeof timeout_ms === 'number' ? timeout_ms : config.agentTimeoutMs || 0;
+        try {
+            const result = await withSessionLock(id, () => runAgentTurn({
+                sessionId: id,
+                userMessage: typeof message === 'string' ? message : null,
+                systemPrompt: typeof system_prompt === 'string' ? system_prompt : null,
+                provider: typeof provider === 'string' ? provider : undefined,
+                model: typeof model === 'string' ? model : undefined,
+                max_tokens: typeof max_tokens === 'number' ? max_tokens : undefined,
+                timeoutMs: timeoutMs > 0 ? timeoutMs : undefined,
+                signal: controller.signal,
+            }));
+            res.json(result);
+        }
+        catch (e) {
+            const err = e;
+            if (err.name === 'AbortError') {
+                res.status(499).json({ error: 'Client closed request or run timed out' });
+                return;
+            }
+            log('gateway', 'error', err.message, { stack: err.stack });
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post('/api/agent/sessions/:id/messages/stream', async (req, res) => {
+        const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+        if (!id) {
+            res.status(400).json({ error: 'Session id required' });
+            return;
+        }
+        const session = getAgentSessionById(id);
+        if (!session) {
+            res.status(404).json({ error: 'Session not found' });
+            return;
+        }
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders?.();
+        const send = (event, data) => {
+            res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+            res.flush?.();
+        };
+        const controller = new AbortController();
+        req.on('close', () => controller.abort());
+        const { message, system_prompt, provider, model, max_tokens, timeout_ms } = req.body || {};
+        const timeoutMs = typeof timeout_ms === 'number' ? timeout_ms : config.agentTimeoutMs || 0;
+        try {
+            await withSessionLock(id, () => runAgentTurnStream({
+                sessionId: id,
+                userMessage: typeof message === 'string' ? message : null,
+                systemPrompt: typeof system_prompt === 'string' ? system_prompt : null,
+                provider: typeof provider === 'string' ? provider : undefined,
+                model: typeof model === 'string' ? model : undefined,
+                max_tokens: typeof max_tokens === 'number' ? max_tokens : undefined,
+                timeoutMs: timeoutMs > 0 ? timeoutMs : undefined,
+                signal: controller.signal,
+            }, (ev) => {
+                if (ev.type === 'assistant')
+                    send('assistant', { delta: ev.delta });
+                else if (ev.type === 'tool_call')
+                    send('tool_call', { name: ev.name, result: ev.result });
+                else if (ev.type === 'done')
+                    send('done', { finalContent: ev.finalContent, turnCount: ev.turnCount });
+                else if (ev.type === 'error')
+                    send('error', { message: ev.message });
+            }));
+        }
+        catch (e) {
+            const err = e;
+            if (err.name === 'AbortError')
+                send('error', { message: 'Client closed request or run timed out' });
+            else {
+                log('gateway', 'error', err.message, { stack: err.stack });
+                send('error', { message: err.message });
+            }
+        }
+        finally {
+            res.end();
+        }
+    });
+    app.patch('/api/tasks/:id', (req, res) => {
+        try {
+            const id = Array.isArray(req.params.id) ? req.params.id[0] : req.params.id;
+            if (!id) {
+                res.status(400).json({ error: 'Task id required' });
+                return;
+            }
+            const { action } = req.body || {};
+            const db = getDb();
+            const row = db.prepare('SELECT id, status FROM tasks WHERE id = ?').get(id);
+            if (!row) {
+                res.status(404).json({ error: 'Task not found' });
+                return;
+            }
+            if (action === 'cancel') {
+                if (row.status !== 'pending' && row.status !== 'running') {
+                    res.status(400).json({ error: 'Task cannot be cancelled' });
+                    return;
+                }
+                updateTaskStatus(id, 'cancelled');
+                log('gateway', 'info', 'Task cancelled', { id });
+                res.json({ id, status: 'cancelled' });
+                return;
+            }
+            if (action === 'retry') {
+                if (row.status !== 'failed') {
+                    res.status(400).json({ error: 'Only failed tasks can be retried' });
+                    return;
+                }
+                setTaskPendingForRetry(id);
+                const enqueueTaskId = app.locals.enqueueTaskId;
+                if (typeof enqueueTaskId === 'function')
+                    enqueueTaskId(id);
+                log('gateway', 'info', 'Task retry enqueued', { id });
+                res.json({ id, status: 'pending' });
+                return;
+            }
+            res.status(400).json({ error: 'action required: cancel or retry' });
+        }
+        catch (e) {
+            log('gateway', 'error', e.message);
+            res.status(500).json({ error: e.message });
+        }
+    });
+    if (existsSync(dashboardDist)) {
+        app.use(express.static(dashboardDist));
+        app.get(/^\/(?!api|health|ws)/, (_req, res) => {
+            res.sendFile(join(dashboardDist, 'index.html'));
+        });
+    }
+    return app;
+}
+export function attachWebSocket(server, onConnection = () => { }) {
+    const wss = new WebSocketServer({ server, path: '/ws' });
+    const broadcast = (data) => {
+        const msg = typeof data === 'string' ? data : JSON.stringify(data);
+        wss.clients.forEach((c) => {
+            if (c.readyState === 1)
+                c.send(msg);
+        });
+    };
+    wss.on('connection', (ws) => {
+        onConnection(ws);
+        ws.send(JSON.stringify({ type: 'connected', ts: Date.now() }));
+    });
+    return { wss, broadcast };
+}
+export function startGateway() {
+    initDb(config.dbPath);
+    const app = createGateway();
+    const server = createServer(app);
+    const { broadcast } = attachWebSocket(server, (ws) => {
+        ws.on('message', (raw) => {
+            try {
+                const data = JSON.parse(raw.toString());
+                if (data.type === 'ping')
+                    ws.send(JSON.stringify({ type: 'pong', ts: Date.now() }));
+            }
+            catch {
+                // ignore
+            }
+        });
+    });
+    app.locals.wsBroadcast = broadcast;
+    server.listen(config.port, config.host, () => {
+        console.log(`Sulala gateway http://${config.host}:${config.port} (WS /ws)`);
+    });
+    return { app, server };
+}
+if (process.argv[1]?.includes('server')) {
+    startGateway();
+}
+//# sourceMappingURL=server.js.map