dexto 1.6.16 → 1.6.17

package/dist/cli/cloud-chat.js

@@ -0,0 +1,697 @@
+import { AgentEventBus, logger, } from '@dexto/core';
+import { startInkCliRefactored } from '@dexto/tui';
+import { createDeployClient } from './commands/deploy/client.js';
+import { loadWorkspaceDeployLink } from './commands/deploy/state.js';
+const CLOUD_SUPPORTED_COMMANDS = [
+    'help',
+    'h',
+    '?',
+    'exit',
+    'quit',
+    'q',
+    'new',
+    'clear',
+    'reset',
+    'resume',
+    'r',
+    'search',
+    'find',
+    'export',
+    'copy',
+    'cp',
+    'shortcuts',
+    'docs',
+    'doc',
+    'login',
+    'logout',
+    'stream',
+    'sounds',
+];
+const KNOWN_PROVIDERS = new Set([
+    'openai',
+    'openai-compatible',
+    'anthropic',
+    'google',
+    'groq',
+    'xai',
+    'cohere',
+    'minimax',
+    'glm',
+    'openrouter',
+    'litellm',
+    'glama',
+    'vertex',
+    'bedrock',
+    'local',
+    'ollama',
+    'dexto-nova',
+]);
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function unsupportedCloudFeature(feature) {
+    return new Error(`${feature} is not available while connected to a cloud agent.`);
+}
+function normalizeProvider(provider) {
+    if (!provider || !KNOWN_PROVIDERS.has(provider)) {
+        return undefined;
+    }
+    return provider;
+}
+function normalizeCloudParts(parts) {
+    return parts.map((part) => {
+        if (part.type === 'text') {
+            return {
+                type: 'text',
+                text: part.text,
+            };
+        }
+        if (part.type === 'image') {
+            return {
+                type: 'image',
+                image: part.image,
+                ...(part.mimeType !== undefined ? { mimeType: part.mimeType } : {}),
+            };
+        }
+        return {
+            type: 'file',
+            data: part.data,
+            mimeType: part.mimeType,
+            ...(part.filename !== undefined ? { filename: part.filename } : {}),
+        };
+    });
+}
+function normalizeHistoryEntry(entry, index) {
+    const content = normalizeCloudParts(entry.content);
+    if (entry.role === 'assistant') {
+        const provider = normalizeProvider(entry.provider);
+        return {
+            role: 'assistant',
+            content: content.length > 0 ? content : null,
+            ...(entry.reasoning !== undefined ? { reasoning: entry.reasoning } : {}),
+            ...(entry.model !== undefined ? { model: entry.model } : {}),
+            ...(provider ? { provider } : {}),
+            ...(entry.timestamp !== undefined ? { timestamp: entry.timestamp } : {}),
+        };
+    }
+    if (entry.role === 'tool') {
+        return {
+            role: 'tool',
+            content,
+            toolCallId: entry.toolCallId ?? `cloud-tool-${index}`,
+            name: entry.name ?? `tool-${index + 1}`,
+            ...(entry.success !== undefined ? { success: entry.success } : {}),
+            ...(entry.timestamp !== undefined ? { timestamp: entry.timestamp } : {}),
+        };
+    }
+    return {
+        role: entry.role,
+        content,
+        ...(entry.timestamp !== undefined ? { timestamp: entry.timestamp } : {}),
+    };
+}
+function buildSessionMetadata(session) {
+    return {
+        createdAt: session.createdAt ?? Date.now(),
+        lastActivity: session.lastActivity ?? session.createdAt ?? Date.now(),
+        messageCount: session.messageCount,
+        ...(session.title ? { title: session.title } : {}),
+    };
+}
+function extractTextContent(parts) {
+    return parts
+        .filter((part) => part.type === 'text')
+        .map((part) => part.text)
+        .join('\n')
+        .trim();
+}
+function contentInputToParts(input) {
+    return typeof input === 'string' ? [{ type: 'text', text: input }] : [...input];
+}
+function contentInputToCloudText(input) {
+    const parts = contentInputToParts(input);
+    const unsupportedParts = parts.filter((part) => part.type !== 'text');
+    if (unsupportedParts.length > 0) {
+        throw unsupportedCloudFeature('Image and file attachments');
+    }
+    const text = extractTextContent(parts);
+    if (!text) {
+        throw new Error('Cloud chat messages must include text content.');
+    }
+    return text;
+}
+function contentPartsToCloudText(parts) {
+    return contentInputToCloudText(parts);
+}
+function combineQueuedContent(messages) {
+    return messages.flatMap((message) => message.content);
+}
+function buildQueuedMessage(id, content) {
+    return {
+        id,
+        content,
+        queuedAt: Date.now(),
+        kind: 'default',
+    };
+}
+function extractMessageSearchText(message) {
+    const content = message.role === 'assistant' ? (message.content ?? []) : message.content;
+    const text = extractTextContent(content);
+    if (message.role === 'assistant' && message.reasoning) {
+        return [text, message.reasoning].filter(Boolean).join('\n');
+    }
+    return text;
+}
+function buildSearchContext(text, query) {
+    const lowerText = text.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const matchIndex = lowerText.indexOf(lowerQuery);
+    if (matchIndex === -1) {
+        return {
+            matchedText: query,
+            context: text.slice(0, 160),
+        };
+    }
+    const start = Math.max(0, matchIndex - 60);
+    const end = Math.min(text.length, matchIndex + query.length + 100);
+    return {
+        matchedText: text.slice(matchIndex, matchIndex + query.length),
+        context: text.slice(start, end).trim(),
+    };
+}
+function emitStreamingEvent(eventBus, event) {
+    const { name, ...payload } = event;
+    eventBus.emit(name, payload);
+}
+export function buildCloudApprovalDecision(approval) {
+    if (typeof approval.approvalId !== 'string' || typeof approval.status !== 'string') {
+        return null;
+    }
+    const approvalData = typeof approval.data === 'object' && approval.data !== null
+        ? approval.data
+        : undefined;
+    return {
+        status: approval.status,
+        ...(approvalData?.formData !== undefined ? { formData: approvalData.formData } : {}),
+        ...(approvalData?.rememberChoice !== undefined
+            ? { rememberChoice: approvalData.rememberChoice }
+            : {}),
+        ...(approvalData?.rememberPattern !== undefined
+            ? { rememberPattern: approvalData.rememberPattern }
+            : {}),
+        ...(approvalData?.rememberDirectory !== undefined
+            ? { rememberDirectory: approvalData.rememberDirectory }
+            : {}),
+        ...(approval.reason !== undefined ? { reason: approval.reason } : {}),
+        ...(approval.message !== undefined ? { message: approval.message } : {}),
+    };
+}
+async function resolveCloudAgentId(options) {
+    const explicitCloudAgentId = options.cloudAgentId?.trim();
+    if (explicitCloudAgentId) {
+        return explicitCloudAgentId;
+    }
+    const workspaceRoot = options.workspaceRoot ?? process.cwd();
+    const link = await loadWorkspaceDeployLink(workspaceRoot);
+    if (link?.cloudAgentId) {
+        return link.cloudAgentId;
+    }
+    throw new Error('No cloud agent ID provided and this workspace is not linked to a deployment. Run `dexto deploy` first or pass a cloud agent ID.');
+}
+async function resolveInitialSessionId(client, cloudAgentId, options) {
+    const sessions = await client.listCloudAgentSessions(cloudAgentId);
+    if (options.resume) {
+        const requestedSession = sessions.find((session) => session.id === options.resume);
+        if (!requestedSession) {
+            throw new Error(`Cloud session '${options.resume}' not found for ${cloudAgentId}.`);
+        }
+        return requestedSession.id;
+    }
+    if (options.continueMostRecent) {
+        const [mostRecentSession] = sessions
+            .slice()
+            .sort((left, right) => (right.lastActivity ?? 0) - (left.lastActivity ?? 0));
+        return mostRecentSession?.id ?? null;
+    }
+    return null;
+}
+export function createCloudAgentBackend(client, cloudAgentId) {
+    const eventBus = new AgentEventBus();
+    const sessionMetadataCache = new Map();
+    const sessionTitleCache = new Map();
+    const sessionModelCache = new Map();
+    const queueBySession = new Map();
+    const globalDisabledTools = [];
+    const sessionDisabledTools = new Map();
+    const sessionAutoApproveTools = new Map();
+    const defaultLogFilePath = () => null;
+    const defaultLogLevel = () => {
+        return logger.getLevel();
+    };
+    const backendLogger = {
+        debug: (message, context) => {
+            logger.debug(message, context);
+        },
+        info: (message, context) => {
+            logger.info(message, context);
+        },
+        warn: (message, context) => {
+            logger.warn(message, context);
+        },
+        error: (message, context) => {
+            logger.error(message, context);
+        },
+        getLevel: defaultLogLevel,
+        getLogFilePath: defaultLogFilePath,
+    };
+    const ensureSessionMetadata = async (sessionId) => {
+        const cached = sessionMetadataCache.get(sessionId);
+        if (cached) {
+            return cached;
+        }
+        const sessions = await client.listCloudAgentSessions(cloudAgentId);
+        for (const session of sessions) {
+            const metadata = buildSessionMetadata(session);
+            sessionMetadataCache.set(session.id, metadata);
+            sessionTitleCache.set(session.id, metadata.title);
+        }
+        return sessionMetadataCache.get(sessionId);
+    };
+    const hydrateSessionHistory = async (sessionId) => {
+        const historyResult = await client.getCloudAgentSessionHistory(cloudAgentId, sessionId);
+        const history = historyResult.history.map(normalizeHistoryEntry);
+        const latestAssistant = [...history]
+            .reverse()
+            .find((message) => {
+            return message.role === 'assistant' && typeof message.model === 'string';
+        });
+        if (latestAssistant?.model) {
+            sessionModelCache.set(sessionId, {
+                model: latestAssistant.model,
+                ...(latestAssistant.provider ? { provider: latestAssistant.provider } : {}),
+            });
+        }
+        return history;
+    };
+    const dequeueQueuedMessages = (sessionId) => {
+        const queued = queueBySession.get(sessionId) ?? [];
+        queueBySession.delete(sessionId);
+        return queued;
+    };
+    const appendQueuedMessage = (sessionId, message) => {
+        const current = queueBySession.get(sessionId) ?? [];
+        const next = [...current, message];
+        queueBySession.set(sessionId, next);
+        return next.length;
+    };
+    const currentLLMConfig = (sessionId) => {
+        const cachedModel = sessionId ? sessionModelCache.get(sessionId) : undefined;
+        return {
+            provider: cachedModel?.provider ?? 'dexto-nova',
+            model: cachedModel?.model ?? 'cloud-agent',
+        };
+    };
+    const sessionLogger = {
+        getLogFilePath: defaultLogFilePath,
+        getLevel: defaultLogLevel,
+    };
+    const backend = {
+        logger: backendLogger,
+        config: {
+            agentId: cloudAgentId,
+        },
+        capabilities: {
+            supportedCommands: [...CLOUD_SUPPORTED_COMMANDS],
+            prompts: false,
+            resources: false,
+            attachments: false,
+            reasoningCycle: false,
+            contextStats: false,
+            startupInfo: false,
+        },
+        sessionManager: {
+            getSessionMetadata: async (sessionId) => await ensureSessionMetadata(sessionId),
+            getSessionStats: async () => {
+                const sessions = await client.listCloudAgentSessions(cloudAgentId);
+                return {
+                    totalSessions: sessions.length,
+                    inMemorySessions: sessions.length,
+                    maxSessions: Number.MAX_SAFE_INTEGER,
+                };
+            },
+        },
+        mcpManager: {
+            getClients: () => new Map(),
+            getFailedConnections: () => ({}),
+        },
+        toolManager: {
+            addSessionAutoApproveTools: async () => { },
+        },
+        services: {
+            hookManager: {
+                getHookNames: () => [],
+            },
+        },
+        on: ((eventName, listener, options) => {
+            eventBus.on(eventName, listener, options);
+        }),
+        emit: ((eventName, ...args) => {
+            const payload = args[0];
+            if (eventName === 'approval:response') {
+                const approval = payload;
+                const decision = buildCloudApprovalDecision(approval);
+                if (decision) {
+                    void client
+                        .submitCloudAgentApproval(cloudAgentId, approval.approvalId, decision)
+                        .catch((error) => {
+                        backendLogger.error('Failed to submit cloud approval response', {
+                            cloudAgentId,
+                            approvalId: approval.approvalId,
+                            status: approval.status,
+                            error: getErrorMessage(error),
+                        });
+                    });
+                }
+            }
+            return eventBus.emit(eventName, payload);
+        }),
+        stream: (async (content, sessionId, options) => {
+            const initialText = contentInputToCloudText(content);
+            const signal = options?.signal;
+            const iterator = async function* () {
+                let currentText = initialText;
+                for (;;) {
+                    const upstream = await client.streamCloudAgentMessage(cloudAgentId, {
+                        sessionId,
+                        content: currentText,
+                        ...(signal ? { signal } : {}),
+                    });
+                    let pendingRunComplete = null;
+                    for await (const event of upstream) {
+                        if (event.name === 'llm:response' && event.sessionId === sessionId) {
+                            if (typeof event.model === 'string') {
+                                sessionModelCache.set(sessionId, {
+                                    model: event.model,
+                                    ...(event.provider ? { provider: event.provider } : {}),
+                                });
+                            }
+                        }
+                        if (event.name === 'session:title-updated' &&
+                            event.sessionId === sessionId) {
+                            sessionTitleCache.set(sessionId, event.title);
+                            const metadata = await ensureSessionMetadata(sessionId);
+                            if (metadata) {
+                                sessionMetadataCache.set(sessionId, {
+                                    ...metadata,
+                                    title: event.title,
+                                });
+                            }
+                        }
+                        if (event.name === 'run:complete') {
+                            pendingRunComplete = event;
+                            continue;
+                        }
+                        emitStreamingEvent(eventBus, event);
+                        yield event;
+                    }
+                    const queuedMessages = dequeueQueuedMessages(sessionId);
+                    if (queuedMessages.length === 0) {
+                        if (pendingRunComplete) {
+                            emitStreamingEvent(eventBus, pendingRunComplete);
+                            yield pendingRunComplete;
+                        }
+                        break;
+                    }
+                    const combinedContent = combineQueuedContent(queuedMessages);
+                    const dequeuedEvent = {
+                        name: 'message:dequeued',
+                        sessionId,
+                        count: queuedMessages.length,
+                        ids: queuedMessages.map((message) => message.id),
+                        coalesced: queuedMessages.length > 1,
+                        content: combinedContent,
+                        messages: queuedMessages,
+                    };
+                    emitStreamingEvent(eventBus, dequeuedEvent);
+                    yield dequeuedEvent;
+                    currentText = contentPartsToCloudText(combinedContent);
+                }
+            };
+            return iterator();
+        }),
+        stop: (async () => { }),
+        run: (async () => {
+            throw unsupportedCloudFeature('Prompt execution');
+        }),
+        createSession: (async (sessionId) => {
+            const session = await client.createCloudAgentSession(cloudAgentId, sessionId ? { sessionId } : undefined);
+            const metadata = buildSessionMetadata(session);
+            sessionMetadataCache.set(session.id, metadata);
+            sessionTitleCache.set(session.id, metadata.title);
+            return {
+                id: session.id,
+                logger: sessionLogger,
+            };
+        }),
+        listSessions: (async () => {
+            const sessions = await client.listCloudAgentSessions(cloudAgentId);
+            for (const session of sessions) {
+                const metadata = buildSessionMetadata(session);
+                sessionMetadataCache.set(session.id, metadata);
+                sessionTitleCache.set(session.id, metadata.title);
+            }
+            return sessions.map((session) => session.id);
+        }),
+        getSession: (async (sessionId) => {
+            await ensureSessionMetadata(sessionId);
+            return {
+                id: sessionId,
+                logger: sessionLogger,
+            };
+        }),
+        getSessionMetadata: (async (sessionId) => await ensureSessionMetadata(sessionId)),
+        getSessionHistory: (async (sessionId) => await hydrateSessionHistory(sessionId)),
+        getSessionTitle: (async (sessionId) => {
+            const cachedTitle = sessionTitleCache.get(sessionId);
+            if (cachedTitle !== undefined) {
+                return cachedTitle;
+            }
+            return (await ensureSessionMetadata(sessionId))?.title;
+        }),
+        setSessionTitle: (async () => {
+            throw unsupportedCloudFeature('Session renaming');
+        }),
+        generateSessionTitle: (async (sessionId) => {
+            const result = await client.generateCloudAgentSessionTitle(cloudAgentId, sessionId);
+            const title = result?.title ?? undefined;
+            sessionTitleCache.set(sessionId, title);
+            const metadata = await ensureSessionMetadata(sessionId);
+            if (metadata) {
+                sessionMetadataCache.set(sessionId, {
+                    ...metadata,
+                    ...(title ? { title } : {}),
+                });
+            }
+            if (title) {
+                eventBus.emit('session:title-updated', {
+                    sessionId,
+                    title,
+                });
+            }
+            return title;
+        }),
+        forkSession: (async () => {
+            throw unsupportedCloudFeature('Session forking');
+        }),
+        getCurrentLLMConfig: ((sessionId) => currentLLMConfig(sessionId)),
+        switchLLM: (async () => {
+            throw unsupportedCloudFeature('Model switching');
+        }),
+        getSupportedProviders: (() => []),
+        getSupportedModels: (() => ({})),
+        getContextStats: (async () => {
+            throw unsupportedCloudFeature('Context statistics');
+        }),
+        clearContext: (async (sessionId) => {
+            await client.clearCloudAgentSessionContext(cloudAgentId, sessionId);
+            queueBySession.delete(sessionId);
+            eventBus.emit('context:cleared', { sessionId });
+        }),
+        compactContext: (async () => {
+            throw unsupportedCloudFeature('Context compaction');
+        }),
+        queueMessage: (async (sessionId, input) => {
+            const messageId = `queued-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const message = buildQueuedMessage(messageId, [...input.content]);
+            const position = appendQueuedMessage(sessionId, message);
+            eventBus.emit('message:queued', {
+                id: message.id,
+                position,
+                sessionId,
+            });
+            return {
+                queued: true,
+                position,
+                id: message.id,
+            };
+        }),
+        getQueuedMessages: (async (sessionId) => queueBySession.get(sessionId) ?? []),
+        removeQueuedMessage: (async (sessionId, messageId) => {
+            const current = queueBySession.get(sessionId) ?? [];
+            const next = current.filter((message) => message.id !== messageId);
+            queueBySession.set(sessionId, next);
+            eventBus.emit('message:removed', {
+                id: messageId,
+                sessionId,
+            });
+            return true;
+        }),
+        clearMessageQueue: (async (sessionId) => {
+            if (typeof sessionId === 'string') {
+                const clearedCount = (queueBySession.get(sessionId) ?? []).length;
+                queueBySession.delete(sessionId);
+                return clearedCount;
+            }
+            const clearedCount = Array.from(queueBySession.values()).reduce((total, queuedMessages) => total + queuedMessages.length, 0);
+            queueBySession.clear();
+            return clearedCount;
+        }),
+        cancel: (async (sessionId) => {
+            await client.cancelCloudAgentSessionRun(cloudAgentId, sessionId);
+            return true;
+        }),
+        searchMessages: (async (query, options = {}) => {
+            const normalizedQuery = query.trim();
+            if (!normalizedQuery) {
+                return {
+                    results: [],
+                    total: 0,
+                    hasMore: false,
+                    query,
+                    options,
+                };
+            }
+            const sessionIds = options.sessionId
+                ? [options.sessionId]
+                : await backend.listSessions();
+            const results = [];
+            for (const sessionId of sessionIds) {
+                const history = await backend.getSessionHistory(sessionId);
+                history.forEach((message, messageIndex) => {
+                    if (options.role && message.role !== options.role) {
+                        return;
+                    }
+                    const searchableText = extractMessageSearchText(message);
+                    if (!searchableText.toLowerCase().includes(normalizedQuery.toLowerCase())) {
+                        return;
+                    }
+                    const { matchedText, context } = buildSearchContext(searchableText, normalizedQuery);
+                    results.push({
+                        sessionId,
+                        message,
+                        matchedText,
+                        context,
+                        messageIndex,
+                    });
+                });
+            }
+            results.sort((left, right) => {
+                const leftTimestamp = left.message.timestamp ?? 0;
+                const rightTimestamp = right.message.timestamp ?? 0;
+                return rightTimestamp - leftTimestamp;
+            });
+            const offset = options.offset ?? 0;
+            const limit = options.limit ?? 20;
+            const pagedResults = results.slice(offset, offset + limit);
+            return {
+                results: pagedResults,
+                total: results.length,
+                hasMore: offset + limit < results.length,
+                query,
+                options,
+            };
+        }),
+        listPrompts: (async () => ({})),
+        refreshPrompts: (async () => { }),
+        resolvePrompt: (async () => {
+            throw unsupportedCloudFeature('Prompt resolution');
+        }),
+        getSystemPrompt: (async () => ''),
+        loadToolkits: (async (toolkits) => ({
+            loaded: [...toolkits],
+            skipped: [],
+        })),
+        listResources: (async () => ({})),
+        setLogLevel: (async () => { }),
+        getAllTools: (async () => ({})),
+        getEnabledTools: (async () => ({})),
+        getAllMcpTools: (async () => ({})),
+        setGlobalDisabledTools: ((toolNames) => {
+            globalDisabledTools.splice(0, globalDisabledTools.length, ...toolNames);
+        }),
+        setSessionDisabledTools: ((sessionId, toolNames) => {
+            sessionDisabledTools.set(sessionId, [...toolNames]);
+        }),
+        setSessionAutoApproveTools: ((sessionId, toolNames) => {
+            sessionAutoApproveTools.set(sessionId, [...toolNames]);
+        }),
+        getSessionAutoApproveTools: ((sessionId) => {
+            return sessionAutoApproveTools.get(sessionId) ?? [];
+        }),
+        getMcpServersWithStatus: (() => []),
+        addMcpServer: (async () => {
+            throw unsupportedCloudFeature('MCP management');
+        }),
+        enableMcpServer: (async () => {
+            throw unsupportedCloudFeature('MCP management');
+        }),
+        disableMcpServer: (async () => {
+            throw unsupportedCloudFeature('MCP management');
+        }),
+        removeMcpServer: (async () => {
+            throw unsupportedCloudFeature('MCP management');
+        }),
+        restartMcpServer: (async () => {
+            throw unsupportedCloudFeature('MCP management');
+        }),
+        getMcpClients: (() => new Map()),
+        getMcpFailedConnections: (() => ({})),
+        getEffectiveConfig: ((sessionId) => {
+            const llmConfig = currentLLMConfig(sessionId);
+            return {
+                runtimeTarget: 'cloud',
+                cloudAgentId,
+                llm: {
+                    provider: llmConfig.provider,
+                    model: llmConfig.model,
+                    maxOutputTokens: null,
+                    temperature: null,
+                },
+                permissions: {
+                    mode: 'cloud',
+                },
+                sessions: {},
+                mcpServers: {},
+                prompts: [],
+            };
+        }),
+    };
+    return backend;
+}
+export async function startCloudChatCli(options) {
+    if (!process.stdin.isTTY) {
+        throw new Error('Interactive cloud chat requires a TTY.');
+    }
+    const deployClient = createDeployClient();
+    const cloudAgentId = await resolveCloudAgentId(options);
+    const initialSessionId = await resolveInitialSessionId(deployClient, cloudAgentId, options);
+    const backend = createCloudAgentBackend(deployClient, cloudAgentId);
+    try {
+        await startInkCliRefactored(backend, initialSessionId, {
+            ...(options.initialPrompt ? { initialPrompt: options.initialPrompt } : {}),
+        });
+    }
+    catch (error) {
+        throw new Error(`Cloud chat failed: ${getErrorMessage(error)}`);
+    }
+}