@m0xoo/openboard 1.0.0

package/packages/server/dist/agents/opencode.events.js

@@ -0,0 +1,398 @@
+import { ticketRepository } from '../repositories/ticket.repository.js';
+import { commentRepository } from '../repositories/comment.repository.js';
+import { agentQueue } from './agent-queue.js';
+import { execFile, exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+// Cache the gh token so we only fetch it once per server process
+let cachedGhToken = null;
+async function getGhToken(cwd) {
+    if (cachedGhToken !== null)
+        return cachedGhToken;
+    try {
+        const { stdout } = await execFileAsync('gh', ['auth', 'token'], { cwd, shell: true });
+        cachedGhToken = stdout.trim() || null;
+    }
+    catch {
+        cachedGhToken = null;
+    }
+    return cachedGhToken;
+}
+// Helper function to execute commands robustly on Windows.
+// Automatically injects GH_TOKEN for any `gh` subcommand.
+async function runCmd(cmd, args, cwd) {
+    console.log(`[opencode-events] Running: ${cmd} ${args.join(' ')} in cwd: ${cwd}`);
+    // Safety check for CWD to avoid obscure ENOENT shell errors
+    if (!fs.existsSync(cwd)) {
+        throw new Error(`Directory does not exist: ${cwd}`);
+    }
+    let extraEnv = {};
+    if (cmd === 'gh') {
+        const token = await getGhToken(cwd);
+        if (token)
+            extraEnv['GH_TOKEN'] = token;
+    }
+    const env = Object.keys(extraEnv).length > 0 ? { ...process.env, ...extraEnv } : undefined;
+    try {
+        return await execFileAsync(cmd, args, { cwd, shell: true, ...(env && { env }) });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            console.log(`[opencode-events] ENOENT with shell: true. Trying fallback exec...`);
+            const envPrefix = extraEnv['GH_TOKEN'] ? `GH_TOKEN=${extraEnv['GH_TOKEN']} ` : '';
+            return await execAsync(`${envPrefix}${cmd} ${args.join(' ')}`, { cwd });
+        }
+        throw e;
+    }
+}
+export async function setupOpencodeEventListener(events, opencodeClient, sessionID, ticket, agentUrl, config, activeSessions, worktreePath, originalWorkspacePath, branchName, agentType = 'opencode') {
+    const processedMessages = new Set();
+    const processedTools = new Set();
+    const activeParts = new Map();
+    try {
+        for await (const event of events.stream) {
+            // FILTER for events belonging solely to THIS session
+            const eventSessionId = event.properties?.sessionID || event.properties?.info?.sessionID || event.properties?.part?.sessionID;
+            if (eventSessionId && eventSessionId !== sessionID)
+                continue;
+            // Handle Blocking Permissions
+            if (event.type === 'permission.asked') {
+                console.log(`[opencode-agent] Permission requested for ticket ${ticket.id}. Waiting for UI approval.`);
+                commentRepository.create({
+                    ticketId: ticket.id,
+                    author: 'System',
+                    content: `⚠️ **Permission Required**\n\nThe agent needs your permission to continue. Please open the [Agent UI](${agentUrl}) to approve or deny the request.`
+                });
+                ticketRepository.updateAgentSession(ticket.id, {
+                    column_id: ticket.column_id,
+                    agent_type: agentType,
+                    status: 'needs_approval',
+                    port: 4096,
+                    url: agentUrl
+                });
+            }
+            // Resume processing when permission is explicitly granted/answered
+            if (event.type === 'permission.replied') {
+                console.log(`[opencode-agent] Permission answered for ticket ${ticket.id}. Resuming processing.`);
+                ticketRepository.updateAgentSession(ticket.id, {
+                    column_id: ticket.column_id,
+                    agent_type: agentType,
+                    status: 'processing',
+                    port: 4096,
+                    url: agentUrl
+                });
+            }
+            // Handle API Quotas & Retries
+            if (event.type === 'session.status') {
+                const status = event.properties.status;
+                if (status.type === 'retry') {
+                    // Let's only post the retry warning on the first few attempts so it doesn't spam infinitely
+                    if (status.attempt <= 5) {
+                        commentRepository.create({
+                            ticketId: ticket.id,
+                            author: 'System',
+                            content: `⚠️ **API Retry Attempt ${status.attempt}**\n\n${status.message}`
+                        });
+                    }
+                }
+            }
+            // Handle Fatal Session Errors
+            if (event.type === 'session.error') {
+                const err = event.properties.error;
+                if (err) {
+                    commentRepository.create({
+                        ticketId: ticket.id,
+                        author: 'System',
+                        content: `❌ **Fatal Error: ${err.name}**\n\n${err.data?.message || JSON.stringify(err.data)}`
+                    });
+                    // Agent failed, mark ticket as blocked/failed
+                    ticketRepository.updateAgentSession(ticket.id, {
+                        column_id: ticket.column_id,
+                        agent_type: agentType,
+                        status: 'blocked',
+                        port: 4096,
+                        url: agentUrl,
+                        error_message: err.data?.message || err.name
+                    });
+                }
+            }
+            // Handle Text Messages (Wait for assistant message to complete)
+            if (event.type === 'message.updated') {
+                const info = event.properties.info;
+                if (info.role === 'assistant' && info.time?.completed && !processedMessages.has(info.id)) {
+                    processedMessages.add(info.id);
+                    try {
+                        const messagesRes = await opencodeClient.session.messages({ path: { id: sessionID } });
+                        if (messagesRes.data) {
+                            const targetMsg = messagesRes.data.find((m) => m.info.id === info.id);
+                            if (targetMsg && targetMsg.parts) {
+                                for (const part of targetMsg.parts) {
+                                    if (part.type === 'text' && part.text?.trim()) {
+                                        commentRepository.create({
+                                            ticketId: ticket.id,
+                                            author: 'opencode',
+                                            content: part.text.trim()
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (fetchErr) {
+                        console.error(`[opencode-agent] Failed to fetch parts for message ${info.id}`, fetchErr);
+                    }
+                }
+            }
+            // Handle Tool Completions and Reasoning Real-Time
+            if (event.type === 'message.part.updated') {
+                const part = event.properties.part;
+                // 1. Handle tool executions
+                if (part.type === 'tool' && part.state?.status === 'completed' && !processedTools.has(part.id)) {
+                    processedTools.add(part.id);
+                    let content = `Executed \`${part.tool}\``;
+                    if (part.state.title)
+                        content += `\n*${part.state.title}*`;
+                    commentRepository.create({
+                        ticketId: ticket.id,
+                        author: 'opencode',
+                        content: content
+                    });
+                }
+                // 2. Handle final reasoning/thoughts block (if not caught by deltas)
+                if (part.type === 'reasoning' && !processedTools.has(part.id)) {
+                    processedTools.add(part.id);
+                    // If we already tracked this via deltas, don't recreate it
+                    if (!activeParts.has(part.id) && part.text && part.text.trim()) {
+                        commentRepository.create({
+                            ticketId: ticket.id,
+                            author: 'opencode (thought)',
+                            content: part.text.trim()
+                        });
+                    }
+                }
+            }
+            // Handle Session Idle (Task Completed)
+            if (event.type === 'session.idle') {
+                console.log(`[opencode-agent] Agent task completed (idle) for ticket ${ticket.id}.`);
+                // Check if the session failed with a fatal error previously
+                const currentTicket = ticketRepository.findById(ticket.id);
+                const hasError = currentTicket?.agent_sessions?.some((s) => s.column_id === ticket.column_id && s.status === 'blocked');
+                if (!hasError) {
+                    // Mark the ticket as done now that the agent session finished processing
+                    ticketRepository.updateAgentSession(ticket.id, {
+                        column_id: ticket.column_id,
+                        agent_type: agentType,
+                        status: 'done',
+                        port: 4096,
+                        url: agentUrl
+                    });
+                    if (agentType === 'code_review') {
+                        try {
+                            // Find out if the PR was approved or changes requested
+                            const latestTicket = ticketRepository.findById(ticket.id) || ticket;
+                            const prUrlSession = [...(latestTicket.agent_sessions || [])].reverse().find(s => s.pr_url);
+                            const prUrl = prUrlSession?.pr_url;
+                            if (prUrl) {
+                                const { stdout: prStatus } = await runCmd('gh', ['pr', 'view', prUrl, '--json', 'comments'], worktreePath);
+                                const comments = JSON.parse(prStatus).comments;
+                                // Find the latest comment that contains a decision
+                                let reviewDecision = 'NONE';
+                                // 1. Check GitHub PR comments First
+                                if (comments && comments.length > 0) {
+                                    for (const comment of [...comments].reverse()) {
+                                        const bodyLower = comment.body.toLowerCase();
+                                        if (bodyLower.includes('[approved]') || bodyLower.includes('approve the pr') || bodyLower.includes('lgtm') || bodyLower.includes('approved')) {
+                                            reviewDecision = 'APPROVED';
+                                            break;
+                                        }
+                                        if (bodyLower.includes('[changes_requested]') || bodyLower.includes('request changes') || bodyLower.includes('changes requested') || bodyLower.includes('changes are needed')) {
+                                            reviewDecision = 'CHANGES_REQUESTED';
+                                            break;
+                                        }
+                                    }
+                                }
+                                // 2. Fallback to Local Chat Logs
+                                if (reviewDecision === 'NONE') {
+                                    const localDbComments = commentRepository.findByTicketId(ticket.id);
+                                    if (localDbComments && localDbComments.length > 0) {
+                                        for (const dbC of [...localDbComments].reverse()) {
+                                            const bodyLower = dbC.content.toLowerCase();
+                                            if (bodyLower.includes('[approved]') || bodyLower.includes('approve the pr') || bodyLower.includes('lgtm') || bodyLower.includes('approved')) {
+                                                reviewDecision = 'APPROVED';
+                                                break;
+                                            }
+                                            if (bodyLower.includes('[changes_requested]') || bodyLower.includes('request changes') || bodyLower.includes('changes requested') || bodyLower.includes('changes are needed')) {
+                                                reviewDecision = 'CHANGES_REQUESTED';
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                                console.log(`[codereview-agent] PR ${prUrl} review decision parsed from comments: ${reviewDecision}`);
+                                if (reviewDecision === 'APPROVED') {
+                                    commentRepository.create({
+                                        ticketId: ticket.id,
+                                        author: 'System',
+                                        content: `✅ **Code Review Approved!**\n\nThe agent approved the PR.`
+                                    });
+                                    // Move ticket to the configured destination column (if set)
+                                    if (config.on_finish_column_id) {
+                                        console.log(`[codereview-agent] Moving ticket ${ticket.id} forward to column ${config.on_finish_column_id}`);
+                                        const moved = ticketRepository.move(ticket.id, config.on_finish_column_id, 0);
+                                        if (moved) {
+                                            // Trigger via the queue so concurrency/priority rules are respected
+                                            agentQueue.evaluateColumnQueue(config.on_finish_column_id);
+                                        }
+                                    }
+                                }
+                                else if (reviewDecision === 'CHANGES_REQUESTED') {
+                                    commentRepository.create({
+                                        ticketId: ticket.id,
+                                        author: 'System',
+                                        content: `⚠️ **Changes Requested**\n\nThe agent has requested changes on the PR. Sending ticket back for revision.`
+                                    });
+                                    if (config.on_reject_column_id) {
+                                        console.log(`[codereview-agent] Moving ticket ${ticket.id} back to configured reject column ${config.on_reject_column_id}`);
+                                        const moved = ticketRepository.move(ticket.id, config.on_reject_column_id, 0);
+                                        if (moved) {
+                                            // Use force=true so the dev agent will re-run even though it previously finished 'done'
+                                            agentQueue.enqueue(moved.id, true);
+                                        }
+                                    }
+                                    else {
+                                        console.warn(`[codereview-agent] Ticket ${ticket.id} rejected, but no 'on_reject_column_id' is configured!`);
+                                    }
+                                }
+                                else {
+                                    commentRepository.create({
+                                        ticketId: ticket.id,
+                                        author: 'System',
+                                        content: `ℹ️ **Code Review Finished**\n\nThe review was completed, but no explicit approval or changes were requested.`
+                                    });
+                                }
+                            }
+                        }
+                        catch (err) {
+                            console.error(`[codereview-agent] Error handling post-review logic`, err);
+                        }
+                    }
+                    else if (agentType === 'opencode') {
+                        // Commit, push, and create PR before moving ticket
+                        try {
+                            console.log(`[opencode-agent] Checking for changes in worktree ${worktreePath}`);
+                            const { stdout: statusOut } = await runCmd('git', ['status', '--porcelain'], worktreePath);
+                            if (statusOut.trim()) {
+                                console.log(`[opencode-agent] Changes found for ticket ${ticket.id}. Committing and pushing.`);
+                                await runCmd('git', ['add', '.'], worktreePath);
+                                await runCmd('git', ['commit', '-m', `"${ticket.title.replace(/"/g, '\\"')}"`], worktreePath);
+                                // Inject GH_TOKEN into remote URL for git push authentication
+                                const token = await getGhToken(worktreePath);
+                                if (token) {
+                                    try {
+                                        const { stdout: remoteUrlOut } = await runCmd('git', ['config', '--get', 'remote.origin.url'], worktreePath);
+                                        const remoteUrl = remoteUrlOut.trim();
+                                        if (remoteUrl.startsWith('https://github.com/')) {
+                                            const authedUrl = remoteUrl.replace('https://github.com/', `https://x-access-token:${token}@github.com/`);
+                                            await runCmd('git', ['remote', 'set-url', 'origin', authedUrl], worktreePath);
+                                        }
+                                    }
+                                    catch (urlErr) {
+                                        console.warn(`[opencode-agent] Could not set authenticated remote URL:`, urlErr);
+                                    }
+                                }
+                                await runCmd('git', ['push', '-u', 'origin', branchName], worktreePath);
+                                // Check if a PR already exists for this ticket (fetch fresh from DB)
+                                const freshTicket = ticketRepository.findById(ticket.id) || ticket;
+                                const existingPrUrlSession = [...(freshTicket.agent_sessions || [])].reverse().find(s => s.pr_url);
+                                let prUrl = existingPrUrlSession?.pr_url;
+                                if (prUrl) {
+                                    commentRepository.create({
+                                        ticketId: ticket.id,
+                                        author: 'System',
+                                        content: `🚀 **Pull Request Updated**\n\nThe agent has updated the existing PR:\n${prUrl}`
+                                    });
+                                }
+                                else {
+                                    const { stdout: prOut } = await runCmd('gh', ['pr', 'create', '--title', `"${ticket.title.replace(/"/g, '\\"')}"`, '--body', `"Automated PR from OpenCode Agent for ticket #${ticket.id}"`], worktreePath);
+                                    prUrl = prOut.trim();
+                                    commentRepository.create({
+                                        ticketId: ticket.id,
+                                        author: 'System',
+                                        content: `🚀 **Pull Request Created**\n\nThe agent has proposed the following changes in a PR. Check it out:\n${prUrl}`
+                                    });
+                                }
+                                // Add PR URL to the active agent session so the UI displays the code review button
+                                ticketRepository.updateAgentSession(ticket.id, {
+                                    column_id: ticket.column_id,
+                                    agent_type: 'opencode',
+                                    status: 'done',
+                                    port: 4096,
+                                    url: agentUrl,
+                                    pr_url: prUrl
+                                });
+                            }
+                            else {
+                                console.log(`[opencode-agent] No changes to push for ticket ${ticket.id}.`);
+                                commentRepository.create({
+                                    ticketId: ticket.id,
+                                    author: 'System',
+                                    content: `ℹ️ **Task Completed (No Changes)**\n\nThe agent finished the task but did not make any code changes.`
+                                });
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[opencode-agent] Failed to create PR for ticket ${ticket.id}`, error);
+                            commentRepository.create({
+                                ticketId: ticket.id,
+                                author: 'System',
+                                content: `❌ **Failed to Create PR**\n\nThe agent finished the task, but an error occurred while pushing changes or creating the PR:\n\`\`\`\n${error.message}\n\`\`\``
+                            });
+                        }
+                        // Move ticket to the configured destination column (if set)
+                        if (config.on_finish_column_id) {
+                            console.log(`[opencode-agent] Moving ticket ${ticket.id} to column ${config.on_finish_column_id}`);
+                            const moved = ticketRepository.move(ticket.id, config.on_finish_column_id, 0);
+                            if (moved) {
+                                // Trigger via the queue so concurrency/priority rules are respected
+                                agentQueue.evaluateColumnQueue(config.on_finish_column_id);
+                            }
+                        }
+                    } // End of agentType === 'opencode' block
+                }
+                // Clean up the server instance tracking after a brief delay
+                setTimeout(() => {
+                    console.log(`[opencode-agent] Cleaning up tracking for ${ticket.id}`);
+                    delete activeSessions[ticket.id];
+                }, 60000); // 1 minute cleanup
+            }
+            // ── Live Text Streaming via Deltas ──
+            if (event.type === 'message.part.delta') {
+                const partID = event.properties.partID;
+                const delta = event.properties.delta;
+                if (delta) {
+                    let tracking = activeParts.get(partID);
+                    if (!tracking) {
+                        // create initial comment
+                        const comment = commentRepository.create({
+                            ticketId: ticket.id,
+                            author: 'opencode',
+                            content: delta
+                        });
+                        tracking = { commentId: comment.id, fullText: delta };
+                        activeParts.set(partID, tracking);
+                    }
+                    else {
+                        // update existing comment
+                        tracking.fullText += delta;
+                        commentRepository.update(tracking.commentId, tracking.fullText);
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[opencode-agent] Event stream error for ticket ${ticket.id}:`, err);
+    }
+}

package/packages/server/dist/db/database.js

@@ -0,0 +1,159 @@
+import initSqlJs from 'sql.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import fs from 'fs';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DB_PATH = path.join(__dirname, '..', '..', '..', 'openboard.db');
+// Resolve sql.js WASM dynamically — handles npm workspace node_modules hoisting
+const require = createRequire(import.meta.url);
+const sqlJsDir = path.dirname(require.resolve('sql.js/dist/sql-wasm.wasm'));
+const WASM_PATH = path.join(sqlJsDir, 'sql-wasm.wasm');
+let db;
+let inTransaction = false;
+function makeStatement(sql) {
+    return {
+        all(...params) {
+            const results = db.exec(sql, params.length ? params : undefined);
+            if (!results.length || !results[0].values.length)
+                return [];
+            const { columns, values } = results[0];
+            return values.map(row => Object.fromEntries(columns.map((col, i) => [col, row[i]])));
+        },
+        get(...params) {
+            return this.all(...params)[0];
+        },
+        run(...params) {
+            db.run(sql, params.length ? params : undefined);
+            // Don't persist mid-transaction — sql.js auto-commits on db.export(),
+            // which would invalidate the open transaction and cause COMMIT/ROLLBACK to fail.
+            if (!inTransaction)
+                persist();
+        },
+    };
+}
+function persist() {
+    const data = db.export();
+    fs.writeFileSync(DB_PATH, Buffer.from(data));
+}
+// ---------------------------------------------------------------------------
+// Transaction helper (sql.js has no WAL, runs synchronously anyway)
+// ---------------------------------------------------------------------------
+function transaction(fn) {
+    return () => {
+        inTransaction = true;
+        db.run('BEGIN');
+        try {
+            fn();
+            db.run('COMMIT');
+            inTransaction = false;
+            persist(); // single persist after the full transaction commits
+        }
+        catch (e) {
+            db.run('ROLLBACK');
+            inTransaction = false;
+            throw e;
+        }
+    };
+}
+let dbHandle;
+export async function initDb() {
+    if (dbHandle)
+        return dbHandle;
+    const wasmFile = fs.readFileSync(WASM_PATH);
+    const wasmBinary = wasmFile.buffer.slice(wasmFile.byteOffset, wasmFile.byteOffset + wasmFile.byteLength);
+    const SQL = await initSqlJs({ wasmBinary });
+    if (fs.existsSync(DB_PATH)) {
+        const fileBuffer = fs.readFileSync(DB_PATH);
+        db = new SQL.Database(new Uint8Array(fileBuffer.buffer, fileBuffer.byteOffset, fileBuffer.byteLength));
+    }
+    else {
+        db = new SQL.Database();
+    }
+    db.run('PRAGMA foreign_keys = ON;');
+    runMigrations();
+    dbHandle = {
+        prepare: makeStatement,
+        exec: (sql) => { db.exec(sql); persist(); },
+        transaction,
+    };
+    return dbHandle;
+}
+export function getDb() {
+    if (!dbHandle)
+        throw new Error('DB not initialized. Call initDb() first.');
+    return dbHandle;
+}
+function runMigrations() {
+    db.run(`
+    CREATE TABLE IF NOT EXISTS boards (
+      id         TEXT PRIMARY KEY,
+      name       TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS board_workspaces (
+      id         TEXT PRIMARY KEY,
+      board_id   TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      type       TEXT NOT NULL, -- 'folder' or 'git'
+      path       TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS columns (
+      id         TEXT PRIMARY KEY,
+      board_id   TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      name       TEXT NOT NULL,
+      position   INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS tickets (
+      id          TEXT PRIMARY KEY,
+      column_id   TEXT NOT NULL REFERENCES columns(id) ON DELETE CASCADE,
+      board_id    TEXT NOT NULL REFERENCES boards(id) ON DELETE CASCADE,
+      title       TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      priority    TEXT NOT NULL DEFAULT 'medium',
+      position    INTEGER NOT NULL DEFAULT 0,
+      agent_sessions TEXT NOT NULL DEFAULT '[]',
+      created_at  TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id          TEXT PRIMARY KEY,
+      ticket_id   TEXT NOT NULL REFERENCES tickets(id) ON DELETE CASCADE,
+      author      TEXT NOT NULL DEFAULT 'agent',
+      content     TEXT NOT NULL,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS column_configs (
+      column_id            TEXT PRIMARY KEY REFERENCES columns(id) ON DELETE CASCADE,
+      agent_type           TEXT NOT NULL,
+      agent_model          TEXT,
+      on_finish_column_id  TEXT
+    );
+  `);
+    try {
+        db.run("ALTER TABLE tickets ADD COLUMN agent_sessions TEXT NOT NULL DEFAULT '[]';");
+        console.log("[db] Migration: Added agent_sessions column to tickets table");
+    }
+    catch (e) { }
+    try {
+        db.run("ALTER TABLE column_configs ADD COLUMN agent_model TEXT;");
+        console.log("[db] Migration: Added agent_model column to column_configs table");
+    }
+    catch (e) { }
+    try {
+        db.run("ALTER TABLE column_configs ADD COLUMN max_agents INTEGER DEFAULT 1;");
+        console.log("[db] Migration: Added max_agents column to column_configs table");
+    }
+    catch (e) { }
+    try {
+        db.run("ALTER TABLE column_configs ADD COLUMN on_reject_column_id TEXT;");
+        console.log("[db] Migration: Added on_reject_column_id column to column_configs table");
+    }
+    catch (e) { }
+    persist();
+}

package/packages/server/dist/index.js

@@ -0,0 +1,66 @@
+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 { 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.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'));
+    });
+    app.listen(PORT, () => {
+        console.log(`[openboard] Server running at http://localhost:${PORT}`);
+    });
+}
+start().catch(err => {
+    console.error('[openboard] Failed to start:', err);
+    process.exit(1);
+});