@openboard/start 1.0.2

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

@@ -0,0 +1,173 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import fg from 'fast-glob';
+import { normalizePathForOS } from '../utils/os.js';
+const router = Router();
+async function getWindowsDrives() {
+    const drives = [];
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    for (const letter of alphabet) {
+        const drive = `${letter}:`;
+        try {
+            fs.accessSync(drive + path.sep);
+            drives.push(drive);
+        }
+        catch {
+            // Drive not accessible or doesn't exist
+        }
+    }
+    return drives;
+}
+router.get('/browse', async (req, res) => {
+    let currentPath = normalizePathForOS(req.query.path || '');
+    try {
+        if (!currentPath && process.platform === 'win32') {
+            const drives = await getWindowsDrives();
+            const entries = drives.map(drive => ({
+                name: drive,
+                path: drive + '\\',
+                isRepo: false,
+                hasSrc: false,
+                hasPublic: false,
+                isDir: true
+            }));
+            res.json({ currentPath: '', entries });
+            return;
+        }
+        if (!currentPath) {
+            currentPath = '/';
+        }
+        const items = await fs.promises.readdir(currentPath, { withFileTypes: true });
+        const entries = [];
+        for (const item of items) {
+            if (!item.isDirectory())
+                continue;
+            const fullPath = path.join(currentPath, item.name);
+            let isRepo = false;
+            let hasSrc = false;
+            let hasPublic = false;
+            try {
+                const subItems = await fs.promises.readdir(fullPath);
+                isRepo = subItems.includes('.git');
+                hasSrc = subItems.includes('src');
+                hasPublic = subItems.includes('public');
+            }
+            catch {
+                // Ignore errors (e.g. permission denied)
+            }
+            entries.push({
+                name: item.name,
+                path: fullPath,
+                isRepo,
+                hasSrc,
+                hasPublic,
+                isDir: true
+            });
+        }
+        // Sorting: Repos first, then alphabetical
+        entries.sort((a, b) => {
+            if (a.isRepo && !b.isRepo)
+                return -1;
+            if (!a.isRepo && b.isRepo)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
+        res.json({ currentPath, entries });
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/search', async (req, res) => {
+    const query = (req.query.query || '').toLowerCase();
+    const basePath = normalizePathForOS(req.query.basePath || '');
+    if (!query || !basePath) {
+        res.json([]);
+        return;
+    }
+    try {
+        const items = await fs.promises.readdir(basePath, { withFileTypes: true });
+        const results = [];
+        for (const item of items) {
+            if (!item.isDirectory())
+                continue;
+            if (item.name.toLowerCase().includes(query)) {
+                const fullPath = path.join(basePath, item.name);
+                let isRepo = false;
+                let hasSrc = false;
+                let hasPublic = false;
+                try {
+                    const subItems = await fs.promises.readdir(fullPath);
+                    isRepo = subItems.includes('.git');
+                    hasSrc = subItems.includes('src');
+                    hasPublic = subItems.includes('public');
+                }
+                catch { }
+                results.push({
+                    name: item.name,
+                    path: fullPath,
+                    isRepo,
+                    hasSrc,
+                    hasPublic,
+                    isDir: true
+                });
+            }
+        }
+        res.json(results);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+router.get('/search/global', async (req, res) => {
+    const query = (req.query.query || '').toLowerCase();
+    if (!query || query.length < 2) {
+        res.json([]);
+        return;
+    }
+    try {
+        // Start search from home directory
+        const homeDir = os.homedir();
+        // Use fast-glob to find directories matching query
+        // Limit depth and results for performance
+        const pattern = `*${query}*`;
+        const matches = await fg(pattern, {
+            cwd: homeDir,
+            onlyDirectories: true,
+            unique: true,
+            absolute: true,
+            deep: 3, // Depth limit
+            ignore: ['**/node_modules/**', '**/.*/**']
+        });
+        const results = [];
+        const limitedMatches = matches.slice(0, 50); // Result limit
+        for (const fullPath of limitedMatches) {
+            const name = path.basename(fullPath);
+            let isRepo = false;
+            let hasSrc = false;
+            let hasPublic = false;
+            try {
+                const subItems = await fs.promises.readdir(fullPath);
+                isRepo = subItems.includes('.git');
+                hasSrc = subItems.includes('src');
+                hasPublic = subItems.includes('public');
+            }
+            catch { }
+            results.push({
+                name,
+                path: fullPath,
+                isRepo,
+                hasSrc,
+                hasPublic,
+                isDir: true
+            });
+        }
+        res.json(results);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+export { router as systemRouter };

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 {};

package/packages/server/dist/utils/opencode.js

@@ -0,0 +1,11 @@
+import { createOpencodeClient } from '@opencode-ai/sdk';
+const opencodePort = process.env.OPENCODE_PORT || 4096;
+/**
+ * Creates an Opencode client instance scoped to a specific board directory.
+ */
+export function createBoardScopedClient(boardPath) {
+    return createOpencodeClient({
+        baseUrl: `http://127.0.0.1:${opencodePort}`,
+        directory: boardPath
+    });
+}

package/packages/server/dist/utils/os.js

@@ -0,0 +1,73 @@
+import { execFile, exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs';
+const execFileAsync = promisify(execFile);
+const execAsync = promisify(exec);
+/**
+ * Normalizes paths for mixed environments (e.g. WSL-style paths in a Windows process).
+ */
+export function normalizePathForOS(p) {
+    if (!p)
+        return p;
+    let normalized = p;
+    if (process.platform === 'win32') {
+        // Convert all forward slashes to backslashes first for consistency on Windows
+        normalized = normalized.replace(/\//g, '\\');
+        // Match \mnt\c\... or /mnt/c/... (case insensitive)
+        const mntMatch = normalized.match(/^[\\\/]mnt[\\\/]([a-z])([\\\/]|$)/i);
+        if (mntMatch) {
+            const drive = mntMatch[1].toUpperCase();
+            // Remove the /mnt/c/ prefix
+            const rest = normalized.substring(mntMatch[0].length);
+            normalized = `${drive}:\\${rest}`;
+        }
+    }
+    else {
+        normalized = normalized.replace(/\\/g, '/');
+    }
+    return normalized;
+}
+// Cache the gh token so we only fetch it once per server process
+let cachedGhToken = null;
+export async function getGhToken(cwd) {
+    if (cachedGhToken !== null)
+        return cachedGhToken;
+    try {
+        const { stdout } = await execFileAsync('gh', ['auth', 'token'], { cwd: normalizePathForOS(cwd), shell: true });
+        cachedGhToken = stdout.trim() || null;
+    }
+    catch {
+        cachedGhToken = null;
+    }
+    return cachedGhToken;
+}
+/**
+ * Helper function to execute commands robustly across OS.
+ * Automatically injects GH_TOKEN for any `gh` subcommand and handles shell execution on Windows.
+ */
+export async function runCmd(cmd, args, cwd, prefix = '') {
+    const normalizedCwd = normalizePathForOS(cwd);
+    console.log(`[${prefix || 'os-util'}] Running: ${cmd} ${args.join(' ')} in cwd: ${normalizedCwd}`);
+    // Safety check for CWD
+    if (!fs.existsSync(normalizedCwd)) {
+        throw new Error(`Directory does not exist: ${normalizedCwd}`);
+    }
+    let extraEnv = {};
+    if (cmd === 'gh') {
+        const token = await getGhToken(normalizedCwd);
+        if (token)
+            extraEnv['GH_TOKEN'] = token;
+    }
+    const env = { ...process.env, ...extraEnv };
+    try {
+        // use shell: true to help find binaries in PATH on Windows
+        return await execFileAsync(cmd, args, { cwd: normalizedCwd, env, shell: true });
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            const envPrefix = extraEnv['GH_TOKEN'] ? (process.platform === 'win32' ? `set GH_TOKEN=${extraEnv['GH_TOKEN']}&& ` : `GH_TOKEN=${extraEnv['GH_TOKEN']} `) : '';
+            return await execAsync(`${envPrefix}${cmd} ${args.join(' ')}`, { cwd: normalizedCwd });
+        }
+        throw e;
+    }
+}