dot-studio 0.0.1 → 0.0.2

package/dist/server/routes/act-runtime-tools.js

@@ -0,0 +1,157 @@
+import { Hono } from 'hono';
+import { parseActSessionOwnerId, resolveSessionExecutionContext } from '../lib/session-execution.js';
+import { getActDefinitionForThread, getActRuntimeService } from '../services/act-runtime/act-runtime-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const actRuntimeTools = new Hono();
+async function resolveActSessionTarget(sessionId) {
+    const context = await resolveSessionExecutionContext(sessionId);
+    if (!context || context.ownerKind !== 'act') {
+        return null;
+    }
+    const parsed = parseActSessionOwnerId(context.ownerId);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        workingDir: context.workingDir,
+        threadId: parsed.threadId,
+        participantKey: parsed.participantKey,
+    };
+}
+async function resolveParticipantKeyByName(workingDir, threadId, recipient) {
+    const actDefinition = await getActDefinitionForThread(workingDir, threadId);
+    if (!actDefinition) {
+        return recipient;
+    }
+    const normalizedRecipient = recipient.trim().toLowerCase();
+    for (const [participantKey, binding] of Object.entries(actDefinition.participants || {})) {
+        const displayName = (binding.displayName || participantKey).trim().toLowerCase();
+        if (displayName === normalizedRecipient || participantKey.toLowerCase() === normalizedRecipient) {
+            return participantKey;
+        }
+    }
+    return null;
+}
+// ── Debug logging middleware for Act tool routes ────
+actRuntimeTools.use('/api/act/*', async (c, next) => {
+    const url = c.req.url;
+    const method = c.req.method;
+    const workingDir = c.req.query('workingDir') || c.req.header('x-dot-working-dir') || 'NONE';
+    console.log(`[act-tool-req] ${method} ${url.replace(/\?.*/, '')} workingDir=${decodeURIComponent(workingDir).slice(-40)}`);
+    await next();
+});
+actRuntimeTools.post('/api/act/:actId/thread/:threadId/send-message', async (c) => {
+    const threadId = c.req.param('threadId');
+    const workingDir = requestWorkingDir(c);
+    console.log(`[act-tool] send-message: threadId=${threadId}, workingDir=${workingDir}`);
+    const body = await c.req.json();
+    const service = getActRuntimeService(workingDir);
+    const result = await service.sendMessage(threadId, body);
+    console.log(`[act-tool] send-message result: ok=${result.ok}${!result.ok ? `, error=${result.error}` : ''}`);
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.get('/api/act/session/:sessionId/read-shared-board', async (c) => {
+    const target = await resolveActSessionTarget(c.req.param('sessionId'));
+    if (!target) {
+        return c.json({ ok: false, error: 'Act session not found' }, 404);
+    }
+    const key = c.req.query('key');
+    const result = await getActRuntimeService(target.workingDir).readBoard(target.threadId, key);
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.post('/api/act/session/:sessionId/message-teammate', async (c) => {
+    const target = await resolveActSessionTarget(c.req.param('sessionId'));
+    if (!target) {
+        return c.json({ ok: false, error: 'Act session not found' }, 404);
+    }
+    const body = await c.req.json();
+    const recipientKey = await resolveParticipantKeyByName(target.workingDir, target.threadId, body.recipient);
+    if (!recipientKey) {
+        return c.json({ ok: false, error: `Unknown teammate "${body.recipient}"` }, 400);
+    }
+    const result = await getActRuntimeService(target.workingDir).sendMessage(target.threadId, {
+        from: target.participantKey,
+        to: recipientKey,
+        content: body.message,
+        tag: body.tag,
+    });
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.post('/api/act/:actId/thread/:threadId/post-to-board', async (c) => {
+    const threadId = c.req.param('threadId');
+    const workingDir = requestWorkingDir(c);
+    console.log(`[act-tool] post-to-board: threadId=${threadId}, workingDir=${workingDir}`);
+    const body = await c.req.json();
+    const result = await getActRuntimeService(workingDir).postToBoard(threadId, body);
+    console.log(`[act-tool] post-to-board result: ok=${result.ok}${!result.ok ? `, error=${result.error}` : ''}`);
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.post('/api/act/session/:sessionId/update-shared-board', async (c) => {
+    const target = await resolveActSessionTarget(c.req.param('sessionId'));
+    if (!target) {
+        return c.json({ ok: false, error: 'Act session not found' }, 404);
+    }
+    const body = await c.req.json();
+    const result = await getActRuntimeService(target.workingDir).postToBoard(target.threadId, {
+        author: target.participantKey,
+        key: body.entryKey,
+        kind: body.entryType,
+        content: body.content,
+        updateMode: body.mode,
+    });
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.get('/api/act/:actId/thread/:threadId/read-board', async (c) => {
+    const threadId = c.req.param('threadId');
+    const workingDir = requestWorkingDir(c);
+    console.log(`[act-tool] read-board: threadId=${threadId}, workingDir=${workingDir}`);
+    const key = c.req.query('key');
+    const result = await getActRuntimeService(workingDir).readBoard(threadId, key);
+    console.log(`[act-tool] read-board result: ok=${result.ok}${!result.ok ? `, error=${result.error}` : ''}`);
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.post('/api/act/:actId/thread/:threadId/set-wake-condition', async (c) => {
+    const threadId = c.req.param('threadId');
+    const body = await c.req.json();
+    const result = await getActRuntimeService(requestWorkingDir(c)).setWakeCondition(threadId, body);
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+actRuntimeTools.post('/api/act/session/:sessionId/wait-until', async (c) => {
+    const target = await resolveActSessionTarget(c.req.param('sessionId'));
+    if (!target) {
+        return c.json({ ok: false, error: 'Act session not found' }, 404);
+    }
+    const body = await c.req.json();
+    const result = await getActRuntimeService(target.workingDir).setWakeCondition(target.threadId, {
+        createdBy: target.participantKey,
+        target: 'self',
+        onSatisfiedMessage: body.resumeWith,
+        condition: body.condition,
+    });
+    if (!result.ok) {
+        return c.json(result, result.status);
+    }
+    return c.json(result);
+});
+export default actRuntimeTools;

package/dist/server/routes/act-runtime.js

@@ -0,0 +1,7 @@
+import { Hono } from 'hono';
+import actRuntimeTools from './act-runtime-tools.js';
+import actRuntimeThreads from './act-runtime-threads.js';
+const actRuntime = new Hono();
+actRuntime.route('/', actRuntimeTools);
+actRuntime.route('/', actRuntimeThreads);
+export default actRuntime;

package/dist/server/routes/adapter.js

@@ -0,0 +1,32 @@
+import { Hono } from 'hono';
+import { dispatchAdapterViewAction, listAdapterViewProjections } from '../services/adapter-view-service.js';
+import { createSSEResponse } from '../lib/sse.js';
+const adapter = new Hono();
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Adapter action is not available yet.';
+}
+adapter.get('/api/adapter/views', async (c) => {
+    const performerId = c.req.query('performerId')?.trim();
+    const projections = await listAdapterViewProjections(performerId || undefined);
+    return c.json({ projections });
+});
+adapter.post('/api/adapter/action', async (c) => {
+    try {
+        const body = await c.req.json();
+        const result = await dispatchAdapterViewAction(body);
+        return c.json(result);
+    }
+    catch (error) {
+        return c.json({ error: errorMessage(error) }, 501);
+    }
+});
+adapter.get('/api/adapter/events', async () => {
+    const stream = new ReadableStream({
+        start(controller) {
+            const encoder = new TextEncoder();
+            controller.enqueue(encoder.encode(': adapter stream placeholder\n\n'));
+        },
+    });
+    return createSSEResponse(stream);
+});
+export default adapter;

package/dist/server/routes/assets-collection.js

@@ -0,0 +1,16 @@
+import { Hono } from 'hono';
+import { cached, TTL } from '../lib/cache.js';
+import { listStudioAssets } from '../services/asset-service.js';
+import { jsonError, requestWorkingDir } from './route-errors.js';
+const assetsCollection = new Hono();
+assetsCollection.get('/api/assets/:kind', async (c) => {
+    const kind = c.req.param('kind');
+    if (!['tal', 'dance', 'performer', 'act'].includes(kind)) {
+        return jsonError(c, `Invalid kind: ${kind}`, 400);
+    }
+    const cwd = requestWorkingDir(c);
+    const assetKind = kind;
+    const assetList = await cached(`assets-${assetKind}-${cwd}`, TTL.ASSETS, () => listStudioAssets(cwd, assetKind));
+    return c.json(assetList);
+});
+export default assetsCollection;

package/dist/server/routes/assets-detail.js

@@ -0,0 +1,38 @@
+import { Hono } from 'hono';
+import { cached, TTL } from '../lib/cache.js';
+import { getRegistryAssetDetail, getStudioAsset } from '../services/asset-service.js';
+import { jsonError, requestWorkingDir } from './route-errors.js';
+const assetsDetail = new Hono();
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+function assetPathFromRequest(c) {
+    return c.req.query('path') || c.req.param('name') || '';
+}
+async function handleStudioAssetDetail(c) {
+    const { kind, author } = c.req.param();
+    const assetPath = assetPathFromRequest(c);
+    try {
+        return c.json(await getStudioAsset(requestWorkingDir(c), kind, author, assetPath));
+    }
+    catch (error) {
+        return jsonError(c, errorMessage(error), 404);
+    }
+}
+async function handleRegistryAssetDetail(c) {
+    const { kind, author } = c.req.param();
+    const assetPath = assetPathFromRequest(c);
+    const cwd = requestWorkingDir(c);
+    try {
+        const detail = await cached(`registry-asset-${cwd}-${kind}-${author}-${assetPath}`, TTL.PROVIDERS, () => getRegistryAssetDetail(cwd, kind, author, assetPath));
+        return c.json(detail);
+    }
+    catch (error) {
+        return jsonError(c, errorMessage(error), 404);
+    }
+}
+assetsDetail.get('/api/assets/:kind/:author', handleStudioAssetDetail);
+assetsDetail.get('/api/assets/:kind/:author/:name', handleStudioAssetDetail);
+assetsDetail.get('/api/assets/registry/:kind/:author', handleRegistryAssetDetail);
+assetsDetail.get('/api/assets/registry/:kind/:author/:name', handleRegistryAssetDetail);
+export default assetsDetail;

package/dist/server/routes/assets.js

@@ -1,161 +1,7 @@
-// Asset Routes — using DOT lib directly
 import { Hono } from 'hono';
-import fs from 'fs/promises';
-import path from 'path';
-import { assetFilePath, getDotDir, getGlobalCwd, getGlobalDotDir, readAsset } from 'dance-of-tal/lib/registry';
-import { getRegistryPackage } from 'dance-of-tal/lib/installer';
-import { cached, TTL } from '../lib/cache.js';
-import { resolveRequestWorkingDir } from '../lib/request-context.js';
+import assetsCollection from './assets-collection.js';
+import assetsDetail from './assets-detail.js';
 const assets = new Hono();
-// ── Asset Scanning ──────────────────────────────────────
-// Scans both local (.dance-of-tal/) and global (~/.dance-of-tal/) dirs
-// Each asset is tagged with source: 'global' | 'stage'
-// Stage assets override global for the same URN
-function normalizeAsset(kind, urn, author, source, content, detail = false) {
-    const slug = urn.split('/')[2];
-    const normalizedAuthor = author.startsWith('@') ? author : `@${author}`;
-    const base = {
-        kind,
-        urn,
-        slug,
-        name: typeof content.name === 'string' && content.name.trim() ? content.name.trim() : slug,
-        author: normalizedAuthor,
-        source,
-        description: typeof content.description === 'string' ? content.description : '',
-    };
-    if (kind === 'performer') {
-        const danceRaw = content.dance;
-        const danceUrns = Array.isArray(danceRaw)
-            ? danceRaw.filter((value) => typeof value === 'string')
-            : typeof danceRaw === 'string'
-                ? [danceRaw]
-                : [];
-        return {
-            ...base,
-            talUrn: typeof content.tal === 'string' ? content.tal : null,
-            danceUrns,
-            actUrn: typeof content.act === 'string' ? content.act : null,
-            model: typeof content.model === 'string' ? content.model : null,
-            mcpConfig: typeof content.mcp_config === 'object' && content.mcp_config !== null ? content.mcp_config : null,
-            tags: Array.isArray(content.tags) ? content.tags : [],
-        };
-    }
-    if (kind === 'act') {
-        return {
-            ...base,
-            entryNode: typeof content.entryNode === 'string' ? content.entryNode : null,
-            nodeCount: typeof content.nodes === 'object' && content.nodes ? Object.keys(content.nodes).length : 0,
-            tags: Array.isArray(content.tags) ? content.tags : [],
-            ...(detail ? {
-                nodes: typeof content.nodes === 'object' && content.nodes ? content.nodes : {},
-                edges: Array.isArray(content.edges) ? content.edges : [],
-                maxIterations: typeof content.maxIterations === 'number' ? content.maxIterations : undefined,
-            } : {}),
-        };
-    }
-    return {
-        ...base,
-        tags: Array.isArray(content.tags) ? content.tags : [],
-        ...(detail && typeof content.content === 'string' ? { content: content.content } : {}),
-    };
-}
-async function fetchRegistryAsset(kind, author, name) {
-    const pkg = await getRegistryPackage(kind, author, name);
-    const urn = typeof pkg.urn === 'string' && pkg.urn ? pkg.urn : `${kind}/@${author.replace(/^@/, '')}/${name}`;
-    const normalized = normalizeAsset(kind, urn, `@${author.replace(/^@/, '')}`, 'registry', pkg.payload, true);
-    return {
-        ...normalized,
-        stars: typeof pkg.stars === 'number' ? pkg.stars : 0,
-        tier: typeof pkg.tier === 'string' ? pkg.tier : undefined,
-        updatedAt: typeof pkg.updatedAt === 'string' ? pkg.updatedAt : undefined,
-    };
-}
-async function scanAssetDir(baseDir, kind, source, resultsMap) {
-    const kindDir = path.join(baseDir, kind);
-    try {
-        const authors = await fs.readdir(kindDir);
-        for (const author of authors) {
-            if (!author.startsWith('@'))
-                continue;
-            const authorDir = path.join(kindDir, author);
-            const stat = await fs.stat(authorDir);
-            if (!stat.isDirectory())
-                continue;
-            const files = await fs.readdir(authorDir);
-            for (const file of files) {
-                if (!file.endsWith('.json'))
-                    continue;
-                try {
-                    const content = JSON.parse(await fs.readFile(path.join(authorDir, file), 'utf-8'));
-                    const name = file.replace(/\.json$/, '');
-                    const urn = `${kind}/${author}/${name}`;
-                    resultsMap.set(urn, normalizeAsset(kind, urn, author, source, content, false));
-                }
-                catch { /* skip invalid files */ }
-            }
-        }
-    }
-    catch { /* directory doesn't exist */ }
-}
-async function listAssets(cwd, kind) {
-    const resultsMap = new Map();
-    const globalDir = getGlobalDotDir();
-    const localDir = getDotDir(cwd);
-    // 1. Scan Global Directory (Base)
-    await scanAssetDir(globalDir, kind, 'global', resultsMap);
-    // 2. Scan Stage Directory (Overrides)
-    await scanAssetDir(localDir, kind, 'stage', resultsMap);
-    return Array.from(resultsMap.values());
-}
-async function resolveAssetSource(cwd, urn) {
-    try {
-        await fs.access(assetFilePath(cwd, urn));
-        return 'stage';
-    }
-    catch {
-        try {
-            await fs.access(assetFilePath(getGlobalCwd(), urn));
-            return 'global';
-        }
-        catch {
-            return 'stage';
-        }
-    }
-}
-// ── Routes ──────────────────────────────────────────────
-assets.get('/api/assets/:kind', async (c) => {
-    const kind = c.req.param('kind');
-    if (!['tal', 'dance', 'performer', 'act'].includes(kind)) {
-        return c.json({ error: `Invalid kind: ${kind}` }, 400);
-    }
-    const cwd = resolveRequestWorkingDir(c);
-    const assetList = await cached(`assets-${kind}-${cwd}`, TTL.ASSETS, () => listAssets(cwd, kind));
-    return c.json(assetList);
-});
-assets.get('/api/assets/:kind/:author/:name', async (c) => {
-    const { kind, author, name } = c.req.param();
-    const urn = `${kind}/@${author}/${name}`;
-    try {
-        const cwd = resolveRequestWorkingDir(c);
-        const asset = await readAsset(cwd, urn);
-        if (!asset) {
-            return c.json({ error: `Asset not found: ${urn}` }, 404);
-        }
-        const source = await resolveAssetSource(cwd, urn);
-        return c.json(normalizeAsset(kind, urn, `@${author}`, source, asset, true));
-    }
-    catch (err) {
-        return c.json({ error: err.message }, 404);
-    }
-});
-assets.get('/api/assets/registry/:kind/:author/:name', async (c) => {
-    const { kind, author, name } = c.req.param();
-    try {
-        const detail = await cached(`registry-asset-${kind}-${author}-${name}`, TTL.PROVIDERS, () => fetchRegistryAsset(kind, author, name));
-        return c.json(detail);
-    }
-    catch (err) {
-        return c.json({ error: err.message }, 404);
-    }
-});
+assets.route('/', assetsCollection);
+assets.route('/', assetsDetail);
 export default assets;

package/dist/server/routes/chat-messages.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { uniqueAssetRefs } from '../lib/chat-session.js';
+import { resolveSessionExecutionContext } from '../lib/session-execution.js';
+import { StudioValidationError, jsonOpencodeError, } from '../lib/opencode-errors.js';
+import { sendStudioChatMessage } from '../services/chat-service.js';
+import { listStudioSessionDiff, listStudioSessionMessages, rejectQuestion, respondQuestion, } from '../services/chat-session-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const chatMessages = new Hono();
+function parseMessagesQuery(c) {
+    const rawLimit = c.req.query('limit');
+    const rawBefore = c.req.query('before');
+    let limit;
+    if (typeof rawLimit === 'string' && rawLimit.trim().length > 0) {
+        const parsed = Number.parseInt(rawLimit, 10);
+        if (!Number.isFinite(parsed) || parsed <= 0) {
+            throw new StudioValidationError('Query "limit" must be a positive integer.', 'fix_input');
+        }
+        limit = parsed;
+    }
+    const before = typeof rawBefore === 'string' && rawBefore.trim().length > 0
+        ? rawBefore.trim()
+        : undefined;
+    return {
+        limit,
+        before,
+    };
+}
+chatMessages.post('/api/chat/sessions/:id/send', async (c) => {
+    const body = await c.req.json();
+    if (!body.performer?.model) {
+        return jsonOpencodeError(c, new StudioValidationError('Select a model for this performer before sending prompts.', 'select_model'));
+    }
+    try {
+        const workingDir = requestWorkingDir(c);
+        const executionDir = (await resolveSessionExecutionContext(c.req.param('id')))?.executionDir || workingDir;
+        const normalizedBody = {
+            ...body,
+            performer: {
+                ...body.performer,
+                danceRefs: uniqueAssetRefs(body.performer?.danceRefs || []),
+                extraDanceRefs: uniqueAssetRefs(body.performer?.extraDanceRefs || []),
+            },
+        };
+        const result = await sendStudioChatMessage(executionDir, workingDir, c.req.param('id'), normalizedBody);
+        return c.json(result, 202);
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { model: body.performer?.model });
+    }
+});
+chatMessages.post('/api/chat/questions/:qid/respond', async (c) => {
+    const { answers } = await c.req.json();
+    try {
+        return c.json(await respondQuestion(c.req.param('qid'), answers));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatMessages.post('/api/chat/questions/:qid/reject', async (c) => {
+    try {
+        return c.json(await rejectQuestion(c.req.param('qid')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatMessages.get('/api/chat/sessions/:id/messages', async (c) => {
+    try {
+        const query = parseMessagesQuery(c);
+        const result = await listStudioSessionMessages(requestWorkingDir(c), c.req.param('id'), query);
+        c.header('x-next-cursor', result.nextCursor || '');
+        return c.json(result.messages);
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatMessages.get('/api/chat/sessions/:id/diff', async (c) => {
+    try {
+        return c.json(await listStudioSessionDiff(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+/**
+ * Resolve a session ID to its owner info (chatKey / performerId).
+ * Used by the frontend to lazily register sessions created externally
+ * (e.g., by wake cascade) into the sessionMap.
+ */
+chatMessages.get('/api/chat/sessions/:id/resolve', async (c) => {
+    const context = await resolveSessionExecutionContext(c.req.param('id'));
+    if (!context) {
+        return c.json({ found: false }, 404);
+    }
+    return c.json({
+        found: true,
+        sessionId: context.sessionId,
+        ownerId: context.ownerId,
+        ownerKind: context.ownerKind,
+    });
+});
+export default chatMessages;

package/dist/server/routes/chat-sessions.js

@@ -0,0 +1,104 @@
+import { Hono } from 'hono';
+import { StudioValidationError, jsonOpencodeError, } from '../lib/opencode-errors.js';
+import { createStudioChatSession } from '../services/chat-service.js';
+import { abortStudioChatSession, deleteStudioChatSession, listStudioChatSessions, renameStudioChatSession, respondSessionPermission, revertStudioChatSession, shareStudioChatSession, summarizeStudioChatSession, unrevertStudioChatSession, listPendingPermissions, } from '../services/chat-session-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const chatSessions = new Hono();
+chatSessions.post('/api/chat/sessions', async (c) => {
+    const body = await c.req.json();
+    try {
+        return c.json(await createStudioChatSession(requestWorkingDir(c), body));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.get('/api/chat/sessions', async (c) => {
+    try {
+        return c.json(await listStudioChatSessions(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.delete('/api/chat/sessions/:id', async (c) => {
+    try {
+        return c.json(await deleteStudioChatSession(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.put('/api/chat/sessions/:id', async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const title = body.title;
+    if (!title || !title.trim()) {
+        return jsonOpencodeError(c, new StudioValidationError('Thread title is required.', 'fix_input'));
+    }
+    try {
+        return c.json(await renameStudioChatSession(requestWorkingDir(c), c.req.param('id'), title.trim()));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/abort', async (c) => {
+    try {
+        return c.json(await abortStudioChatSession(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/permission/:pid/respond', async (c) => {
+    const { response } = await c.req.json();
+    try {
+        return c.json(await respondSessionPermission(requestWorkingDir(c), c.req.param('id'), c.req.param('pid'), response));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/share', async (c) => {
+    try {
+        return c.json(await shareStudioChatSession(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/summarize', async (c) => {
+    const { providerID, modelID, auto } = await c.req.json();
+    try {
+        return c.json(await summarizeStudioChatSession(requestWorkingDir(c), c.req.param('id'), { providerID, modelID, auto }));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/revert', async (c) => {
+    const { messageId, partId } = await c.req.json();
+    try {
+        return c.json(await revertStudioChatSession(requestWorkingDir(c), c.req.param('id'), { messageId, partId }));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.post('/api/chat/sessions/:id/unrevert', async (c) => {
+    try {
+        return c.json(await unrevertStudioChatSession(requestWorkingDir(c), c.req.param('id')));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+chatSessions.get('/api/chat/permissions', async (c) => {
+    try {
+        return c.json(await listPendingPermissions(requestWorkingDir(c)));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err);
+    }
+});
+export default chatSessions;

package/dist/server/routes/chat-stream.js

@@ -0,0 +1,15 @@
+import { Hono } from 'hono';
+import { jsonOpencodeError } from '../lib/opencode-errors.js';
+import { createSSEResponse } from '../lib/sse.js';
+import { buildStudioChatEventStream } from '../services/chat-event-stream-service.js';
+import { requestWorkingDir } from './route-errors.js';
+const chatStream = new Hono();
+chatStream.get('/api/chat/events', async (c) => {
+    try {
+        return createSSEResponse(await buildStudioChatEventStream(requestWorkingDir(c), c.req.raw.signal));
+    }
+    catch (err) {
+        return jsonOpencodeError(c, err, { defaultStatus: 503 });
+    }
+});
+export default chatStream;