dot-studio 0.0.1 → 0.0.3

package/dist/server/services/chat-event-stream-service.js

@@ -0,0 +1,157 @@
+import { getOpencode } from '../lib/opencode.js';
+import { listSessionExecutionContextsForWorkingDir, resolveSessionExecutionContext, } from '../lib/session-execution.js';
+import { sseEncode } from '../lib/sse.js';
+const HEARTBEAT_INTERVAL_MS = 30_000;
+const EXECUTION_DIRECTORY_REFRESH_MS = 1_000;
+async function listEventDirectories(workingDir) {
+    const performerContexts = await listSessionExecutionContextsForWorkingDir(workingDir, 'performer');
+    const actContexts = await listSessionExecutionContextsForWorkingDir(workingDir, 'act');
+    return Array.from(new Set([
+        workingDir,
+        ...performerContexts.map((context) => context.executionDir),
+        ...actContexts.map((context) => context.executionDir),
+    ]));
+}
+export async function buildStudioChatEventStream(workingDir, abortSignal) {
+    const oc = await getOpencode();
+    return new ReadableStream({
+        async start(controller) {
+            let active = true;
+            const subscribedDirectories = new Set();
+            const connectingDirectories = new Set();
+            let heartbeatTimer = null;
+            let refreshTimer = null;
+            const close = () => {
+                if (!active) {
+                    return;
+                }
+                active = false;
+                if (heartbeatTimer) {
+                    clearInterval(heartbeatTimer);
+                    heartbeatTimer = null;
+                }
+                if (refreshTimer) {
+                    clearInterval(refreshTimer);
+                    refreshTimer = null;
+                }
+                subscribedDirectories.clear();
+                connectingDirectories.clear();
+                abortSignal?.removeEventListener('abort', close);
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Stream may already be closed.
+                }
+            };
+            const enqueueEvent = (event) => {
+                if (!active) {
+                    return;
+                }
+                try {
+                    controller.enqueue(sseEncode(JSON.stringify(event)));
+                }
+                catch {
+                    close();
+                }
+            };
+            const subscribeDirectory = async (directory) => {
+                if (!active || subscribedDirectories.has(directory) || connectingDirectories.has(directory)) {
+                    return;
+                }
+                connectingDirectories.add(directory);
+                try {
+                    const subscription = abortSignal
+                        ? await oc.event.subscribe({ directory }, { signal: abortSignal })
+                        : await oc.event.subscribe({ directory });
+                    if (!active) {
+                        return;
+                    }
+                    connectingDirectories.delete(directory);
+                    subscribedDirectories.add(directory);
+                    void (async () => {
+                        try {
+                            for await (const event of subscription.stream) {
+                                if (!active) {
+                                    return;
+                                }
+                                if (event.type === 'permission.asked') {
+                                    const sessionID = typeof event.properties?.sessionID === 'string'
+                                        ? event.properties.sessionID
+                                        : null;
+                                    const permissionID = typeof event.properties?.id === 'string'
+                                        ? event.properties.id
+                                        : null;
+                                    if (sessionID && permissionID) {
+                                        const context = await resolveSessionExecutionContext(sessionID);
+                                        if (context?.ownerKind === 'act') {
+                                            try {
+                                                await oc.permission.respond({
+                                                    sessionID,
+                                                    permissionID,
+                                                    response: 'always',
+                                                    directory: context.executionDir,
+                                                });
+                                            }
+                                            catch (error) {
+                                                console.error('Failed to auto-accept permission for Act session:', error);
+                                            }
+                                            continue;
+                                        }
+                                    }
+                                }
+                                if (event.type?.startsWith('message.') || event.type?.startsWith('session.') || event.type === 'permission.asked' || event.type === 'permission.replied' || event.type === 'question.asked' || event.type === 'question.replied' || event.type === 'question.rejected' || event.type === 'todo.updated') {
+                                    const rawProps = event.properties;
+                                    const sessionID = rawProps?.sessionID || rawProps?.info?.sessionID || rawProps?.part?.sessionID;
+                                    if (sessionID) {
+                                        const context = await resolveSessionExecutionContext(sessionID);
+                                        if (context) {
+                                            enqueueEvent({
+                                                ...event,
+                                                properties: {
+                                                    ...(event.properties || {}),
+                                                    ownerId: context.ownerId,
+                                                    ownerKind: context.ownerKind,
+                                                },
+                                            });
+                                            continue;
+                                        }
+                                    }
+                                }
+                                enqueueEvent(event);
+                            }
+                        }
+                        catch {
+                            // Ignore broken subscription and keep stream alive.
+                        }
+                        finally {
+                            subscribedDirectories.delete(directory);
+                            connectingDirectories.delete(directory);
+                            if (active) {
+                                void subscribeDirectory(directory);
+                            }
+                        }
+                    })();
+                }
+                catch {
+                    connectingDirectories.delete(directory);
+                }
+            };
+            const refreshSubscriptions = async () => {
+                if (!active) {
+                    return;
+                }
+                const directories = await listEventDirectories(workingDir);
+                await Promise.all(directories.map((directory) => subscribeDirectory(directory)));
+            };
+            abortSignal?.addEventListener('abort', close, { once: true });
+            heartbeatTimer = setInterval(() => {
+                enqueueEvent({ type: 'server.heartbeat' });
+            }, HEARTBEAT_INTERVAL_MS);
+            refreshTimer = setInterval(() => {
+                void refreshSubscriptions();
+            }, EXECUTION_DIRECTORY_REFRESH_MS);
+            await refreshSubscriptions();
+        },
+    });
+}

package/dist/server/services/chat-service.js

@@ -0,0 +1,207 @@
+import { getOpencode } from '../lib/opencode.js';
+import { buildStudioSessionTitle } from '../../shared/session-metadata.js';
+import { extractNonRetryableSessionError, waitForSessionToSettle } from '../lib/chat-session.js';
+import { describeUnavailableRuntimeTools } from '../lib/runtime-tools.js';
+import { StudioValidationError, unwrapOpencodeResult } from '../lib/opencode-errors.js';
+import { getSafeOwnerExecutionDir } from '../lib/safe-mode.js';
+import { registerSessionExecutionContext } from '../lib/session-execution.js';
+import { resolveActSessionPolicy, ACT_AGENT_POSTURE } from '../lib/act-session-policy.js';
+import { ensurePerformerProjection } from './opencode-projection/stage-projection-service.js';
+import { projectActTools } from './act-runtime/act-tool-projection.js';
+import { getActDefinitionForThread, getActRuntimeService } from './act-runtime/act-runtime-service.js';
+export async function createStudioChatSession(cwd, request) {
+    const oc = await getOpencode();
+    const isAct = !!request.actId;
+    const actPolicy = isAct ? resolveActSessionPolicy(request.actId) : null;
+    const ownerKind = isAct ? actPolicy.ownerKind : 'performer';
+    // Use the full chatKey as both safe owner and session context owner so each
+    // Act participant session resolves back to the correct tab and execution scope.
+    const safeOwnerId = request.performerId;
+    const contextOwnerId = request.performerId;
+    // Act sessions are always direct — never inherit executionMode from request
+    const effectiveMode = isAct ? actPolicy.executionMode : (request.executionMode || 'direct');
+    const executionDir = await getSafeOwnerExecutionDir(cwd, ownerKind, safeOwnerId, effectiveMode);
+    const session = unwrapOpencodeResult(await oc.session.create({
+        directory: executionDir,
+        title: buildStudioSessionTitle(request.performerId, request.performerName, request.configHash, effectiveMode),
+    }));
+    await registerSessionExecutionContext({
+        sessionId: session.id,
+        ownerKind,
+        ownerId: contextOwnerId,
+        mode: effectiveMode,
+        workingDir: cwd,
+        executionDir,
+    });
+    // Persist participant→session mapping to thread.json for Act participants
+    // ChatKey format: `act:{actId}:thread:{threadId}:participant:{participantKey}`
+    if (request.actId && request.performerId.startsWith('act:')) {
+        const threadMatch = request.performerId.match(/^act:[^:]+:thread:([^:]+):participant:(.+)$/);
+        if (threadMatch) {
+            const [, threadId, participantKey] = threadMatch;
+            try {
+                const { getActRuntimeService } = await import('./act-runtime/act-runtime-service.js');
+                const service = getActRuntimeService(cwd);
+                await service.registerParticipantSession(threadId, participantKey, session.id);
+            }
+            catch {
+                // Non-fatal: session still works, just won't persist for reload
+            }
+        }
+    }
+    return {
+        sessionId: session.id,
+        title: session.title,
+    };
+}
+export async function sendStudioChatMessage(executionDir, workingDir, sessionId, request) {
+    const performer = request.performer;
+    if (!performer?.model) {
+        throw new StudioValidationError('Select a model for this performer before sending prompts.', 'select_model');
+    }
+    // Extract raw performer key for Act-namespaced chatKeys
+    // ChatKey format: `act:{actId}:thread:{threadId}:participant:{participantKey}`
+    // We need just the participantKey part for Act tool generation
+    let rawPerformerId = performer.performerId;
+    if (request.actId && performer.performerId.startsWith('act:')) {
+        const participantPrefix = ':participant:';
+        const participantIdx = performer.performerId.indexOf(participantPrefix);
+        if (participantIdx !== -1) {
+            rawPerformerId = performer.performerId.slice(participantIdx + participantPrefix.length);
+        }
+    }
+    // ── Collaboration tool projection ───────────────────
+    // When running in an Act thread, project stable collaboration context and
+    // collaboration tools into the participant session.
+    let actExtraTools = [];
+    let collaborationPromptSection = '';
+    if (request.actId && request.actThreadId) {
+        try {
+            const actDef = await getActDefinitionForThread(workingDir, request.actThreadId);
+            if (actDef) {
+                const projection = projectActTools(rawPerformerId, actDef, request.actThreadId, workingDir);
+                actExtraTools = projection.tools;
+                collaborationPromptSection = projection.contextPrompt;
+            }
+        }
+        catch (err) {
+            console.warn('[chat-service] Act tool projection failed:', err);
+        }
+    }
+    const isAssistant = rawPerformerId === 'studio-assistant';
+    let ensured = null;
+    let assistantContextPrefix = '';
+    let assistantAgentName = null;
+    let capabilitySnapshot = null;
+    let toolResolution = {
+        selectedMcpServers: [],
+        requestedTools: [],
+        availableTools: [],
+        resolvedTools: [],
+        unavailableTools: [],
+        unavailableDetails: [],
+    };
+    if (isAssistant) {
+        const { buildAssistantActionPrompt, ensureAssistantAgent } = await import('./studio-assistant/assistant-service.js');
+        assistantAgentName = await ensureAssistantAgent(executionDir);
+        assistantContextPrefix = buildAssistantActionPrompt(request.assistantContext || null);
+    }
+    else {
+        ensured = await ensurePerformerProjection({
+            performerId: rawPerformerId,
+            performerName: performer.performerName,
+            talRef: performer.talRef,
+            danceRefs: [...(performer.danceRefs || []), ...(performer.extraDanceRefs || [])],
+            model: performer.model,
+            modelVariant: performer.modelVariant || null,
+            mcpServerNames: performer.mcpServerNames || [],
+            executionDir,
+            workingDir,
+            ...(request.actId ? { scope: 'act', actId: request.actId } : {}),
+            ...(collaborationPromptSection ? { collaborationPromptSection } : {}),
+            // Pass Act runtime tools as extraTools so they're included in projection
+            ...(actExtraTools.length > 0 ? { extraTools: actExtraTools } : {}),
+        });
+        capabilitySnapshot = ensured.capabilitySnapshot;
+        toolResolution = ensured.toolResolution;
+    }
+    const unavailableSummary = describeUnavailableRuntimeTools(toolResolution);
+    if (toolResolution.selectedMcpServers.length > 0 && toolResolution.resolvedTools.length === 0 && unavailableSummary) {
+        throw new StudioValidationError(`Selected MCP servers are unavailable: ${unavailableSummary}.`, 'fix_input');
+    }
+    const promptSections = [assistantContextPrefix, request.message].filter(Boolean);
+    const parts = [{ type: 'text', text: promptSections.join('\n\n---\n\n') }];
+    if (request.attachments && request.attachments.length > 0) {
+        if (capabilitySnapshot && !capabilitySnapshot.attachment) {
+            throw new StudioValidationError('Selected model does not support attachments. Remove the files or choose a model that supports them.', 'choose_model');
+        }
+        for (const attachment of request.attachments) {
+            parts.push({
+                type: 'file',
+                mime: attachment.mime,
+                url: attachment.url,
+                filename: attachment.filename,
+            });
+        }
+    }
+    const oc = await getOpencode();
+    const actRuntime = request.actId && request.actThreadId
+        ? getActRuntimeService(workingDir)
+        : null;
+    if (actRuntime && rawPerformerId) {
+        await actRuntime.beginUserTurn(request.actThreadId);
+        await actRuntime.markParticipantSessionBusy(request.actThreadId, rawPerformerId);
+    }
+    try {
+        unwrapOpencodeResult(await oc.session.promptAsync({
+            sessionID: sessionId,
+            directory: executionDir,
+            agent: isAssistant
+                ? (assistantAgentName || undefined)
+                // Act scope always uses build agent, ignoring performer planMode
+                : (ensured?.compiled.agentNames[request.actId ? ACT_AGENT_POSTURE : (performer.planMode ? 'plan' : 'build')]),
+            // Pass model directly so OpenCode uses the user's selected model,
+            // not the (potentially stale) model cached from the agent file.
+            model: performer.model ? {
+                providerID: performer.model.provider,
+                modelID: performer.model.modelId,
+            } : undefined,
+            parts,
+        }));
+    }
+    catch (error) {
+        if (actRuntime && rawPerformerId) {
+            await actRuntime.drainParticipantQueue(request.actThreadId, rawPerformerId).catch(() => { });
+        }
+        throw error;
+    }
+    if (actRuntime && rawPerformerId) {
+        void waitForSessionToSettle(oc, sessionId, { directory: executionDir }, { timeoutMs: 30 * 60_000, pollMs: 250, requireObservedBusy: true }).then((settled) => {
+            if (!settled) {
+                void actRuntime.clearParticipantSessionBusy(request.actThreadId, rawPerformerId);
+                console.warn(`[chat-service] Session ${sessionId} for "${rawPerformerId}" did not settle before timeout`);
+                return;
+            }
+            return Promise.resolve(oc.session.messages({
+                sessionID: sessionId,
+                directory: executionDir,
+            })).then((response) => {
+                const rawMessages = unwrapOpencodeResult(response);
+                const messages = Array.isArray(rawMessages) ? rawMessages : [];
+                const fatalError = extractNonRetryableSessionError(messages);
+                if (fatalError) {
+                    void actRuntime.clearParticipantSessionBusy(request.actThreadId, rawPerformerId);
+                    void actRuntime.tripParticipantAutoWakeCircuit(request.actThreadId, rawPerformerId, fatalError);
+                    console.warn(`[chat-service] Opened auto-wake circuit for "${rawPerformerId}": ${fatalError}`);
+                    return;
+                }
+                void actRuntime.clearParticipantAutoWakeCircuit(request.actThreadId, rawPerformerId);
+                return actRuntime.drainParticipantQueue(request.actThreadId, rawPerformerId);
+            });
+        }).catch((error) => {
+            console.error(`[chat-service] Failed waiting for act session ${sessionId} to settle:`, error);
+            void actRuntime.clearParticipantSessionBusy(request.actThreadId, rawPerformerId);
+        });
+    }
+    return { accepted: true };
+}

package/dist/server/services/chat-session-service.js

@@ -0,0 +1,203 @@
+import { getOpencode } from '../lib/opencode.js';
+import { listSessionExecutionContextsForWorkingDir, resolveSessionExecutionContext, unregisterSessionExecutionContext, } from '../lib/session-execution.js';
+import { normalizeIncompleteToolParts, waitForSessionToSettle } from '../lib/chat-session.js';
+import { unwrapOpencodeResult } from '../lib/opencode-errors.js';
+import { responseData } from './opencode-service.js';
+function readResponseHeader(result, name) {
+    if (!result || typeof result !== 'object') {
+        return null;
+    }
+    const response = result.response;
+    if (!response?.headers || typeof response.headers.get !== 'function') {
+        return null;
+    }
+    const value = response.headers.get(name);
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export async function directoryQueryForSession(workingDir, sessionId) {
+    const context = await resolveSessionExecutionContext(sessionId);
+    return {
+        directory: context?.executionDir || workingDir,
+    };
+}
+export async function deleteStudioChatSession(workingDir, sessionId) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    unwrapOpencodeResult(await oc.session.delete({
+        sessionID: sessionId,
+        ...directoryQuery,
+    }));
+    await unregisterSessionExecutionContext(sessionId);
+    return { ok: true };
+}
+export async function renameStudioChatSession(workingDir, sessionId, title) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.update({
+        sessionID: sessionId,
+        ...directoryQuery,
+        title,
+    }));
+}
+export async function abortStudioChatSession(workingDir, sessionId) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    unwrapOpencodeResult(await oc.session.abort({
+        sessionID: sessionId,
+        ...directoryQuery,
+    }));
+    await waitForSessionToSettle(oc, sessionId, directoryQuery).catch(() => { });
+    return { ok: true };
+}
+export async function respondSessionPermission(workingDir, sessionId, permissionId, response) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    unwrapOpencodeResult(await oc.permission.respond({
+        ...directoryQuery,
+        sessionID: sessionId,
+        permissionID: permissionId,
+        response,
+    }));
+    return { ok: true };
+}
+export async function respondQuestion(questionId, answers) {
+    const oc = await getOpencode();
+    unwrapOpencodeResult(await oc.question.reply({
+        requestID: questionId,
+        answers,
+    }));
+    return { ok: true };
+}
+export async function rejectQuestion(questionId) {
+    const oc = await getOpencode();
+    unwrapOpencodeResult(await oc.question.reject({
+        requestID: questionId,
+    }));
+    return { ok: true };
+}
+export async function listPendingPermissions(workingDir) {
+    const oc = await getOpencode();
+    const res = await oc.permission.list({ directory: workingDir });
+    return responseData(res, []);
+}
+export async function listPendingQuestions(workingDir) {
+    const oc = await getOpencode();
+    const res = await oc.question.list({ directory: workingDir });
+    return responseData(res, []);
+}
+export async function listStudioSessionMessages(workingDir, sessionId, options = {}) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    const params = {
+        sessionID: sessionId,
+        ...directoryQuery,
+    };
+    if (typeof options.limit === 'number' && Number.isFinite(options.limit) && options.limit > 0) {
+        params.limit = options.limit;
+    }
+    if (typeof options.before === 'string' && options.before.trim()) {
+        params.$query_before = options.before.trim();
+    }
+    const messageResult = await oc.session.messages(params);
+    const data = unwrapOpencodeResult(messageResult);
+    const statuses = unwrapOpencodeResult(await oc.session.status({
+        ...directoryQuery,
+    }));
+    const status = statuses?.[sessionId];
+    const messages = !status || status.type === 'idle'
+        ? normalizeIncompleteToolParts(data || [], Date.now())
+        : (data || []);
+    return {
+        messages,
+        nextCursor: readResponseHeader(messageResult, 'x-next-cursor'),
+    };
+}
+export async function listStudioSessionDiff(workingDir, sessionId) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.diff({
+        sessionID: sessionId,
+        ...directoryQuery,
+    })) || [];
+}
+export async function shareStudioChatSession(workingDir, sessionId) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.share({
+        sessionID: sessionId,
+        ...directoryQuery,
+    }));
+}
+export async function summarizeStudioChatSession(workingDir, sessionId, options) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.summarize({
+        sessionID: sessionId,
+        ...directoryQuery,
+        ...(options.providerID && options.modelID ? { providerID: options.providerID, modelID: options.modelID } : {}),
+        ...(typeof options.auto === 'boolean' ? { auto: options.auto } : {}),
+    }));
+}
+export async function revertStudioChatSession(workingDir, sessionId, input) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.revert({
+        sessionID: sessionId,
+        ...directoryQuery,
+        messageID: input.messageId,
+        ...(input.partId ? { partID: input.partId } : {}),
+    }));
+}
+export async function unrevertStudioChatSession(workingDir, sessionId) {
+    const oc = await getOpencode();
+    const directoryQuery = await directoryQueryForSession(workingDir, sessionId);
+    return unwrapOpencodeResult(await oc.session.unrevert({
+        sessionID: sessionId,
+        ...directoryQuery,
+    }));
+}
+export async function listStudioChatSessions(workingDir) {
+    const oc = await getOpencode();
+    const performerContexts = await listSessionExecutionContextsForWorkingDir(workingDir, 'performer');
+    const actContexts = await listSessionExecutionContextsForWorkingDir(workingDir, 'act');
+    const directories = Array.from(new Set([
+        workingDir,
+        ...performerContexts.map((context) => context.executionDir),
+        ...actContexts.map((context) => context.executionDir),
+    ]));
+    const directoryData = await Promise.all(directories.map(async (directory) => {
+        const [sessions, statuses] = await Promise.all([
+            unwrapOpencodeResult(await oc.session.list({ directory })),
+            unwrapOpencodeResult(await oc.session.status({ directory })),
+        ]);
+        return {
+            sessions: sessions || [],
+            statuses: statuses || {},
+        };
+    }));
+    const sessions = new Map();
+    for (const entry of directoryData) {
+        for (const session of entry.sessions) {
+            if (!session?.id)
+                continue;
+            const normalized = {
+                ...session,
+                createdAt: typeof session.createdAt === 'number' ? session.createdAt : session.time?.created,
+                updatedAt: typeof session.updatedAt === 'number' ? session.updatedAt : session.time?.updated,
+                parentId: typeof session.parentID === 'string' ? session.parentID : null,
+                status: entry.statuses[session.id]?.type,
+            };
+            const existing = sessions.get(session.id);
+            const existingUpdatedAt = existing?.updatedAt || 0;
+            const nextUpdatedAt = normalized.updatedAt || 0;
+            if (!existing || nextUpdatedAt >= existingUpdatedAt) {
+                sessions.set(session.id, normalized);
+            }
+        }
+    }
+    return Array.from(sessions.values());
+}

package/dist/server/services/compile-service.js

@@ -0,0 +1,4 @@
+import { compileProjectionPreview } from './opencode-projection/preview-service.js';
+export async function compileStudioPromptPreview(workingDir, request) {
+    return compileProjectionPreview(workingDir, request);
+}