teamcopilot 0.0.1

package/dist/chat/index.js

@@ -0,0 +1,849 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const client_1 = __importDefault(require("../prisma/client"));
+const index_1 = require("../utils/index");
+const opencode_client_1 = require("../utils/opencode-client");
+const chat_session_1 = require("../utils/chat-session");
+const assert_1 = require("../utils/assert");
+const redact_1 = require("../utils/redact");
+const session_abort_1 = require("../utils/session-abort");
+const router = express_1.default.Router({ mergeParams: true });
+const USER_INSTRUCTIONS_FILENAME = "USER_INSTRUCTIONS.md";
+const ACTUAL_USER_MESSAGE_MARKER = "####### Actual user message below #######";
+function getErrorMessage(error) {
+    if (error && typeof error === 'object' && 'detail' in error) {
+        return String(error.detail);
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return 'Unknown error';
+}
+function normalizeWorkspaceRelativePath(rawPath) {
+    const normalized = path_1.default.posix.normalize(rawPath.split("\\").join("/").trim());
+    if (!normalized || normalized === "." || normalized.startsWith("../") || normalized === ".." || normalized.startsWith("/")) {
+        throw {
+            status: 400,
+            message: "file path must be a workspace-relative path"
+        };
+    }
+    return normalized;
+}
+function parseMessageParts(rawParts) {
+    if (!Array.isArray(rawParts)) {
+        throw {
+            status: 400,
+            message: "parts must be an array"
+        };
+    }
+    const parts = [];
+    for (const rawPart of rawParts) {
+        if (!rawPart || typeof rawPart !== "object") {
+            throw {
+                status: 400,
+                message: "Each part must be an object"
+            };
+        }
+        const part = rawPart;
+        if (part.type === "text") {
+            if (typeof part.text !== "string") {
+                throw {
+                    status: 400,
+                    message: "Text part requires a string text field"
+                };
+            }
+            parts.push({ type: "text", text: part.text });
+            continue;
+        }
+        if (part.type === "file") {
+            if (typeof part.path !== "string") {
+                throw {
+                    status: 400,
+                    message: "File part requires a string path field"
+                };
+            }
+            parts.push({ type: "file", path: normalizeWorkspaceRelativePath(part.path) });
+            continue;
+        }
+        throw {
+            status: 400,
+            message: `Unsupported part type: ${String(part.type)}`
+        };
+    }
+    return parts;
+}
+function buildOpencodePromptParts(parts) {
+    const workspaceDir = (0, opencode_client_1.getWorkspaceDir)();
+    return parts.map((part) => {
+        if (part.type === "text") {
+            return {
+                type: "text",
+                text: part.text
+            };
+        }
+        const normalizedPath = normalizeWorkspaceRelativePath(part.path);
+        const absolutePath = path_1.default.resolve(workspaceDir, normalizedPath);
+        const relativeCheck = path_1.default.relative(workspaceDir, absolutePath);
+        if (relativeCheck.startsWith("..") || path_1.default.isAbsolute(relativeCheck)) {
+            throw {
+                status: 400,
+                message: "file path must stay inside workspace"
+            };
+        }
+        const filename = normalizedPath.endsWith("/")
+            ? normalizedPath.slice(0, -1).split("/").pop() || normalizedPath
+            : normalizedPath.split("/").pop() || normalizedPath;
+        return {
+            type: "file",
+            mime: "text/plain",
+            filename,
+            url: (0, url_1.pathToFileURL)(absolutePath).href
+        };
+    });
+}
+async function readWorkspaceUserInstructions() {
+    const workspaceDir = (0, opencode_client_1.getWorkspaceDir)();
+    const userInstructionsPath = path_1.default.join(workspaceDir, USER_INSTRUCTIONS_FILENAME);
+    try {
+        const content = await promises_1.default.readFile(userInstructionsPath, "utf-8");
+        if (content.trim().length === 0) {
+            return null;
+        }
+        return content;
+    }
+    catch (err) {
+        const nodeError = err;
+        if (nodeError.code === "ENOENT") {
+            return null;
+        }
+        throw new Error(`Failed to read ${USER_INSTRUCTIONS_FILENAME}: ${nodeError.message}`);
+    }
+}
+function stripTextBeforeActualUserMarker(text) {
+    const markerIndex = text.indexOf(ACTUAL_USER_MESSAGE_MARKER);
+    if (markerIndex === -1) {
+        return text;
+    }
+    return text.slice(markerIndex + ACTUAL_USER_MESSAGE_MARKER.length).replace(/^\s+/, "");
+}
+function sanitizeFirstUserMessageForClient(messages) {
+    const firstUserMessageId = messages.find((message) => {
+        const info = message.info;
+        return info.role === "user";
+    })?.info.id;
+    if (!firstUserMessageId) {
+        return messages;
+    }
+    const firstUserMessage = messages.find((message) => message.info.id === firstUserMessageId);
+    if (!firstUserMessage) {
+        return messages;
+    }
+    const hasMarker = firstUserMessage.parts.some((part) => {
+        if (part.type !== "text") {
+            return false;
+        }
+        const textPart = part;
+        return typeof textPart.text === "string" && textPart.text.includes(ACTUAL_USER_MESSAGE_MARKER);
+    });
+    if (!hasMarker) {
+        return messages;
+    }
+    let markerFound = false;
+    return messages.map((message) => {
+        if (message.info.id !== firstUserMessageId) {
+            return message;
+        }
+        const parts = message.parts.map((part) => {
+            if (part.type !== "text") {
+                return part;
+            }
+            const textPart = part;
+            if (typeof textPart.text !== "string") {
+                return part;
+            }
+            if (markerFound) {
+                return part;
+            }
+            const markerIndex = textPart.text.indexOf(ACTUAL_USER_MESSAGE_MARKER);
+            if (markerIndex === -1) {
+                return {
+                    ...textPart,
+                    text: ""
+                };
+            }
+            markerFound = true;
+            return {
+                ...textPart,
+                text: stripTextBeforeActualUserMarker(textPart.text)
+            };
+        });
+        return {
+            info: message.info,
+            parts
+        };
+    });
+}
+function sanitizeEventForClient(event) {
+    if (event.type !== "message.part.updated") {
+        return event;
+    }
+    const properties = event.properties;
+    if (!properties || typeof properties !== "object") {
+        return event;
+    }
+    const part = properties.part;
+    if (!part || typeof part !== "object") {
+        return event;
+    }
+    const candidate = part;
+    if (candidate.type !== "text" || typeof candidate.text !== "string") {
+        return event;
+    }
+    return {
+        ...event,
+        properties: {
+            ...properties,
+            part: {
+                ...part,
+                text: stripTextBeforeActualUserMarker(candidate.text)
+            }
+        }
+    };
+}
+function shouldAutoGenerateTitle(title) {
+    if (!title)
+        return true;
+    const normalized = title.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    const genericPatterns = [
+        /^new chat$/,
+        /^new session(?:\s*-\s*.*)?$/,
+        /^session(?:\s*-\s*.*)?$/,
+        /^chat(?:\s*-\s*.*)?$/
+    ];
+    return genericPatterns.some((pattern) => pattern.test(normalized));
+}
+function getEventSessionId(event) {
+    const directSessionId = event.sessionID;
+    if (typeof directSessionId === "string" && directSessionId.length > 0) {
+        return directSessionId;
+    }
+    const properties = event.properties;
+    if (!properties || typeof properties !== "object") {
+        return null;
+    }
+    const propertyRecord = properties;
+    const candidates = [
+        propertyRecord.sessionID,
+        propertyRecord.info?.sessionID,
+        propertyRecord.part?.sessionID,
+        propertyRecord.permission?.sessionID,
+        propertyRecord.message?.sessionID,
+        propertyRecord.error?.sessionID
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.length > 0) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function generateTitleFromUserMessage(content) {
+    const maxChars = 60;
+    const maxWords = 9;
+    let text = content
+        .replace(/\s+/g, " ")
+        .replace(/[`*_#>\[\]()]/g, "")
+        .trim();
+    text = text.split(/[.!?\n]/)[0]?.trim() || text;
+    const leadingPhrases = [
+        "can you ",
+        "could you ",
+        "please ",
+        "help me ",
+        "i want to ",
+        "i need to ",
+        "let's ",
+        "lets "
+    ];
+    let lowered = text.toLowerCase();
+    for (const phrase of leadingPhrases) {
+        if (lowered.startsWith(phrase)) {
+            text = text.slice(phrase.length).trim();
+            lowered = text.toLowerCase();
+            break;
+        }
+    }
+    const words = text.split(/\s+/).filter(Boolean).slice(0, maxWords);
+    let candidate = words.join(" ").trim();
+    if (!candidate) {
+        return "New Chat";
+    }
+    if (candidate.length > maxChars) {
+        candidate = candidate.slice(0, maxChars).trim();
+        if (!/[.!?]$/.test(candidate)) {
+            candidate = `${candidate}...`;
+        }
+    }
+    return candidate;
+}
+// GET /api/chat/sessions - List user's sessions
+router.get('/sessions', (0, index_1.apiHandler)(async (req, res) => {
+    const sessions = await client_1.default.chat_sessions.findMany({
+        where: { user_id: req.userId },
+        orderBy: { updated_at: 'desc' }
+    });
+    if (sessions.length === 0) {
+        res.json({ sessions });
+        return;
+    }
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const opencodeSessionsResult = await client.session.list();
+    if (opencodeSessionsResult.error) {
+        throw new Error(getErrorMessage(opencodeSessionsResult.error) || 'Failed to list sessions from opencode');
+    }
+    const opencodeSessionIds = new Set((opencodeSessionsResult.data || []).map((session) => session.id));
+    const staleSessionIds = sessions
+        .filter((session) => !opencodeSessionIds.has(session.opencode_session_id))
+        .map((session) => session.id);
+    if (staleSessionIds.length > 0) {
+        await client_1.default.chat_sessions.deleteMany({
+            where: {
+                id: { in: staleSessionIds },
+                user_id: req.userId
+            }
+        });
+    }
+    const validSessions = sessions.filter((session) => opencodeSessionIds.has(session.opencode_session_id));
+    res.json({ sessions: validSessions });
+}, true));
+// GET /api/chat/file-suggestions - Search workspace files/folders for @mentions
+router.get('/file-suggestions', (0, index_1.apiHandler)(async (req, res) => {
+    const query = req.query.query;
+    if (typeof query !== "string") {
+        throw {
+            status: 400,
+            message: "query is required and must be a string"
+        };
+    }
+    const trimmedQuery = query.trim();
+    if (!trimmedQuery) {
+        res.json({ files: [] });
+        return;
+    }
+    const rawLimit = req.query.limit;
+    let limit = 10;
+    if (rawLimit !== undefined) {
+        const parsedLimit = Number.parseInt(String(rawLimit), 10);
+        if (!Number.isFinite(parsedLimit) || parsedLimit < 1 || parsedLimit > 50) {
+            throw {
+                status: 400,
+                message: "limit must be an integer between 1 and 50"
+            };
+        }
+        limit = parsedLimit;
+    }
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const result = await client.find.files({
+        query: {
+            query: trimmedQuery
+        }
+    });
+    if (result.error) {
+        throw new Error(getErrorMessage(result.error) || "Failed to fetch file suggestions from opencode");
+    }
+    res.json({ files: (result.data || []).slice(0, limit) });
+}, true));
+// POST /api/chat/sessions - Create new session
+router.post('/sessions', (0, index_1.apiHandler)(async (req, res) => {
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    // Create session in opencode
+    const result = await client.session.create();
+    if (result.error) {
+        throw new Error(getErrorMessage(result.error) || 'Failed to create opencode session');
+    }
+    const opencodeSession = result.data;
+    // Save session in our database
+    const session = await client_1.default.chat_sessions.create({
+        data: {
+            user_id: req.userId,
+            opencode_session_id: opencodeSession.id,
+            title: opencodeSession.title || 'New Chat',
+            created_at: Date.now(),
+            updated_at: Date.now()
+        }
+    });
+    res.json({
+        session: {
+            id: session.id,
+            opencode_session_id: session.opencode_session_id,
+            title: session.title,
+            created_at: session.created_at,
+            updated_at: session.updated_at
+        }
+    });
+}, true));
+// GET /api/chat/sessions/:id - Get session details
+router.get('/sessions/:id', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    // Get session details from opencode
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const result = await client.session.get({
+        path: { id: session.opencode_session_id }
+    });
+    if (result.error) {
+        throw new Error(getErrorMessage(result.error) || 'Failed to get session from opencode');
+    }
+    res.json({
+        session: {
+            id: session.id,
+            opencode_session_id: session.opencode_session_id,
+            title: session.title || result.data?.title,
+            created_at: session.created_at,
+            updated_at: session.updated_at,
+            opencode_data: result.data
+        }
+    });
+}, true));
+/*
+// DELETE /api/chat/sessions/:id - Delete session
+router.delete('/sessions/:id', apiHandler(async (req, res) => {
+    const id = req.params.id as string;
+
+    const session = await prisma.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId!
+        }
+    });
+
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+
+    // Delete session from opencode
+    const client = await getOpencodeClient();
+    await client.session.delete({
+        path: { id: session.opencode_session_id }
+    });
+
+    // Delete from our database
+    await prisma.chat_sessions.delete({
+        where: { id }
+    });
+
+    res.json({ success: true });
+}, true));
+*/
+// GET /api/chat/sessions/:id/messages - Get messages
+router.get('/sessions/:id/messages', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const result = await client.session.messages({
+        path: { id: session.opencode_session_id }
+    });
+    if (result.error) {
+        throw new Error(getErrorMessage(result.error) || 'Failed to get messages from opencode');
+    }
+    const statusResult = await client.session.status();
+    (0, assert_1.assertCondition)(!statusResult.error, getErrorMessage(statusResult.error));
+    const sessionStatusType = (0, chat_session_1.getSessionStatusTypeForSession)(statusResult.data, session.opencode_session_id);
+    const normalizedMessages = (0, chat_session_1.normalizeStaleRunningTools)(result.data, sessionStatusType);
+    const sanitizedMessages = sanitizeFirstUserMessageForClient(normalizedMessages);
+    res.json({
+        messages: sanitizedMessages,
+        session_status: sessionStatusType
+    });
+}, true));
+// POST /api/chat/sessions/:id/messages - Send message
+router.post('/sessions/:id/messages', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const rawParts = req.body?.parts;
+    if (rawParts === undefined) {
+        throw {
+            status: 400,
+            message: "parts is required"
+        };
+    }
+    const inputParts = parseMessageParts(rawParts);
+    if (inputParts.length === 0) {
+        throw {
+            status: 400,
+            message: "parts must contain at least one item"
+        };
+    }
+    if (!inputParts.some((part) => part.type === "text" && part.text.trim().length > 0)) {
+        throw {
+            status: 400,
+            message: "Message must include a non-empty text part"
+        };
+    }
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    const pendingQuestion = await (0, opencode_client_1.getPendingQuestionForSession)(session.opencode_session_id);
+    if (pendingQuestion) {
+        throw {
+            status: 409,
+            message: 'A tool is waiting for input. Reply through the tool-answer endpoint.'
+        };
+    }
+    const pendingPermission = await (0, opencode_client_1.listPendingPermissionsForSession)(session.opencode_session_id);
+    if (pendingPermission.length > 0) {
+        throw {
+            status: 409,
+            message: 'At least one permission request is waiting for input. Reply through the permission-response endpoint.'
+        };
+    }
+    const client = await (0, opencode_client_1.getOpencodeClient)();
+    const promptParts = buildOpencodePromptParts(inputParts);
+    let finalPromptParts = promptParts;
+    const existingMessagesResult = await client.session.messages({
+        path: { id: session.opencode_session_id },
+        query: { limit: 1 }
+    });
+    if (existingMessagesResult.error) {
+        throw new Error(getErrorMessage(existingMessagesResult.error) || "Failed to check session message history");
+    }
+    if ((existingMessagesResult.data || []).length === 0) {
+        const userInstructions = await readWorkspaceUserInstructions();
+        if (userInstructions) {
+            const wrappedUserInstructions = `# Custom user instructions (in case of conflicts, the instructions here take precedence over the contents of the AGENTS.md file)\n\n${userInstructions}\n\n${ACTUAL_USER_MESSAGE_MARKER}\n\n`;
+            finalPromptParts = [
+                {
+                    type: "text",
+                    text: wrappedUserInstructions
+                },
+                ...promptParts
+            ];
+        }
+    }
+    // Use promptAsync to send message and return immediately
+    const result = await client.session.promptAsync({
+        path: { id: session.opencode_session_id },
+        body: { parts: finalPromptParts }
+    });
+    if (result.error) {
+        throw new Error(getErrorMessage(result.error) || 'Failed to send message to opencode');
+    }
+    const data = {
+        updated_at: Date.now()
+    };
+    if (shouldAutoGenerateTitle(session.title)) {
+        const firstTextPart = inputParts.find((part) => part.type === "text" && part.text.trim().length > 0);
+        data.title = generateTitleFromUserMessage(firstTextPart?.text || "");
+    }
+    const updatedSession = await client_1.default.chat_sessions.update({
+        where: { id },
+        data
+    });
+    res.json({
+        success: true,
+        session: {
+            id: updatedSession.id,
+            title: updatedSession.title,
+            updated_at: updatedSession.updated_at
+        }
+    });
+}, true));
+// GET /api/chat/sessions/:id/pending-permission - Get pending permission for session
+router.get('/sessions/:id/pending-permission', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    const permissions = [];
+    // Include opencode native pending permissions
+    const opencodePendingPermissions = (await (0, opencode_client_1.listPendingPermissions)())
+        .filter((permission) => permission.sessionID === session.opencode_session_id)
+        .map((permission) => {
+        (0, assert_1.assertCondition)(typeof permission.tool?.messageID === 'string' && typeof permission.tool?.callID === 'string', `Pending opencode permission '${permission.id}' is missing tool.messageID/callID`);
+        return {
+            ...permission,
+            tool: {
+                messageID: permission.tool.messageID,
+                callID: permission.tool.callID
+            }
+        };
+    });
+    permissions.push(...opencodePendingPermissions);
+    // Include custom tool execution pending permissions
+    const customPendingPermissions = await client_1.default.tool_execution_permissions.findMany({
+        where: {
+            opencode_session_id: session.opencode_session_id,
+            status: 'pending'
+        },
+        orderBy: {
+            created_at: 'asc'
+        }
+    });
+    for (const customPendingPermission of customPendingPermissions) {
+        permissions.push({
+            id: customPendingPermission.id,
+            sessionID: customPendingPermission.opencode_session_id,
+            permission: 'tool',
+            patterns: [],
+            metadata: {},
+            always: [],
+            tool: {
+                messageID: customPendingPermission.message_id,
+                callID: customPendingPermission.call_id
+            }
+        });
+    }
+    res.json({ permissions });
+}, true));
+// POST /api/chat/sessions/:id/tool-answer - Reply to a pending tool question
+router.post('/sessions/:id/tool-answer', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const { content } = req.body;
+    if (!content || typeof content !== 'string') {
+        throw {
+            status: 400,
+            message: 'content is required and must be a string'
+        };
+    }
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    const pendingQuestion = await (0, opencode_client_1.getPendingQuestionForSession)(session.opencode_session_id);
+    if (!pendingQuestion) {
+        throw {
+            status: 409,
+            message: 'No pending tool question for this session'
+        };
+    }
+    // Current UI replies with a single string; map it to the first question.
+    const answers = pendingQuestion.questions.map((_, index) => index === 0 ? [content] : []);
+    await (0, opencode_client_1.replyToPendingQuestion)(pendingQuestion.id, answers);
+    await client_1.default.chat_sessions.update({
+        where: { id },
+        data: { updated_at: Date.now() }
+    });
+    res.json({ success: true });
+}, true));
+// POST /api/chat/sessions/:id/permission-response - Reply to a pending permission request
+router.post('/sessions/:id/permission-response', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const { response, permission_id } = req.body;
+    if (response !== 'once' && response !== 'always' && response !== 'reject') {
+        throw {
+            status: 400,
+            message: 'response is required and must be one of: once, always, reject'
+        };
+    }
+    if (typeof permission_id !== 'string') {
+        throw {
+            status: 400,
+            message: 'permission_id is required and must be a string'
+        };
+    }
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    // First check our custom tool execution permissions by explicit permission_id.
+    const customPendingPermission = await client_1.default.tool_execution_permissions.findFirst({
+        where: {
+            id: permission_id,
+            opencode_session_id: session.opencode_session_id,
+            status: 'pending'
+        }
+    });
+    if (customPendingPermission) {
+        // Update our custom permission status
+        await client_1.default.tool_execution_permissions.update({
+            where: { id: customPendingPermission.id },
+            data: {
+                status: response === 'reject' ? 'rejected' : 'approved',
+                responded_at: BigInt(Date.now())
+            }
+        });
+        await client_1.default.chat_sessions.update({
+            where: { id },
+            data: { updated_at: Date.now() }
+        });
+        res.json({ success: true });
+        return;
+    }
+    // Otherwise treat it as an opencode-native permission ID and reply directly.
+    await (0, opencode_client_1.replyToPendingPermission)(session.opencode_session_id, permission_id, response);
+    await client_1.default.chat_sessions.update({
+        where: { id },
+        data: { updated_at: Date.now() }
+    });
+    res.json({ success: true });
+}, true));
+// POST /api/chat/sessions/:id/abort - Abort AI response
+router.post('/sessions/:id/abort', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    await (0, session_abort_1.abortOpencodeSession)(session.opencode_session_id);
+    res.json({
+        success: true
+    });
+}, true));
+// GET /api/chat/sessions/:id/events - SSE stream for real-time updates
+router.get('/sessions/:id/events', (0, index_1.apiHandler)(async (req, res) => {
+    const id = req.params.id;
+    const session = await client_1.default.chat_sessions.findFirst({
+        where: {
+            id,
+            user_id: req.userId
+        }
+    });
+    if (!session) {
+        throw {
+            status: 404,
+            message: 'Session not found'
+        };
+    }
+    // Set up SSE headers
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders();
+    const port = (0, opencode_client_1.getOpencodePort)();
+    const workspaceDir = (0, opencode_client_1.getWorkspaceDir)();
+    // Create an abort controller for cleanup
+    const abortController = new AbortController();
+    // Handle client disconnect
+    req.on('close', () => {
+        abortController.abort();
+    });
+    try {
+        // Subscribe to opencode events using fetch with SSE
+        const response = await fetch(`http://localhost:${port}/event?directory=${encodeURIComponent(workspaceDir)}`, {
+            headers: {
+                'Accept': 'text/event-stream',
+            },
+            signal: abortController.signal
+        });
+        if (!response.ok || !response.body) {
+            res.write(`data: ${JSON.stringify({ type: 'error', message: 'Failed to connect to opencode events' })}\n\n`);
+            res.end();
+            return;
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffer += decoder.decode(value, { stream: true });
+            // Process complete SSE messages
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (line.startsWith('data:')) {
+                    const data = line.slice(5).trim();
+                    if (data) {
+                        try {
+                            const event = JSON.parse(data);
+                            const eventSessionId = getEventSessionId(event);
+                            // Filter events to only include ones for this session
+                            if (eventSessionId === session.opencode_session_id) {
+                                const sanitizedEvent = sanitizeEventForClient(event);
+                                res.write(`data: ${JSON.stringify((0, redact_1.sanitizeForClient)(sanitizedEvent))}\n\n`);
+                            }
+                        }
+                        catch {
+                            // Skip malformed JSON
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (err) {
+        if (err.name !== 'AbortError') {
+            res.write(`data: ${JSON.stringify({ type: 'error', message: 'SSE stream error' })}\n\n`);
+        }
+    }
+    res.end();
+}, true));
+exports.default = router;