@openboard/start 1.0.20

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

@@ -0,0 +1,364 @@
+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 activeParts = new Map();
+    let rawSessionCost = 0;
+    let sessionCommentId = null;
+    let sessionCommentContent = "";
+    function updateSessionComment(content, type = 'message', append = true) {
+        let prefix = "";
+        if (type === 'status')
+            prefix = "\n---\n";
+        if (type === 'pr')
+            prefix = "\n---\n";
+        if (append) {
+            sessionCommentContent += (sessionCommentContent ? prefix : "") + content;
+        }
+        else {
+            sessionCommentContent = content;
+        }
+        if (sessionCommentId) {
+            commentRepository.update(sessionCommentId, sessionCommentContent);
+        }
+        else {
+            const comment = commentRepository.create({
+                ticketId: ticket.id,
+                author: 'opencode', // Fixed author for session log
+                content: sessionCommentContent
+            });
+            sessionCommentId = comment.id;
+        }
+    }
+    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.`);
+                updateSessionComment(`⚠️ **Permission Required**\n\nThe agent needs your permission to continue. Please open the [Agent UI](${agentUrl}) to approve or deny the request.`, 'status');
+                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.`);
+                updateSessionComment(`✅ **Permission Handled**`, 'status');
+                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) {
+                        updateSessionComment(`⚠️ **API Retry Attempt ${status.attempt}**\n\n${status.message}`, 'status');
+                    }
+                }
+            }
+            // Handle Fatal Session Errors
+            if (event.type === 'session.error') {
+                const err = event.properties.error;
+                if (err) {
+                    updateSessionComment(`❌ **Fatal Error: ${err.name}**\n\n${err.data?.message || JSON.stringify(err.data)}`, 'status');
+                    // 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.cost) {
+                    rawSessionCost += info.cost;
+                }
+                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) {
+                                let combinedText = '';
+                                for (const part of targetMsg.parts) {
+                                    if (part.type === 'text' && part.text?.trim()) {
+                                        combinedText += (combinedText ? '\n\n' : '') + part.text.trim();
+                                    }
+                                }
+                                if (combinedText) {
+                                    // With session consolidation, we might just want to refresh or ensure it's there.
+                                    // For now, let's keep it simple: the deltas handle the live updates, 
+                                    // and message.updated ensures the final state is correct if deltas were missed.
+                                    // We don't want to double append. 
+                                    // Since we are using a single sessionCommentContent, we'll just let deltas do the work.
+                                }
+                            }
+                        }
+                    }
+                    catch (fetchErr) {
+                        console.error(`[opencode-agent] Failed to fetch parts for message ${info.id}`, fetchErr);
+                    }
+                }
+            }
+            // Handle Tool Completions and Reasoning Real-Time
+            // (WE NOW IGNORE THESE AS PER USER REQUEST TO ONLY SHOW IMPORTANT COMMENTS)
+            if (event.type === 'message.part.updated') {
+                const part = event.properties.part;
+                if (part.type === 'step-finish' && part.cost) {
+                    rawSessionCost += part.cost;
+                }
+            }
+            // 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 current session failed with a fatal error previously
+                const currentTicket = ticketRepository.findById(ticket.id);
+                const sessionsForColumn = currentTicket?.agent_sessions?.filter((s) => s.column_id === ticket.column_id) || [];
+                const latestSession = sessionsForColumn[sessionsForColumn.length - 1];
+                const hasError = latestSession?.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,
+                        total_cost: rawSessionCost > 0 ? Number(rawSessionCost.toFixed(4)) : undefined
+                    });
+                    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') {
+                                    updateSessionComment(`✅ **Code Review Approved!**\n\nThe agent approved the PR.`, 'status');
+                                    // 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') {
+                                    updateSessionComment(`⚠️ **Changes Requested**\n\nThe agent has requested changes on the PR. Sending ticket back for revision.`, 'status');
+                                    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 {
+                                    updateSessionComment(`ℹ️ **Code Review Finished**\n\nThe review was completed, but no explicit approval or changes were requested.`, 'status');
+                                }
+                            }
+                        }
+                        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) {
+                                    updateSessionComment(`🚀 **Pull Request Updated**\n\nThe agent has updated the existing PR:\n${prUrl}${rawSessionCost > 0 ? `\n\n**Total Cost:** $${rawSessionCost.toFixed(4)}` : ''}`, 'pr');
+                                }
+                                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();
+                                    updateSessionComment(`🚀 **Pull Request Created**\n\nThe agent has proposed the following changes in a PR. Check it out:\n${prUrl}${rawSessionCost > 0 ? `\n\n**Total Cost:** $${rawSessionCost.toFixed(4)}` : ''}`, 'pr');
+                                }
+                                // 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,
+                                    total_cost: rawSessionCost > 0 ? Number(rawSessionCost.toFixed(4)) : undefined
+                                });
+                            }
+                            else {
+                                console.log(`[opencode-agent] No changes to push for ticket ${ticket.id}.`);
+                                updateSessionComment(`ℹ️ **Task Completed (No Changes)**\n\nThe agent finished the task but did not make any code changes.${rawSessionCost > 0 ? `\n\n**Total Cost:** $${rawSessionCost.toFixed(4)}` : ''}`, 'status');
+                            }
+                        }
+                        catch (error) {
+                            console.error(`[opencode-agent] Failed to create PR for ticket ${ticket.id}`, error);
+                            updateSessionComment(`❌ **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\`\`\``, 'status');
+                        }
+                        // 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
+                }
+                // Wait! Since this ticket finished processing, we should re-evaluate the CURRENT column
+                // so the next pending ticket can be picked up by an agent.
+                agentQueue.evaluateColumnQueue(ticket.column_id);
+                // 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 delta = event.properties.delta;
+                const messageID = event.properties.messageID;
+                if (delta && messageID) {
+                    updateSessionComment(delta, 'message', true);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error(`[opencode-agent] Event stream error for ticket ${ticket.id}:`, err);
+    }
+}

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

@@ -0,0 +1,170 @@
+import initSqlJs from 'sql.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import fs from 'fs';
+import os from 'os';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const openboardDir = path.join(os.homedir(), '.openboard');
+if (!fs.existsSync(openboardDir)) {
+    fs.mkdirSync(openboardDir, { recursive: true });
+}
+const DB_PATH = path.join(openboardDir, 'openboard.db');
+console.log("[db] DB_PATH", DB_PATH);
+// Migrate old database if it exists
+const oldDbPath = path.join(__dirname, '..', '..', '..', 'openboard.db');
+if (fs.existsSync(oldDbPath) && !fs.existsSync(DB_PATH)) {
+    fs.copyFileSync(oldDbPath, DB_PATH);
+}
+// 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/gh-worker.js

@@ -0,0 +1,82 @@
+import { ticketRepository } from './repositories/ticket.repository.js';
+import { commentRepository } from './repositories/comment.repository.js';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { getDb } from './db/database.js';
+const execFileAsync = promisify(execFile);
+export class GhWorker {
+    interval = null;
+    isPolling = false;
+    start() {
+        console.log('[gh-worker] Starting GitHub PR status worker...');
+        this.poll();
+        this.interval = setInterval(() => this.poll(), 10_000); // Every 60 seconds
+    }
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    async poll() {
+        if (this.isPolling)
+            return;
+        this.isPolling = true;
+        try {
+            // Find all tickets with a PR URL that isn't merged or closed
+            const db = getDb();
+            const rows = db.prepare('SELECT * FROM tickets').all();
+            for (const row of rows) {
+                let sessions = [];
+                try {
+                    sessions = JSON.parse(row.agent_sessions);
+                }
+                catch {
+                    continue;
+                }
+                if (!sessions || sessions.length === 0)
+                    continue;
+                for (let i = sessions.length - 1; i >= 0; i--) {
+                    const session = sessions[i];
+                    if (session.pr_url && (!session.pr_status || session.pr_status === 'OPEN')) {
+                        try {
+                            const { stdout } = await execFileAsync('gh', ['pr', 'view', session.pr_url, '--json', 'state'], { shell: true });
+                            const data = JSON.parse(stdout);
+                            const newState = data.state; // 'OPEN', 'MERGED', 'CLOSED'
+                            if (newState && newState !== session.pr_status) {
+                                console.log(`[gh-worker] PR status changed from ${session.pr_status} to ${newState} for ticket ${row.id}`);
+                                // Update this specific session
+                                session.pr_status = newState;
+                                ticketRepository.updateAgentSession(row.id, session);
+                                if (newState === 'MERGED') {
+                                    commentRepository.create({
+                                        ticketId: row.id,
+                                        author: 'System',
+                                        content: `🎉 **Pull Request Merged!**\n\nThe PR [${session.pr_url}](${session.pr_url}) has been merged.`
+                                    });
+                                }
+                                else if (newState === 'CLOSED') {
+                                    commentRepository.create({
+                                        ticketId: row.id,
+                                        author: 'System',
+                                        content: `🚫 **Pull Request Closed**\n\nThe PR [${session.pr_url}](${session.pr_url}) was closed without merging.`
+                                    });
+                                }
+                            }
+                        }
+                        catch (e) {
+                            console.warn(`[gh-worker] Failed to check PR status for ${session.pr_url}: ${e.message}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.error('[gh-worker] Polling error:', err);
+        }
+        finally {
+            this.isPolling = false;
+        }
+    }
+}
+export const ghWorker = new GhWorker();