@otto-code/server 0.5.0

package/dist/server/server/session/project-config/project-config-session.d.ts

@@ -0,0 +1,34 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ProjectRegistry } from "../../workspace-registry.js";
+export interface ProjectConfigSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+export interface ProjectConfigSessionOptions {
+    host: ProjectConfigSessionHost;
+    projectRegistry: Pick<ProjectRegistry, "list">;
+    logger: pino.Logger;
+}
+/**
+ * A client's read/write surface for a project's on-disk otto.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export declare class ProjectConfigSession {
+    private readonly host;
+    private readonly projectRegistry;
+    private readonly logger;
+    constructor(options: ProjectConfigSessionOptions);
+    handleReadProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "read_project_config_request";
+    }>): Promise<void>;
+    handleWriteProjectConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "write_project_config_request";
+    }>): Promise<void>;
+    private emitProjectConfigReadFailure;
+    private emitProjectConfigWriteFailure;
+    private resolveKnownProjectRoot;
+}
+//# sourceMappingURL=project-config-session.d.ts.map

package/dist/server/server/session/project-config/project-config-session.js

@@ -0,0 +1,125 @@
+import { realpathSync } from "node:fs";
+import { resolve, sep } from "path";
+import { readOttoConfigForEdit, writeOttoConfigForEdit, } from "../../../utils/otto-config-file.js";
+/**
+ * A client's read/write surface for a project's on-disk otto.json. Resolves the
+ * request's repoRoot against the known (non-archived) project roots — accepting a
+ * trailing slash or a symlink via realpath — then reads or writes the config
+ * substrate and emits the matching response. Reaches no state beyond the injected
+ * project registry and the outbound channel.
+ */
+export class ProjectConfigSession {
+    constructor(options) {
+        this.host = options.host;
+        this.projectRegistry = options.projectRegistry;
+        this.logger = options.logger;
+    }
+    async handleReadProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigReadFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        const result = readOttoConfigForEdit(repoRoot);
+        if (!result.ok) {
+            this.logger.warn({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Failed to read project config");
+            this.emitProjectConfigReadFailure(msg, result.error, repoRoot);
+            return;
+        }
+        if (result.config === null) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "missing_project_config" }, "Project config missing");
+        }
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+            },
+        });
+    }
+    async handleWriteProjectConfigRequest(msg) {
+        const repoRoot = await this.resolveKnownProjectRoot(msg.repoRoot);
+        if (!repoRoot) {
+            this.emitProjectConfigWriteFailure(msg, { code: "project_not_found" });
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "write_attempt" }, "Writing project config");
+        const result = writeOttoConfigForEdit({
+            repoRoot,
+            config: msg.config,
+            expectedRevision: msg.expectedRevision,
+        });
+        if (!result.ok) {
+            this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: result.error.code }, "Project config write did not complete");
+            this.emitProjectConfigWriteFailure(msg, result.error, repoRoot);
+            return;
+        }
+        this.logger.debug({ repoRoot, requestId: msg.requestId, outcome: "written" }, "Project config written");
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: true,
+                config: result.config,
+                revision: result.revision,
+            },
+        });
+    }
+    emitProjectConfigReadFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "read_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    emitProjectConfigWriteFailure(msg, error, repoRoot = msg.repoRoot) {
+        this.host.emit({
+            type: "write_project_config_response",
+            payload: {
+                requestId: msg.requestId,
+                repoRoot,
+                ok: false,
+                error,
+            },
+        });
+    }
+    async resolveKnownProjectRoot(repoRoot) {
+        const requestedRoot = canonicalizeConfigRoot(repoRoot);
+        const projects = await this.projectRegistry.list();
+        for (const project of projects) {
+            if (project.archivedAt !== null) {
+                continue;
+            }
+            const projectRoot = canonicalizeConfigRoot(project.rootPath);
+            if (requestedRoot === projectRoot) {
+                return projectRoot;
+            }
+        }
+        return null;
+    }
+}
+function canonicalizeConfigRoot(repoRoot) {
+    const resolved = resolve(repoRoot);
+    try {
+        return stripTrailingPathSeparators(realpathSync(resolved));
+    }
+    catch {
+        return stripTrailingPathSeparators(resolved);
+    }
+}
+function stripTrailingPathSeparators(path) {
+    let normalized = path;
+    while (normalized.length > 1 && normalized.endsWith(sep)) {
+        normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+}
+//# sourceMappingURL=project-config-session.js.map

package/dist/server/server/session/provider/provider-catalog-session.d.ts

@@ -0,0 +1,74 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import { type ProviderSnapshotManager } from "../../agent/provider-snapshot-manager.js";
+import type { AgentFeature, AgentSessionConfig } from "../../agent/agent-sdk-types.js";
+import type { ProviderAvailability } from "../../agent/agent-manager.js";
+import type { ProviderUsageService } from "../../../services/quota-fetcher/service.js";
+/**
+ * The collaborators a provider-catalog request reaches that are NOT part of the
+ * provider domain. Two are CLIENT-COMPAT predicates the Session shell owns because
+ * agent-lifecycle shares the visibility gate: both read client state (appVersion /
+ * capabilities) LIVE, mutated post-construction via updateAppVersion /
+ * updateClientCapabilities. The two agent-control reads expose provider availability
+ * and draft features the AgentManager owns.
+ */
+export interface ProviderCatalogSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    isProviderVisibleToClient(provider: string): boolean;
+    supportsCustomModeIcons(): boolean;
+    listProviderAvailability(): Promise<ProviderAvailability[]>;
+    listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
+}
+export interface ProviderCatalogSessionOptions {
+    host: ProviderCatalogSessionHost;
+    providerSnapshotManager: ProviderSnapshotManager;
+    providerUsageService: ProviderUsageService;
+    logger: pino.Logger;
+}
+/**
+ * A client's provider catalog surface: model / mode / feature listing, the providers
+ * snapshot push + pull, provider diagnostics, and usage. The snapshot PUSH (start) and
+ * every PULL handler gate visibility and downgrade mode icons through the SAME predicates,
+ * so an older client sees one consistent provider set across both paths — the COMPAT
+ * invariant the shell could only enforce by code proximity before this carve.
+ */
+export declare class ProviderCatalogSession {
+    private readonly host;
+    private readonly providerSnapshotManager;
+    private readonly providerUsageService;
+    private readonly logger;
+    private unsubscribeSnapshotEvents;
+    constructor(options: ProviderCatalogSessionOptions);
+    start(): void;
+    dispose(): void;
+    private downgradeModeIconsForClient;
+    private downgradeEntryModesForClient;
+    private emitProviderDisabledResponse;
+    handleListProviderModelsRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_models_request";
+    }>): Promise<void>;
+    handleListProviderModesRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_modes_request";
+    }>): Promise<void>;
+    private getProviderSnapshotEntryForRead;
+    private buildDraftAgentSessionConfig;
+    handleListProviderFeaturesRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_provider_features_request";
+    }>): Promise<void>;
+    handleListAvailableProvidersRequest(msg: Extract<SessionInboundMessage, {
+        type: "list_available_providers_request";
+    }>): Promise<void>;
+    handleGetProvidersSnapshotRequest(msg: Extract<SessionInboundMessage, {
+        type: "get_providers_snapshot_request";
+    }>): Promise<void>;
+    handleRefreshProvidersSnapshotRequest(msg: Extract<SessionInboundMessage, {
+        type: "refresh_providers_snapshot_request";
+    }>): Promise<void>;
+    handleProviderDiagnosticRequest(msg: Extract<SessionInboundMessage, {
+        type: "provider_diagnostic_request";
+    }>): Promise<void>;
+    handleProviderUsageListRequest(msg: Extract<SessionInboundMessage, {
+        type: "provider.usage.list.request";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=provider-catalog-session.d.ts.map

package/dist/server/server/session/provider/provider-catalog-session.js

@@ -0,0 +1,343 @@
+import { getErrorMessage } from "@otto-code/protocol/error-utils";
+import { isGlobalProviderSnapshotKey, } from "../../agent/provider-snapshot-manager.js";
+import { expandTilde } from "../../../utils/path.js";
+// COMPAT(customModeIcons): the only mode icons known to clients before v0.1.84. Any
+// other icon name is downgraded to "ShieldCheck" for those clients.
+const LEGACY_MODE_ICONS = new Set([
+    "ShieldCheck",
+    "ShieldAlert",
+    "ShieldOff",
+    "ShieldQuestionMark",
+]);
+/**
+ * A client's provider catalog surface: model / mode / feature listing, the providers
+ * snapshot push + pull, provider diagnostics, and usage. The snapshot PUSH (start) and
+ * every PULL handler gate visibility and downgrade mode icons through the SAME predicates,
+ * so an older client sees one consistent provider set across both paths — the COMPAT
+ * invariant the shell could only enforce by code proximity before this carve.
+ */
+export class ProviderCatalogSession {
+    constructor(options) {
+        this.unsubscribeSnapshotEvents = null;
+        this.host = options.host;
+        this.providerSnapshotManager = options.providerSnapshotManager;
+        this.providerUsageService = options.providerUsageService;
+        this.logger = options.logger;
+    }
+    start() {
+        const handleProviderSnapshotChange = (entries, cwd) => {
+            // COMPAT(providersSnapshot): keep provider visibility gating for older clients.
+            const visibleEntries = entries.filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
+            const snapshotCwd = isGlobalProviderSnapshotKey(cwd) ? undefined : cwd;
+            this.host.emit({
+                type: "providers_snapshot_update",
+                payload: {
+                    ...(snapshotCwd ? { cwd: snapshotCwd } : {}),
+                    entries: this.downgradeEntryModesForClient(visibleEntries),
+                    generatedAt: new Date().toISOString(),
+                },
+            });
+        };
+        this.providerSnapshotManager.on("change", handleProviderSnapshotChange);
+        this.unsubscribeSnapshotEvents = () => {
+            this.providerSnapshotManager.off("change", handleProviderSnapshotChange);
+        };
+    }
+    dispose() {
+        if (this.unsubscribeSnapshotEvents) {
+            this.unsubscribeSnapshotEvents();
+            this.unsubscribeSnapshotEvents = null;
+        }
+    }
+    // COMPAT(customModeIcons): rewrite icons unknown to v0.1.83 clients (whose MODE_ICONS
+    // map is a closed enum and would render `undefined`, crashing in render). Drop
+    // this and the cap gate when floor >= v0.1.84.
+    downgradeModeIconsForClient(modes) {
+        if (this.host.supportsCustomModeIcons())
+            return modes;
+        return modes.map((mode) => mode.icon && !LEGACY_MODE_ICONS.has(mode.icon) ? { ...mode, icon: "ShieldCheck" } : mode);
+    }
+    downgradeEntryModesForClient(entries) {
+        if (this.host.supportsCustomModeIcons())
+            return entries;
+        return entries.map((entry) => entry.modes ? { ...entry, modes: this.downgradeModeIconsForClient(entry.modes) } : entry);
+    }
+    emitProviderDisabledResponse(kind, provider, requestId, fetchedAt) {
+        const payload = {
+            provider,
+            error: `Provider ${provider} is disabled`,
+            fetchedAt,
+            requestId,
+        };
+        if (kind === "models") {
+            this.host.emit({ type: "list_provider_models_response", payload });
+        }
+        else {
+            this.host.emit({ type: "list_provider_modes_response", payload });
+        }
+    }
+    async handleListProviderModelsRequest(msg) {
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
+        const fetchedAt = new Date().toISOString();
+        const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
+        if (!entry) {
+            this.host.emit({
+                type: "list_provider_models_response",
+                payload: {
+                    provider: msg.provider,
+                    error: `Unknown provider: ${msg.provider}`,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (!entry.enabled) {
+            this.emitProviderDisabledResponse("models", msg.provider, msg.requestId, fetchedAt);
+            return;
+        }
+        if (entry.status === "ready") {
+            this.host.emit({
+                type: "list_provider_models_response",
+                payload: {
+                    provider: msg.provider,
+                    models: entry.models ?? [],
+                    error: null,
+                    fetchedAt: entry.fetchedAt ?? fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const errorMessage = entry.status === "error"
+            ? (entry.error ?? `Failed to list models for ${msg.provider}`)
+            : `Provider ${msg.provider} is not available`;
+        this.host.emit({
+            type: "list_provider_models_response",
+            payload: {
+                provider: msg.provider,
+                error: errorMessage,
+                fetchedAt,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleListProviderModesRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        const cwd = resolveCatalogRequestCwd(msg.cwd);
+        const entry = await this.getProviderSnapshotEntryForRead(cwd, msg.provider);
+        if (!entry) {
+            this.host.emit({
+                type: "list_provider_modes_response",
+                payload: {
+                    provider: msg.provider,
+                    error: `Unknown provider: ${msg.provider}`,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        if (!entry.enabled) {
+            this.emitProviderDisabledResponse("modes", msg.provider, msg.requestId, fetchedAt);
+            return;
+        }
+        if (entry.status === "ready") {
+            this.host.emit({
+                type: "list_provider_modes_response",
+                payload: {
+                    provider: msg.provider,
+                    modes: this.downgradeModeIconsForClient(entry.modes ?? []),
+                    error: null,
+                    fetchedAt: entry.fetchedAt ?? fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+            return;
+        }
+        const errorMessage = entry.status === "error"
+            ? (entry.error ?? `Failed to list modes for ${msg.provider}`)
+            : `Provider ${msg.provider} is not available`;
+        this.host.emit({
+            type: "list_provider_modes_response",
+            payload: {
+                provider: msg.provider,
+                error: errorMessage,
+                fetchedAt,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async getProviderSnapshotEntryForRead(cwd, provider) {
+        const manager = this.providerSnapshotManager;
+        const findEntry = () => manager.getSnapshot(cwd).find((candidate) => candidate.provider === provider);
+        let entry = findEntry();
+        if (entry && !entry.enabled) {
+            return entry;
+        }
+        if (!entry || entry.status === "loading") {
+            // Awaits the in-flight warmup (deduped per-cwd) so old clients still get
+            // a resolved answer rather than a loading placeholder.
+            await manager.warmUpSnapshotForCwd({ cwd, providers: [provider] });
+            entry = findEntry();
+        }
+        return entry;
+    }
+    buildDraftAgentSessionConfig(draftConfig) {
+        return {
+            provider: draftConfig.provider,
+            cwd: expandTilde(draftConfig.cwd),
+            ...(draftConfig.modeId ? { modeId: draftConfig.modeId } : {}),
+            ...(draftConfig.model ? { model: draftConfig.model } : {}),
+            ...(draftConfig.thinkingOptionId ? { thinkingOptionId: draftConfig.thinkingOptionId } : {}),
+            ...(draftConfig.featureValues ? { featureValues: draftConfig.featureValues } : {}),
+        };
+    }
+    async handleListProviderFeaturesRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const sessionConfig = this.buildDraftAgentSessionConfig(msg.draftConfig);
+            const features = await this.host.listDraftFeatures(sessionConfig);
+            this.host.emit({
+                type: "list_provider_features_response",
+                payload: {
+                    provider: msg.draftConfig.provider,
+                    features,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, provider: msg.draftConfig.provider, draftConfig: msg.draftConfig }, `Failed to list features for ${msg.draftConfig.provider}`);
+            this.host.emit({
+                type: "list_provider_features_response",
+                payload: {
+                    provider: msg.draftConfig.provider,
+                    error: getErrorMessage(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleListAvailableProvidersRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const providers = (await this.host.listProviderAvailability()).filter((provider) => this.host.isProviderVisibleToClient(provider.provider));
+            this.host.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to list provider availability");
+            this.host.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers: [],
+                    error: getErrorMessage(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
+    async handleGetProvidersSnapshotRequest(msg) {
+        // COMPAT(providersSnapshot): keep legacy provider-list RPCs alongside snapshot flow.
+        const entries = this.providerSnapshotManager
+            .getSnapshot(msg.cwd ? expandTilde(msg.cwd) : undefined)
+            .filter((entry) => this.host.isProviderVisibleToClient(entry.provider));
+        this.host.emit({
+            type: "get_providers_snapshot_response",
+            payload: {
+                entries: this.downgradeEntryModesForClient(entries),
+                generatedAt: new Date().toISOString(),
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleRefreshProvidersSnapshotRequest(msg) {
+        if (msg.cwd) {
+            await this.providerSnapshotManager.refreshSnapshotForCwd({
+                cwd: expandTilde(msg.cwd),
+                providers: msg.providers,
+            });
+        }
+        else {
+            await this.providerSnapshotManager.refreshSettingsSnapshot({
+                providers: msg.providers,
+            });
+        }
+        this.host.emit({
+            type: "refresh_providers_snapshot_response",
+            payload: {
+                acknowledged: true,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    async handleProviderDiagnosticRequest(msg) {
+        try {
+            const { diagnostic } = await this.providerSnapshotManager.getProviderDiagnostic(msg.provider);
+            this.host.emit({
+                type: "provider_diagnostic_response",
+                payload: {
+                    provider: msg.provider,
+                    diagnostic,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({ err, provider: msg.provider }, `Failed to get provider diagnostic for ${msg.provider}`);
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: msg.type,
+                    error: `Failed to get provider diagnostic: ${err.message}`,
+                    code: "provider_diagnostic_failed",
+                },
+            });
+        }
+    }
+    async handleProviderUsageListRequest(msg) {
+        try {
+            const usage = await this.providerUsageService.listUsage();
+            this.host.emit({
+                type: "provider.usage.list.response",
+                payload: {
+                    requestId: msg.requestId,
+                    fetchedAt: usage.fetchedAt,
+                    providers: usage.providers,
+                },
+            });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.logger.error({ err }, "Failed to list provider usage");
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: msg.type,
+                    error: `Failed to list provider usage: ${err.message}`,
+                    code: "provider_usage_list_failed",
+                },
+            });
+        }
+    }
+}
+function resolveCatalogRequestCwd(cwd) {
+    const trimmed = cwd?.trim();
+    return trimmed ? expandTilde(trimmed) : undefined;
+}
+//# sourceMappingURL=provider-catalog-session.js.map