@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/session/ingestion/source-session.js

@@ -0,0 +1,191 @@
+import { IngestionError } from "../../ingestion/errors.js";
+/**
+ * The client-facing string for a failed source request.
+ *
+ * An IngestionError collapses to its CODE, never its message: the message is
+ * the aggregator's own text, which can echo request context including a header
+ * we sent.
+ */
+function toSourceErrorMessage(error) {
+    if (error instanceof IngestionError) {
+        return error.code;
+    }
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+/**
+ * A client's ingestion-source request surface: catalogue, connect, list, check.
+ *
+ * Its own file rather than an arm of ChatScheduleLoopSession, which already
+ * carries chat, schedule, loop and fleet. Appending a fifth concern there would
+ * be the smaller diff and the worse file.
+ *
+ * Every handler is a thin pass-through to IngestionService. No health logic, no
+ * store access and no gateway reaches this layer, so there is nothing here that
+ * could put a credential on the wire.
+ */
+export class SourceSession {
+    constructor(options) {
+        this.host = options.host;
+        this.ingestionService = options.ingestionService;
+        this.logger = options.logger;
+    }
+    /**
+     * An IngestionError is reported by its CODE, never its message.
+     *
+     * The message is an aggregator's own text, which can echo request context
+     * including a header we sent. The code is a closed set we wrote ourselves, so
+     * it is the only part safe to hand to a client or to a log line.
+     */
+    emitSourceRpcError(request, error) {
+        const message = toSourceErrorMessage(error);
+        this.logger.error({ err: error, requestType: request.type }, "Source request failed");
+        this.host.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "source_request_failed",
+            },
+        });
+    }
+    async handleSourceCatalogueRequest(request) {
+        try {
+            const page = await this.ingestionService.catalogue(request.kind, request.query, request.cursor);
+            this.host.emit({
+                type: "source/catalogue/response",
+                payload: {
+                    requestId: request.requestId,
+                    items: page.items,
+                    nextCursor: page.nextCursor,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    async handleSourceConnectRequest(request) {
+        try {
+            const result = await this.ingestionService.connect(request.kind, request.appSlug);
+            this.host.emit({
+                type: "source/connect/response",
+                payload: {
+                    requestId: request.requestId,
+                    source: result.source,
+                    redirectUrl: result.redirectUrl,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    async handleSourceListRequest(request) {
+        try {
+            const sources = await this.ingestionService.list();
+            this.host.emit({
+                type: "source/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    sources,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    async handleSourceCheckRequest(request) {
+        try {
+            const source = await this.ingestionService.check(request.sourceId);
+            this.host.emit({
+                type: "source/check/response",
+                payload: {
+                    requestId: request.requestId,
+                    source,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    /**
+     * FILTER AUTHORING (Epic 7).
+     *
+     * The four handlers Epics 1-6 never shipped, which is why connecting a source
+     * reached nothing: the engine could match, cap, dispatch and reconcile, and
+     * the only way to author the document driving it was to hand-write JSON into
+     * `~/.paseo/filters/`.
+     *
+     * Same pass-through discipline as the source handlers above - all policy is
+     * in IngestionService and FilterStore, nothing here touches a gateway.
+     */
+    async handleIngestionFilterListRequest(request) {
+        try {
+            const filters = await this.ingestionService.listFilters(request.sourceId);
+            this.host.emit({
+                type: "ingestion/filter/list/response",
+                payload: { requestId: request.requestId, filters, error: null },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    async handleIngestionFilterCreateRequest(request) {
+        try {
+            const filter = await this.ingestionService.createFilter(request.draft);
+            this.host.emit({
+                type: "ingestion/filter/create/response",
+                payload: { requestId: request.requestId, filter, error: null },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    /**
+     * A missing filter emits `filter: null` with `error: null`. That pairing is
+     * the message: "no such filter" is a real answer and renders as "that filter
+     * is gone", where a non-null error would render as "paseo is broken".
+     */
+    async handleIngestionFilterUpdateRequest(request) {
+        try {
+            const filter = await this.ingestionService.updateFilter(request.filterId, request.patch);
+            this.host.emit({
+                type: "ingestion/filter/update/response",
+                payload: { requestId: request.requestId, filter, error: null },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+    async handleIngestionFilterDeleteRequest(request) {
+        try {
+            const removed = await this.ingestionService.deleteFilter(request.filterId);
+            this.host.emit({
+                type: "ingestion/filter/delete/response",
+                payload: {
+                    requestId: request.requestId,
+                    filterId: request.filterId,
+                    removed,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitSourceRpcError(request, error);
+        }
+    }
+}
+//# sourceMappingURL=source-session.js.map

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 paseo.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 { readPaseoConfigForEdit, writePaseoConfigForEdit, } from "../../../utils/paseo-config-file.js";
+/**
+ * A client's read/write surface for a project's on-disk paseo.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 = readPaseoConfigForEdit(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 = writePaseoConfigForEdit({
+            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,105 @@
+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[]>;
+    /**
+     * Re-read `agents.providers` from config.json into the live registry. Owned by
+     * the shell because it also has to push the rebuilt registry into AgentManager,
+     * which is outside the provider-catalog domain.
+     */
+    reloadProviderConfigFromDisk(): ProviderReloadSummary;
+}
+/** Diff + resulting provider list from a config reload. Never carries `env`. */
+export interface ProviderReloadSummary {
+    added: string[];
+    updated: string[];
+    removed: string[];
+    unchanged: string[];
+    providers: Array<{
+        provider: string;
+        label: string;
+        enabled: boolean;
+    }>;
+    /**
+     * Custom providers left out of the rebuilt registry because their entry could
+     * not be resolved. Reported rather than swallowed: a skip that only reached the
+     * daemon log would look, from the CLI, exactly like a provider that reloaded
+     * fine.
+     */
+    skipped: Array<{
+        provider: string;
+        reason: string;
+    }>;
+}
+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>;
+    handleProvidersReloadConfigRequest(msg: Extract<SessionInboundMessage, {
+        type: "providers.reload_config.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