@otto-code/server 0.5.0

package/dist/server/server/session.d.ts

@@ -0,0 +1,450 @@
+import { type ClientCapability } from "@otto-code/protocol/client-capabilities";
+import { type AgentSnapshotPayload, type SessionInboundMessage, type SessionOutboundMessage, type WorkspaceSetupSnapshot } from "./messages.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type { BinaryFrame } from "@otto-code/protocol/binary-frames/index";
+import type { SpeechToTextProvider, TextToSpeechProvider } from "./speech/speech-provider.js";
+import { type SpeechSettingsOptions } from "./speech/speech-settings-options.js";
+import type { TurnDetectionProvider } from "./speech/turn-detection-provider.js";
+import type { VoiceCallerContext, VoiceSpeakHandler } from "./voice-types.js";
+import type { ScriptHealthState } from "./script-health-monitor.js";
+import type { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import type { DaemonConfigStore } from "./daemon-config-store.js";
+import type { WorkspaceGitService } from "./workspace-git-service.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import { ProviderSnapshotManager } from "./agent/provider-snapshot-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+import { type PersistedWorkspaceRecord, type ProjectRegistry, type WorkspaceRegistry } from "./workspace-registry.js";
+import { type DaemonRuntimeConfig } from "./session/daemon/daemon-session.js";
+import type { DaemonWebSocketRuntimeDiagnosticSnapshot } from "./session/daemon/diagnostics.js";
+import { DownloadTokenStore } from "./file-download/token-store.js";
+import { PushTokenStore } from "./push/token-store.js";
+import type { DevServerManager } from "./preview/dev-server-manager.js";
+import type { ServiceProxySubsystem } from "./service-proxy.js";
+import { renameCurrentBranch as renameCurrentBranchDefault } from "../utils/checkout-git.js";
+import type { CheckoutDiffManager } from "./checkout-diff-manager.js";
+import type { Resolvable } from "./speech/provider-resolver.js";
+import type { SpeechReadinessSnapshot } from "./speech/speech-runtime.js";
+import type pino from "pino";
+import { FileBackedChatService } from "./chat/chat-service.js";
+import { LoopService } from "./loop-service.js";
+import { ScheduleService } from "./schedule/service.js";
+import { type GitHubService } from "../services/github-service.js";
+import type { GitHostingResolver } from "../services/git-hosting/resolver.js";
+import type { ProviderUsageService } from "../services/quota-fetcher/service.js";
+import { WorkspaceAutoName } from "./workspace-auto-name.js";
+export declare function resolveWaitForFinishError(options: {
+    status: "permission" | "error" | "idle";
+    final: AgentSnapshotPayload | null;
+}): string | null;
+export interface SessionRuntimeMetrics {
+    terminalDirectorySubscriptionCount: number;
+    terminalSubscriptionCount: number;
+    inflightRequests: number;
+    peakInflightRequests: number;
+}
+export interface SessionFileSystem {
+    isDirectory(path: string): Promise<boolean>;
+}
+type AgentMcpTransportFactory = () => Promise<unknown>;
+export interface SessionOptions {
+    clientId: string;
+    appVersion?: string | null;
+    clientCapabilities?: Record<string, unknown> | null;
+    onMessage: (msg: SessionOutboundMessage) => void;
+    onBinaryMessage?: (frame: Uint8Array) => void;
+    getTransportBufferedAmount?: () => number | null;
+    onLifecycleIntent?: (intent: SessionLifecycleIntent) => void;
+    logger: pino.Logger;
+    downloadTokenStore: DownloadTokenStore;
+    pushTokenStore: PushTokenStore;
+    ottoHome: string;
+    worktreesRoot?: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    projectRegistry: ProjectRegistry;
+    workspaceRegistry: WorkspaceRegistry;
+    filesystem?: SessionFileSystem;
+    chatService: FileBackedChatService;
+    scheduleService: ScheduleService;
+    loopService: LoopService;
+    checkoutDiffManager: CheckoutDiffManager;
+    github?: GitHubService;
+    gitHostingResolver?: GitHostingResolver;
+    createAgentMcpTransport?: AgentMcpTransportFactory;
+    renameCurrentBranch?: typeof renameCurrentBranchDefault;
+    workspaceGitService: WorkspaceGitService;
+    workspaceAutoName: WorkspaceAutoName;
+    daemonConfigStore: DaemonConfigStore;
+    mcpBaseUrl?: string | null;
+    stt: Resolvable<SpeechToTextProvider | null>;
+    sttLanguage?: string;
+    tts: Resolvable<TextToSpeechProvider | null>;
+    terminalManager: TerminalManager | null;
+    previewDevServers?: DevServerManager | null;
+    providerSnapshotManager: ProviderSnapshotManager;
+    providerUsageService: ProviderUsageService;
+    serviceProxy?: ServiceProxySubsystem;
+    scriptRuntimeStore?: WorkspaceScriptRuntimeStore;
+    workspaceSetupSnapshots?: Map<string, WorkspaceSetupSnapshot>;
+    onBranchChanged?: (workspaceId: string, oldBranch: string | null, newBranch: string | null) => void;
+    getDaemonTcpPort?: () => number | null;
+    getDaemonTcpHost?: () => string | null;
+    serviceProxyPublicBaseUrl?: string | null;
+    resolveScriptHealth?: (hostname: string) => ScriptHealthState | null;
+    voice?: {
+        turnDetection?: Resolvable<TurnDetectionProvider | null>;
+    };
+    voiceBridge?: {
+        registerVoiceSpeakHandler?: (agentId: string, handler: VoiceSpeakHandler) => void;
+        unregisterVoiceSpeakHandler?: (agentId: string) => void;
+        registerVoiceCallerContext?: (agentId: string, context: VoiceCallerContext) => void;
+        unregisterVoiceCallerContext?: (agentId: string) => void;
+    };
+    dictation?: {
+        finalTimeoutMs?: number;
+        stt?: Resolvable<SpeechToTextProvider | null>;
+        sttLanguage?: string;
+        getSpeechReadiness?: () => SpeechReadinessSnapshot;
+    };
+    getSpeechSettingsOptions?: () => SpeechSettingsOptions;
+    previewTts?: (params: {
+        text: string;
+        voice?: {
+            name: string;
+            model?: string;
+        };
+    }) => Promise<{
+        audio: string;
+        format: string;
+    } | null>;
+    getPersonalityStats?: () => Record<string, number> | Promise<Record<string, number>>;
+    serverId?: string;
+    daemonVersion?: string;
+    daemonRuntimeConfig?: DaemonRuntimeConfig;
+    getWebSocketRuntimeMetrics?: () => DaemonWebSocketRuntimeDiagnosticSnapshot | null;
+}
+export type SessionLifecycleIntent = {
+    type: "shutdown";
+    clientId: string;
+    requestId: string;
+    reason: string;
+} | {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+};
+/**
+ * Session represents a single connected client session.
+ * It owns all state management, orchestration logic, and message processing.
+ * Session has no knowledge of WebSockets - it only emits and receives messages.
+ */
+export declare class Session {
+    private readonly clientId;
+    private appVersion;
+    private clientCapabilities;
+    private readonly sessionId;
+    private readonly onMessage;
+    private readonly onBinaryMessage;
+    private readonly getTransportBufferedAmount;
+    private readonly onLifecycleIntent;
+    private readonly sessionLogger;
+    private readonly ottoHome;
+    private readonly worktreesRoot;
+    private agentManager;
+    private readonly agentStorage;
+    private readonly projectRegistry;
+    private readonly workspaceRegistry;
+    private readonly filesystem;
+    private readonly github;
+    private readonly gitHostingResolver;
+    private readonly renameCurrentBranch;
+    private readonly workspaceGitService;
+    private readonly workspaceAutoName;
+    private readonly gitMutation;
+    private readonly workspaceProvisioning;
+    private readonly daemonConfigStore;
+    private readonly getSpeechSettingsOptions;
+    private readonly previewTts;
+    private readonly getPersonalityStats;
+    private readonly pushTokenStore;
+    private unsubscribeAgentEvents;
+    private unsubscribeTerminalWorkspaceContributionEvents;
+    private readonly agentUpdates;
+    private workspaceUpdatesSubscription;
+    private clientActivity;
+    private readonly terminalManager;
+    private readonly previewDevServers;
+    private readonly providerSnapshotManager;
+    private readonly serviceProxy;
+    private readonly scriptRuntimeStore;
+    private readonly getDaemonTcpPort;
+    private readonly getDaemonTcpHost;
+    private readonly serviceProxyPublicBaseUrl;
+    private readonly resolveScriptHealth;
+    private readonly terminalController;
+    private inflightRequests;
+    private peakInflightRequests;
+    private readonly workspaceSetupSnapshots;
+    private readonly workspaceGitObserver;
+    private readonly workspaceDirectory;
+    private readonly voiceSession;
+    private readonly checkoutSession;
+    private readonly chatScheduleLoopSession;
+    private readonly providerCatalogSession;
+    private readonly workspaceFilesSession;
+    private readonly agentConfigSession;
+    private readonly projectConfigSession;
+    private readonly daemonSession;
+    private readonly artifactSession;
+    private readonly workspaceScripts;
+    private readonly createAgentLifecycleDispatch;
+    constructor(options: SessionOptions);
+    updateAppVersion(appVersion: string | null): void;
+    updateClientCapabilities(capabilities: Record<string, unknown> | null): void;
+    supports(capability: ClientCapability): boolean;
+    syncWorkspaceGitObserverForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
+    emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
+    archiveWorkspaceRecordForExternalMutation(workspaceId: string): Promise<void>;
+    markWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>, archivingAt: string): void;
+    clearWorkspaceArchivingForExternalMutation(workspaceIds: Iterable<string>): void;
+    emitWorkspaceUpdatesForExternalWorkspaceIds(workspaceIds: Iterable<string>): Promise<void>;
+    warmWorkspaceGitDataForWorkspace(workspace: PersistedWorkspaceRecord): Promise<void>;
+    /**
+     * Get the client's current activity state
+     */
+    getClientActivity(): {
+        deviceType: "web" | "mobile";
+        focusedAgentId: string | null;
+        focusedTerminalId: string | null;
+        lastActivityAt: Date;
+        appVisible: boolean;
+        appVisibilityChangedAt: Date;
+    } | null;
+    private getFocusedAgentSelectionForCwd;
+    private readStructuredGenerationDaemonConfig;
+    getRuntimeMetrics(): SessionRuntimeMetrics;
+    emitServerMessage(message: SessionOutboundMessage): void;
+    /**
+     * Send initial state to client after connection
+     */
+    sendInitialState(): Promise<void>;
+    /**
+     * Normalize a user prompt (with optional image metadata) for AgentManager
+     */
+    private buildAgentPrompt;
+    /**
+     * Interrupt the agent's active run so the next prompt starts a fresh turn.
+     * Returns once the manager confirms the stream has been cancelled.
+     */
+    private interruptAgentIfRunning;
+    private hasActiveAgentRun;
+    private handleAgentRunError;
+    /**
+     * Subscribe to AgentManager events and forward them to the client
+     */
+    private subscribeToOptionalManagers;
+    private subscribeToAgentEvents;
+    private buildAgentStreamPayload;
+    private buildAgentPayload;
+    private buildStoredAgentPayload;
+    private isProviderVisibleToClient;
+    private buildProjectPlacementForWorkspace;
+    private buildProjectPlacementForWorkspaceId;
+    /**
+     * Main entry point for processing session messages
+     */
+    handleMessage(msg: SessionInboundMessage): Promise<void>;
+    private dispatchInboundMessage;
+    private dispatchVoiceAndControlMessage;
+    private dispatchAgentRewindMessage;
+    private dispatchAgentPersonalityMessage;
+    private dispatchAgentRelationshipMessage;
+    private handleStopObservedSubagentRequest;
+    private dispatchAgentTimelineMessage;
+    private dispatchAgentLifecycleMessage;
+    private dispatchAgentConfigMessage;
+    private handleTtsPreviewRequest;
+    private dispatchCheckoutMessage;
+    private handleHostingAuthStatusRequest;
+    private dispatchPreviewMessage;
+    private dispatchWorkspaceAndProjectMessage;
+    private dispatchWorkspaceFilesMessage;
+    private dispatchProviderMessage;
+    private dispatchTerminalMessage;
+    private dispatchChatScheduleLoopMessage;
+    private dispatchArtifactMessage;
+    private dispatchMiscMessage;
+    resetPeakInflight(): void;
+    getSessionId(): string;
+    handleBinaryFrame(binaryFrame: BinaryFrame): Promise<void>;
+    private handleRestartServerRequest;
+    private handleShutdownServerRequest;
+    private emitLifecycleIntent;
+    private handleDeleteAgentRequest;
+    private handleArchiveAgentRequest;
+    private archiveAgentForClose;
+    private handleDetachAgentRequest;
+    private handleCloseItemsRequest;
+    private unarchiveAgentByHandle;
+    private handleUpdateAgentRequest;
+    private handleProjectRenameRequest;
+    private handleProjectRemoveRequest;
+    private handleWorkspaceTitleSetRequest;
+    /**
+     * UI-initiated preview RPCs behind the Preview toolbar button. Mirrors what
+     * the agent-facing preview_* tools do (packages/server/src/server/preview/preview-tools.ts)
+     * but is driven by the app directly instead of an agent tool call — the
+     * caller creates and places the browser tab itself, then reports the
+     * binding back via preview.bind_tab so a later agent preview_start call
+     * finds the same designated tab.
+     */
+    private handlePreviewListConfigRequest;
+    private handlePreviewStartRequest;
+    private handlePreviewBindTabRequest;
+    private handlePreviewStopRequest;
+    /**
+     * Handle text message to agent (with optional image attachments)
+     */
+    private handleSendAgentMessage;
+    /**
+     * Handle create agent request
+     */
+    /**
+     * Resolve an optional personality id against the roster + this cwd's provider
+     * snapshot and fold its identity onto the create config. Availability is
+     * re-checked here (the cwd may differ from where the picker resolved it); an
+     * unavailable or unknown personality is skipped with a warning rather than
+     * failing the create — the agent still runs with the chosen brain, just
+     * without personality identity. The brain fields are never overridden; only
+     * `personalitySnapshot` and (when the caller set none) `systemPrompt` are added.
+     */
+    private applyPersonalityIdentityToConfig;
+    /**
+     * Resolve a roster personality against a *running* agent's cwd for a live
+     * switch (agent.personality.set). Unlike the spawn-time soft-skip above, an
+     * unknown or unavailable personality throws — the RPC rejects with the reason
+     * instead of half-applying.
+     */
+    private resolvePersonalitySnapshotForAgent;
+    private handleCreateAgentRequest;
+    private handleResumeAgentRequest;
+    private handleImportAgentRequest;
+    private handleRefreshAgentRequest;
+    private handleCancelAgentRequest;
+    private handleAgentRewindRequest;
+    private buildAgentSessionConfig;
+    private isPathWithinRoot;
+    /**
+     * Handle clearing agent attention flag
+     */
+    private handleClearAgentAttention;
+    /**
+     * Handle client heartbeat for activity tracking
+     */
+    private handleClientHeartbeat;
+    private clearFocusedTerminalAttention;
+    /**
+     * Handle push token registration
+     */
+    /**
+     * Per-category context window breakdown for the client's context popup.
+     * `usage: null` (not an error) when the agent is gone, its provider doesn't
+     * implement the read, or the provider has no live handle to report from.
+     */
+    private handleAgentContextGetUsageRequest;
+    private handleRegisterPushToken;
+    /**
+     * Handle list commands request for an agent
+     */
+    private handleListCommandsRequest;
+    /**
+     * Handle agent permission response from user
+     */
+    private handleAgentPermissionResponse;
+    private handleDirectorySuggestionsRequest;
+    private handleOttoWorktreeListRequest;
+    private handleOttoWorktreeArchiveRequest;
+    private listTerminalActivityContributions;
+    /**
+     * Build the current agent list payload (live + persisted), optionally filtered by labels.
+     */
+    private listAgentPayloads;
+    private resolveAgentIdentifier;
+    private getAgentPayloadById;
+    private resolveDelegationRootWorkspaceId;
+    private buildActiveProjectPlacementsByWorkspaceId;
+    private collectFetchAgentsEntries;
+    private listFetchAgentsEntries;
+    private readonly agentsPager;
+    private decodeAgentCursor;
+    private describeWorkspaceRecord;
+    private buildWorkspaceGitRuntimePayload;
+    private buildWorkspaceGitHubRuntimePayload;
+    private describeWorkspaceRecordWithGitData;
+    private describeCreatedWorktreeWorkspace;
+    private buildWorkspaceDescriptor;
+    markWorkspaceArchiving(workspaceIds: Iterable<string>, archivingAt: string): void;
+    clearWorkspaceArchiving(workspaceIds: Iterable<string>): void;
+    private buildWorkspaceDescriptorMap;
+    private findWorkspaceIdForCwd;
+    private matchesWorkspaceFilter;
+    private listFetchWorkspacesEntries;
+    private bufferOrEmitWorkspaceUpdate;
+    private flushBootstrappedWorkspaceUpdates;
+    private buildProjectDescriptor;
+    private unarchiveOwningWorkspaceForAgent;
+    private recreateOwningWorktreeForRestore;
+    private createOttoWorktree;
+    private listActiveWorkspaceRefs;
+    private archiveWorkspaceRecord;
+    private teardownArchivedWorkspace;
+    private reconcileAndEmitWorkspaceUpdates;
+    private reconcileActiveWorkspaceRecords;
+    private emitWorkspaceUpdatesForWorkspaceIds;
+    private buildWorkspaceRemoveUpdatePayload;
+    private resolveProjectWithoutActiveWorkspacesForArchivedWorkspace;
+    private emitWorkspaceUpdateForTerminalContribution;
+    private emitWorkspaceUpdateForCwd;
+    private handleFetchAgents;
+    private handleFetchAgentHistory;
+    private handleFetchRecentProviderSessions;
+    private handleFetchWorkspacesRequest;
+    private buildBootstrapSnapshot;
+    private registerWorkspaceForImportedAgent;
+    private handleWorkspaceCreateRequest;
+    private handleWorkspaceCreateLocal;
+    private handleWorkspaceCreateWorktree;
+    private resolveWorktreeSourceCwd;
+    private handleOpenProjectRequest;
+    private handleProjectAddRequest;
+    private buildWorkspaceScriptPayloadSnapshot;
+    private handleStartWorkspaceScriptRequest;
+    private handleLegacyListAvailableEditorsRequest;
+    private handleLegacyOpenInEditorRequest;
+    private handleCreateOttoWorktreeRequest;
+    private createOttoWorktreeWorkflow;
+    private handleWorkspaceSetupStatusRequest;
+    private handleArchiveWorkspaceRequest;
+    private handleWorkspaceClearAttentionRequest;
+    private handleFetchAgent;
+    private shouldUseFullTimelineForProjectedPage;
+    private selectCanonicalTimelineProjection;
+    private selectProjectedTimelineProjection;
+    private selectTimelineProjection;
+    private handleFetchAgentTimelineRequest;
+    private handleAgentForkContextRequest;
+    private handleSendAgentMessageRequest;
+    private handleWaitForFinish;
+    /**
+     * Emit a message to the client
+     */
+    private emit;
+    private emitBinary;
+    /**
+     * Clean up session resources
+     */
+    cleanup(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=session.d.ts.map