@openboard/start 1.0.2

package/packages/server/dist/index.js

@@ -0,0 +1,81 @@
+import express from 'express';
+import cors from 'cors';
+import { initDb } from './db/database.js';
+import { boardsRouter } from './routes/boards.router.js';
+import { columnsRouter } from './routes/columns.router.js';
+import { ticketsRouter } from './routes/tickets.router.js';
+import { columnConfigRouter } from './routes/column-config.router.js';
+import { systemRouter } from './routes/system.router.js';
+import { sseManager } from './sse.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PORT = process.env.PORT ?? 3001;
+async function start() {
+    await initDb();
+    console.log('[openboard] Database ready');
+    const app = express();
+    app.use(cors({ origin: process.env.CLIENT_ORIGIN ? process.env.CLIENT_ORIGIN.split(',') : ['http://localhost:5173', 'http://localhost:4173'] }));
+    app.use(express.json());
+    // SSE subscription endpoint
+    // GET /api/events?boardId=<id>
+    // Clients subscribe here; the server pushes events whenever data changes.
+    app.get('/api/events', (req, res) => {
+        const boardId = req.query.boardId || '*';
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.setHeader('X-Accel-Buffering', 'no'); // disable nginx buffering if present
+        res.flushHeaders();
+        // Register this connection
+        sseManager.subscribe(boardId, res);
+        // Send a connected confirmation event
+        res.write(`event: connected\ndata: ${JSON.stringify({ boardId })}\n\n`);
+        // Heartbeat every 25 s to keep the connection alive through proxies/firewalls
+        const heartbeat = setInterval(() => {
+            try {
+                res.write(': heartbeat\n\n');
+            }
+            catch {
+                clearInterval(heartbeat);
+            }
+        }, 25_000);
+        req.on('close', () => {
+            clearInterval(heartbeat);
+            sseManager.unsubscribe(boardId, res);
+        });
+    });
+    app.use('/api/boards', boardsRouter);
+    app.use('/api/boards/:boardId/columns', columnsRouter);
+    app.use('/api/boards/:boardId/tickets', ticketsRouter);
+    app.use('/api/boards/:boardId/columns', columnConfigRouter);
+    app.use('/api/system', systemRouter);
+    app.get('/api/health', (_req, res) => res.json({ status: 'ok' }));
+    // Serve the built client
+    const clientExtPath = path.join(__dirname, '../../client/dist');
+    app.use(express.static(clientExtPath));
+    app.get('*', (req, res) => {
+        res.sendFile(path.join(clientExtPath, 'index.html'));
+    });
+    const server = app.listen(PORT);
+    server.on('listening', () => {
+        const address = server.address();
+        const actualPort = typeof address === 'string' ? address : address?.port;
+        console.log(`[openboard] Server running at http://localhost:${actualPort}`);
+    });
+    server.on('error', (err) => {
+        if (err.code === 'EADDRINUSE') {
+            console.log(`[openboard] Port ${PORT} is in use, trying a random available port...`);
+            server.close();
+            server.listen(0);
+        }
+        else {
+            console.error('[openboard] Server error:', err);
+        }
+    });
+}
+start().catch(err => {
+    console.error('[openboard] Failed to start:', err);
+    process.exit(1);
+});

package/packages/server/dist/repositories/board.repository.js

@@ -0,0 +1,72 @@
+import { randomUUID } from 'crypto';
+import { getDb } from '../db/database.js';
+export const boardRepository = {
+    findAll() {
+        const db = getDb();
+        const boards = db.prepare('SELECT * FROM boards ORDER BY created_at ASC').all();
+        return boards.map(board => {
+            const workspaces = db.prepare('SELECT * FROM board_workspaces WHERE board_id = ?').all(board.id);
+            return {
+                ...board,
+                workspaces
+            };
+        });
+    },
+    findById(id) {
+        const db = getDb();
+        const board = db.prepare('SELECT * FROM boards WHERE id = ?').get(id);
+        if (!board)
+            return undefined;
+        const workspaces = db.prepare('SELECT * FROM board_workspaces WHERE board_id = ?').all(id);
+        return {
+            ...board,
+            workspaces
+        };
+    },
+    findByPath(path) {
+        const db = getDb();
+        const board = db.prepare('SELECT * FROM boards WHERE path = ?').get(path);
+        if (!board)
+            return undefined;
+        const workspaces = db.prepare('SELECT * FROM board_workspaces WHERE board_id = ?').all(board.id);
+        return {
+            ...board,
+            workspaces
+        };
+    },
+    create(name, path, workspaces = []) {
+        const boardId = randomUUID();
+        const db = getDb();
+        db.transaction(() => {
+            db.prepare('INSERT INTO boards (id, name, path) VALUES (?, ?, ?)').run(boardId, name, path || null);
+            for (const ws of workspaces) {
+                db.prepare('INSERT INTO board_workspaces (id, board_id, type, path) VALUES (?, ?, ?, ?)')
+                    .run(randomUUID(), boardId, ws.type, ws.path);
+            }
+        })();
+        return this.findById(boardId);
+    },
+    update(id, name, path, workspaces) {
+        const db = getDb();
+        db.transaction(() => {
+            if (path !== undefined) {
+                db.prepare('UPDATE boards SET name = ?, path = ? WHERE id = ?').run(name, path, id);
+            }
+            else {
+                db.prepare('UPDATE boards SET name = ? WHERE id = ?').run(name, id);
+            }
+            if (workspaces) {
+                // Simple sync: delete all and re-create
+                db.prepare('DELETE FROM board_workspaces WHERE board_id = ?').run(id);
+                for (const ws of workspaces) {
+                    db.prepare('INSERT INTO board_workspaces (id, board_id, type, path) VALUES (?, ?, ?, ?)')
+                        .run(randomUUID(), id, ws.type, ws.path);
+                }
+            }
+        })();
+        return this.findById(id);
+    },
+    delete(id) {
+        getDb().prepare('DELETE FROM boards WHERE id = ?').run(id);
+    },
+};

package/packages/server/dist/repositories/column-config.repository.js

@@ -0,0 +1,30 @@
+import { getDb } from '../db/database.js';
+export const columnConfigRepository = {
+    findByColumnId(columnId) {
+        return getDb()
+            .prepare('SELECT * FROM column_configs WHERE column_id = ?')
+            .get(columnId);
+    },
+    findByBoardId(boardId) {
+        // Since board_id is not in column_configs, we join with columns
+        return getDb()
+            .prepare(`
+                SELECT cf.* FROM column_configs cf
+                JOIN columns c ON cf.column_id = c.id
+                WHERE c.board_id = ?
+            `)
+            .all(boardId);
+    },
+    upsert(data) {
+        getDb()
+            .prepare(`INSERT OR REPLACE INTO column_configs (column_id, agent_type, agent_model, max_agents, on_finish_column_id, on_reject_column_id)
+                 VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(data.columnId, data.agentType, data.agentModel ?? null, data.maxAgents ?? 1, data.onFinishColumnId ?? null, data.onRejectColumnId ?? null);
+        return this.findByColumnId(data.columnId);
+    },
+    delete(columnId) {
+        getDb()
+            .prepare('DELETE FROM column_configs WHERE column_id = ?')
+            .run(columnId);
+    },
+};

package/packages/server/dist/repositories/column.repository.js

@@ -0,0 +1,36 @@
+import { randomUUID } from 'crypto';
+import { getDb } from '../db/database.js';
+export const columnRepository = {
+    findByBoardId(boardId) {
+        return getDb()
+            .prepare('SELECT * FROM columns WHERE board_id = ? ORDER BY position ASC')
+            .all(boardId);
+    },
+    findById(id) {
+        return getDb().prepare('SELECT * FROM columns WHERE id = ?').get(id);
+    },
+    create(boardId, name) {
+        const id = randomUUID();
+        const maxPos = getDb()
+            .prepare('SELECT COALESCE(MAX(position), -1) as m FROM columns WHERE board_id = ?')
+            .get(boardId).m;
+        getDb()
+            .prepare('INSERT INTO columns (id, board_id, name, position) VALUES (?, ?, ?, ?)')
+            .run(id, boardId, name, maxPos + 1);
+        return this.findById(id);
+    },
+    update(id, name) {
+        getDb().prepare('UPDATE columns SET name = ? WHERE id = ?').run(name, id);
+        return this.findById(id);
+    },
+    reorder(boardId, orderedIds) {
+        const update = getDb().prepare('UPDATE columns SET position = ? WHERE id = ? AND board_id = ?');
+        const transaction = getDb().transaction(() => {
+            orderedIds.forEach((id, index) => update.run(index, id, boardId));
+        });
+        transaction();
+    },
+    delete(id) {
+        getDb().prepare('DELETE FROM columns WHERE id = ?').run(id);
+    },
+};

package/packages/server/dist/repositories/comment.repository.js

@@ -0,0 +1,35 @@
+import { randomUUID } from 'crypto';
+import { getDb } from '../db/database.js';
+import { sseManager } from '../sse.js';
+export const commentRepository = {
+    findByTicketId(ticketId) {
+        const db = getDb();
+        return db.prepare('SELECT * FROM comments WHERE ticket_id = ? ORDER BY created_at ASC').all(ticketId);
+    },
+    create(data) {
+        const id = randomUUID();
+        const db = getDb();
+        db.prepare('INSERT INTO comments (id, ticket_id, author, content) VALUES (?, ?, ?, ?)')
+            .run(id, data.ticketId, data.author ?? 'agent', data.content);
+        const comment = db.prepare('SELECT * FROM comments WHERE id = ?').get(id);
+        if (comment) {
+            sseManager.emit(data.ticketId, 'comment:added', {
+                ticketId: data.ticketId,
+                comment,
+            });
+        }
+        return comment;
+    },
+    update(id, content) {
+        const db = getDb();
+        db.prepare('UPDATE comments SET content = ? WHERE id = ?').run(content, id);
+        const comment = db.prepare('SELECT * FROM comments WHERE id = ?').get(id);
+        if (comment) {
+            sseManager.emit(comment.ticket_id, 'comment:updated', {
+                ticketId: comment.ticket_id,
+                comment,
+            });
+        }
+        return comment;
+    },
+};

package/packages/server/dist/repositories/ticket.repository.js

@@ -0,0 +1,171 @@
+import { randomUUID } from 'crypto';
+import { getDb } from '../db/database.js';
+import { sseManager } from '../sse.js';
+function parseTicket(row) {
+    let agent_sessions = [];
+    if (row.agent_sessions) {
+        try {
+            agent_sessions = JSON.parse(row.agent_sessions);
+            // Patch opencode sessions with the current port if it changed on restart
+            const currentPort = process.env.OPENCODE_PORT || '4096';
+            agent_sessions = agent_sessions.map((session) => {
+                if (session.agent_type === 'opencode') {
+                    if (session.port && String(session.port) !== String(currentPort)) {
+                        session.port = Number(currentPort);
+                    }
+                    if (session.url) {
+                        session.url = session.url.replace(/:\d+\//, `:${currentPort}/`);
+                    }
+                }
+                return session;
+            });
+        }
+        catch { }
+    }
+    return {
+        ...row,
+        agent_sessions
+    };
+}
+export const ticketRepository = {
+    findByColumnId(columnId) {
+        const rows = getDb()
+            .prepare('SELECT * FROM tickets WHERE column_id = ? ORDER BY position ASC')
+            .all(columnId);
+        return rows.map(parseTicket);
+    },
+    findByBoardId(boardId) {
+        const rows = getDb()
+            .prepare('SELECT * FROM tickets WHERE board_id = ? ORDER BY position ASC')
+            .all(boardId);
+        return rows.map(parseTicket);
+    },
+    findById(id) {
+        const row = getDb().prepare('SELECT * FROM tickets WHERE id = ?').get(id);
+        if (!row)
+            return undefined;
+        return parseTicket(row);
+    },
+    create(data) {
+        const id = randomUUID();
+        const maxPos = getDb()
+            .prepare('SELECT COALESCE(MAX(position), -1) as m FROM tickets WHERE column_id = ?')
+            .get(data.columnId).m;
+        getDb()
+            .prepare(`INSERT INTO tickets (id, column_id, board_id, title, description, priority, position)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, data.columnId, data.boardId, data.title, data.description ?? '', data.priority ?? 'medium', maxPos + 1);
+        const savedTicket = this.findById(id);
+        sseManager.emit(savedTicket.board_id, 'ticket:updated', savedTicket);
+        return savedTicket;
+    },
+    update(id, data) {
+        const ticket = this.findById(id);
+        if (!ticket)
+            return undefined;
+        const updated = { ...ticket, ...data, updated_at: new Date().toISOString() };
+        getDb()
+            .prepare(`UPDATE tickets SET title = ?, description = ?, priority = ?, updated_at = ? WHERE id = ?`)
+            .run(updated.title, updated.description, updated.priority, updated.updated_at, id);
+        const savedTicket = this.findById(id);
+        if (savedTicket) {
+            sseManager.emit(savedTicket.board_id, 'ticket:updated', savedTicket);
+        }
+        return savedTicket;
+    },
+    move(id, toColumnId, position) {
+        const db = getDb();
+        const existing = db.prepare('SELECT column_id, position FROM tickets WHERE id = ?').get(id);
+        if (!existing)
+            return undefined;
+        const fromColumnId = existing.column_id;
+        const fromPosition = existing.position;
+        db.transaction(() => {
+            if (fromColumnId === toColumnId) {
+                // Moving within same column
+                if (fromPosition === position)
+                    return; // No-op
+                if (fromPosition < position) {
+                    // Moving down: shift items between old and new position up
+                    db.prepare('UPDATE tickets SET position = position - 1 WHERE column_id = ? AND position > ? AND position <= ?').run(toColumnId, fromPosition, position);
+                }
+                else {
+                    // Moving up: shift items between new and old position down
+                    db.prepare('UPDATE tickets SET position = position + 1 WHERE column_id = ? AND position >= ? AND position < ?').run(toColumnId, position, fromPosition);
+                }
+            }
+            else {
+                // Moving to different column
+                // 1. Shift items in destination column down to make room
+                db.prepare('UPDATE tickets SET position = position + 1 WHERE column_id = ? AND position >= ?').run(toColumnId, position);
+                // 2. Clear gaps in source column
+                db.prepare('UPDATE tickets SET position = position - 1 WHERE column_id = ? AND position > ?').run(fromColumnId, fromPosition);
+            }
+            // Finally, update the target ticket (agent history remains intact)
+            db.prepare(`UPDATE tickets SET column_id = ?, position = ?, updated_at = datetime('now') WHERE id = ?`).run(toColumnId, position, id);
+        })();
+        const updatedTicket = this.findById(id);
+        if (updatedTicket) {
+            sseManager.emit(updatedTicket.board_id, 'ticket:updated', updatedTicket);
+        }
+        return updatedTicket;
+    },
+    updateAgentSession(id, sessionData) {
+        const ticket = this.findById(id);
+        if (!ticket)
+            return undefined;
+        const sessions = [...ticket.agent_sessions];
+        // Find the index of the most recent session for this column
+        let existingIdx = -1;
+        for (let i = sessions.length - 1; i >= 0; i--) {
+            if (sessions[i].column_id === sessionData.column_id) {
+                existingIdx = i;
+                break;
+            }
+        }
+        const isTerminalStatus = (s) => s === 'done' || s === 'blocked';
+        let isNewSession = false;
+        if (existingIdx === -1) {
+            // No session ever Existed for this column
+            isNewSession = true;
+        }
+        else {
+            const existingSession = sessions[existingIdx];
+            // If the existing session is already in a terminal state (done or blocked)
+            // AND we are trying to start a new 'processing' session, then we append.
+            if (isTerminalStatus(existingSession.status) && sessionData.status === 'processing') {
+                isNewSession = true;
+            }
+        }
+        if (isNewSession) {
+            const newSession = {
+                ...sessionData,
+                started_at: new Date().toISOString(),
+                // If it starts terminal (which would be weird but possible), set finished_at
+                finished_at: isTerminalStatus(sessionData.status) ? new Date().toISOString() : undefined
+            };
+            sessions.push(newSession);
+        }
+        else {
+            // Update the existing (active) session
+            const newSession = {
+                ...sessions[existingIdx], // Preserve started_at and any missing fields
+                ...sessionData,
+                finished_at: isTerminalStatus(sessionData.status) ? new Date().toISOString() : undefined
+            };
+            sessions[existingIdx] = newSession;
+        }
+        const updated = { ...ticket, agent_sessions: sessions, updated_at: new Date().toISOString() };
+        getDb()
+            .prepare('UPDATE tickets SET agent_sessions = ?, updated_at = ? WHERE id = ?')
+            .run(JSON.stringify(sessions), updated.updated_at, id);
+        const savedTicket = this.findById(id);
+        if (savedTicket) {
+            sseManager.emit(savedTicket.board_id, 'ticket:updated', savedTicket);
+        }
+        return savedTicket;
+    },
+    delete(id) {
+        getDb().prepare('DELETE FROM tickets WHERE id = ?').run(id);
+    },
+};

package/packages/server/dist/routes/boards.router.js

@@ -0,0 +1,33 @@
+import { Router } from 'express';
+import { boardRepository } from '../repositories/board.repository.js';
+import { sseManager } from '../sse.js';
+const router = Router();
+router.get('/', (_req, res) => {
+    res.json(boardRepository.findAll());
+});
+router.post('/', (req, res) => {
+    const { name, path, workspaces } = req.body;
+    if (!name?.trim()) {
+        res.status(400).json({ error: 'Name is required' });
+        return;
+    }
+    const board = boardRepository.create(name.trim(), path, workspaces);
+    sseManager.emitGlobal('board:created', board);
+    res.status(201).json(board);
+});
+router.patch('/:id', (req, res) => {
+    const { name, path, workspaces } = req.body;
+    const board = boardRepository.update(req.params.id, name?.trim(), path, workspaces);
+    if (!board) {
+        res.status(404).json({ error: 'Board not found' });
+        return;
+    }
+    sseManager.emitGlobal('board:updated', board);
+    res.json(board);
+});
+router.delete('/:id', (req, res) => {
+    boardRepository.delete(req.params.id);
+    sseManager.emitGlobal('board:deleted', { id: req.params.id });
+    res.status(204).end();
+});
+export { router as boardsRouter };

package/packages/server/dist/routes/column-config.router.js

@@ -0,0 +1,44 @@
+import { Router } from 'express';
+import { columnConfigRepository } from '../repositories/column-config.repository.js';
+import { sseManager } from '../sse.js';
+const router = Router({ mergeParams: true });
+// GET /api/boards/:boardId/columns/configs
+// Fetches all configs for all columns in this board
+router.get('/configs', (req, res) => {
+    const configs = columnConfigRepository.findByBoardId(req.params.boardId);
+    res.json(configs);
+});
+// GET /api/boards/:boardId/columns/:id/config
+router.get('/:id/config', (req, res) => {
+    const config = columnConfigRepository.findByColumnId(req.params.id);
+    if (!config) {
+        res.json({ column_id: req.params.id, agent_type: 'none', on_finish_column_id: null });
+        return;
+    }
+    res.json(config);
+});
+// PUT /api/boards/:boardId/columns/:id/config
+router.put('/:id/config', (req, res) => {
+    const { agentType, agentModel, maxAgents, onFinishColumnId, onRejectColumnId } = req.body;
+    if (!agentType) {
+        res.status(400).json({ error: 'agentType is required' });
+        return;
+    }
+    const config = columnConfigRepository.upsert({
+        columnId: req.params.id,
+        agentType,
+        agentModel,
+        maxAgents,
+        onFinishColumnId,
+        onRejectColumnId,
+    });
+    sseManager.emit(req.params.boardId, 'column:config:updated', config);
+    res.json(config);
+});
+// DELETE /api/boards/:boardId/columns/:id/config
+router.delete('/:id/config', (req, res) => {
+    columnConfigRepository.delete(req.params.id);
+    sseManager.emit(req.params.boardId, 'column:config:deleted', { columnId: req.params.id });
+    res.status(204).end();
+});
+export { router as columnConfigRouter };

package/packages/server/dist/routes/columns.router.js

@@ -0,0 +1,45 @@
+import { Router } from 'express';
+import { columnRepository } from '../repositories/column.repository.js';
+import { sseManager } from '../sse.js';
+const router = Router({ mergeParams: true });
+// GET /api/boards/:boardId/columns
+router.get('/', (req, res) => {
+    res.json(columnRepository.findByBoardId(req.params.boardId));
+});
+// POST /api/boards/:boardId/columns
+router.post('/', (req, res) => {
+    const { name } = req.body;
+    if (!name?.trim()) {
+        res.status(400).json({ error: 'Name is required' });
+        return;
+    }
+    const column = columnRepository.create(req.params.boardId, name.trim());
+    sseManager.emit(req.params.boardId, 'column:created', column);
+    res.status(201).json(column);
+});
+// PATCH /api/boards/:boardId/columns/:id
+router.patch('/:id', (req, res) => {
+    const { name } = req.body;
+    const column = columnRepository.update(req.params.id, name.trim());
+    if (!column) {
+        res.status(404).json({ error: 'Column not found' });
+        return;
+    }
+    sseManager.emit(req.params.boardId, 'column:updated', column);
+    res.json(column);
+});
+// PUT /api/boards/:boardId/columns/reorder
+router.put('/reorder', (req, res) => {
+    const { orderedIds } = req.body;
+    columnRepository.reorder(req.params.boardId, orderedIds);
+    const columns = columnRepository.findByBoardId(req.params.boardId);
+    sseManager.emit(req.params.boardId, 'columns:reordered', columns);
+    res.status(204).end();
+});
+// DELETE /api/boards/:boardId/columns/:id
+router.delete('/:id', (req, res) => {
+    columnRepository.delete(req.params.id);
+    sseManager.emit(req.params.boardId, 'column:deleted', { id: req.params.id });
+    res.status(204).end();
+});
+export { router as columnsRouter };