@m0xoo/openboard 1.0.0

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

@@ -0,0 +1,56 @@
+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
+        };
+    },
+    create(name, workspaces = []) {
+        const boardId = randomUUID();
+        const db = getDb();
+        db.transaction(() => {
+            db.prepare('INSERT INTO boards (id, name) VALUES (?, ?)').run(boardId, name);
+            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, workspaces) {
+        const db = getDb();
+        db.transaction(() => {
+            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,158 @@
+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);
+        }
+        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, workspaces } = req.body;
+    if (!name?.trim()) {
+        res.status(400).json({ error: 'Name is required' });
+        return;
+    }
+    const board = boardRepository.create(name.trim(), workspaces);
+    sseManager.emitGlobal('board:created', board);
+    res.status(201).json(board);
+});
+router.patch('/:id', (req, res) => {
+    const { name, workspaces } = req.body;
+    const board = boardRepository.update(req.params.id, name?.trim(), 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,42 @@
+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, onFinishColumnId, onRejectColumnId } = req.body;
+    if (!agentType) {
+        res.status(400).json({ error: 'agentType is required' });
+        return;
+    }
+    const config = columnConfigRepository.upsert({
+        columnId: req.params.id,
+        agentType,
+        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 };

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

@@ -0,0 +1,88 @@
+import { Router } from 'express';
+import { ticketRepository } from '../repositories/ticket.repository.js';
+import { commentRepository } from '../repositories/comment.repository.js';
+import { triggerAgent } from '../agents/agent-runner.js';
+import { agentQueue } from '../agents/agent-queue.js';
+const router = Router({ mergeParams: true });
+// GET /api/boards/:boardId/tickets
+router.get('/', (req, res) => {
+    res.json(ticketRepository.findByBoardId(req.params.boardId));
+});
+// POST /api/boards/:boardId/tickets
+router.post('/', (req, res) => {
+    const { title, description, priority, columnId } = req.body;
+    if (!title?.trim() || !columnId) {
+        res.status(400).json({ error: 'title and columnId are required' });
+        return;
+    }
+    const ticket = ticketRepository.create({
+        boardId: req.params.boardId,
+        columnId,
+        title: title.trim(),
+        description,
+        priority,
+    });
+    triggerAgent(ticket);
+    // Return latest DB state (might have agent_status: 'processing')
+    const latest = ticketRepository.findById(ticket.id) || ticket;
+    res.status(201).json(latest);
+});
+// PATCH /api/boards/:boardId/tickets/:id
+router.patch('/:id', (req, res) => {
+    const { title, description, priority } = req.body;
+    const ticket = ticketRepository.update(req.params.id, { title, description, priority });
+    if (!ticket) {
+        res.status(404).json({ error: 'Ticket not found' });
+        return;
+    }
+    res.json(ticket);
+});
+// PUT /api/boards/:boardId/tickets/:id/move
+router.put('/:id/move', (req, res) => {
+    const { toColumnId, position } = req.body;
+    const ticket = ticketRepository.move(req.params.id, toColumnId, position);
+    if (!ticket) {
+        res.status(404).json({ error: 'Ticket not found' });
+        return;
+    }
+    triggerAgent(ticket);
+    res.json(ticket);
+});
+// POST /api/boards/:boardId/tickets/:id/retry
+router.post('/:id/retry', (req, res) => {
+    const ticket = ticketRepository.findById(req.params.id);
+    if (!ticket) {
+        res.status(404).json({ error: 'Ticket not found' });
+        return;
+    }
+    // Only retry if it failed or hasn't started
+    // We pass force=true so that if it is in 'blocked' state, it gets cleared.
+    triggerAgent(ticket, true);
+    res.status(202).json({ status: 'retrying' });
+});
+// DELETE /api/boards/:boardId/tickets/:id
+router.delete('/:id', (req, res) => {
+    ticketRepository.delete(req.params.id);
+    agentQueue.ping();
+    res.status(204).end();
+});
+// GET /api/boards/:boardId/tickets/:id/comments
+router.get('/:id/comments', (req, res) => {
+    const comments = commentRepository.findByTicketId(req.params.id);
+    res.json(comments);
+});
+// POST /api/boards/:boardId/tickets/:id/comments
+router.post('/:id/comments', (req, res) => {
+    const { content, author } = req.body;
+    if (!content?.trim()) {
+        res.status(400).json({ error: 'content is required' });
+        return;
+    }
+    const comment = commentRepository.create({
+        ticketId: req.params.id,
+        author,
+        content: content.trim(),
+    });
+    res.status(201).json(comment);
+});
+export { router as ticketsRouter };

package/packages/server/dist/sse.js

@@ -0,0 +1,43 @@
+class SseManager {
+    // boardId -> set of connected SSE clients
+    // Use '*' for board-level events (created/deleted) that all clients should see
+    clients = new Map();
+    subscribe(boardId, res) {
+        if (!this.clients.has(boardId)) {
+            this.clients.set(boardId, new Set());
+        }
+        this.clients.get(boardId).add(res);
+    }
+    unsubscribe(boardId, res) {
+        this.clients.get(boardId)?.delete(res);
+    }
+    emit(boardId, event, data) {
+        const targets = new Set();
+        // Collect subscribers for the specific board
+        this.clients.get(boardId)?.forEach(c => targets.add(c));
+        // Always also broadcast to '*' channel (global subscribers)
+        this.clients.get('*')?.forEach(c => targets.add(c));
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        targets.forEach(client => {
+            try {
+                client.write(payload);
+            }
+            catch {
+                // Client disconnected — cleanup handled by 'close' event
+            }
+        });
+    }
+    /** Broadcast to ALL connected clients (used for board-level events). */
+    emitGlobal(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+        this.clients.forEach(set => {
+            set.forEach(client => {
+                try {
+                    client.write(payload);
+                }
+                catch { /* ignore */ }
+            });
+        });
+    }
+}
+export const sseManager = new SseManager();

package/packages/server/dist/types.js

@@ -0,0 +1,2 @@
+// Shared types between server and client (duplicated intentionally for zero-dep simplicity)
+export {};