@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/session/daemon/install-origin.js

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { isRealpathInsideRoot } from "../../../utils/path.js";
+import { PASEO_CLI_PACKAGE } from "./npm-global-cli.js";
+const PackageJsonSchema = z.object({ name: z.string().optional() }).passthrough();
+export const daemonInstallOriginRuntime = {
+    resolveCurrentServerPackageRoot,
+};
+export function validateDaemonInstallOrigin(install, daemonVersion, runtime = daemonInstallOriginRuntime) {
+    if (install.isLinked) {
+        return `The global ${PASEO_CLI_PACKAGE} install is linked; self-update only supports normal npm global installs.`;
+    }
+    if (daemonVersion && install.version !== daemonVersion) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install (global npm has ${install.version}, daemon is ${daemonVersion}).`;
+    }
+    const currentServerPackageRoot = runtime.resolveCurrentServerPackageRoot();
+    if (!currentServerPackageRoot) {
+        return "Unable to verify that this daemon is running from an npm global install.";
+    }
+    if (!isCurrentServerUnderNpmInstall(currentServerPackageRoot, install)) {
+        return `This daemon is not running from the npm global ${PASEO_CLI_PACKAGE} install.`;
+    }
+    return null;
+}
+function isCurrentServerUnderNpmInstall(currentServerPackageRoot, install) {
+    const roots = install.globalRootPath
+        ? [install.packagePath, globalNodeModulesPath(install.globalRootPath)]
+        : [install.packagePath];
+    return roots.some((root) => isRealpathInsideRoot(root, currentServerPackageRoot));
+}
+function globalNodeModulesPath(globalRootPath) {
+    const normalized = path.normalize(globalRootPath);
+    return path.basename(normalized) === "node_modules"
+        ? normalized
+        : path.join(normalized, "node_modules");
+}
+function resolveCurrentServerPackageRoot() {
+    return resolvePackageRootFrom(fileURLToPath(import.meta.url), "@hyperdrive.bot/fleet-server");
+}
+function resolvePackageRootFrom(startPath, packageName) {
+    let currentDir = path.dirname(startPath);
+    while (true) {
+        const packageJsonPath = path.join(currentDir, "package.json");
+        if (existsSync(packageJsonPath)) {
+            try {
+                const packageJson = PackageJsonSchema.parse(JSON.parse(readFileSync(packageJsonPath, "utf8")));
+                if (packageJson.name === packageName) {
+                    return currentDir;
+                }
+            }
+            catch {
+                return null;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+//# sourceMappingURL=install-origin.js.map

package/dist/server/server/session/daemon/npm-global-cli.d.ts

@@ -0,0 +1,29 @@
+export declare const PASEO_CLI_PACKAGE = "@hyperdrive.bot/fleet-cli";
+export interface CommandOptions {
+    timeout?: number;
+    maxBuffer?: number;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface NpmGlobalPaseoInstall {
+    version: string;
+    packagePath: string;
+    globalRootPath: string | null;
+    isLinked: boolean;
+}
+export interface NpmGlobalPaseoCli {
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export type CommandRunner = (command: string, args: string[], options?: CommandOptions) => Promise<CommandResult>;
+export declare class DefaultNpmGlobalPaseoCli implements NpmGlobalPaseoCli {
+    private readonly runCommand;
+    constructor(runCommand?: CommandRunner);
+    inspect(): Promise<NpmGlobalPaseoInstall>;
+    installLatest(): Promise<CommandResult>;
+}
+export declare const npmGlobalPaseoCli: DefaultNpmGlobalPaseoCli;
+//# sourceMappingURL=npm-global-cli.d.ts.map

package/dist/server/server/session/daemon/npm-global-cli.js

@@ -0,0 +1,98 @@
+import { getErrorMessage } from "@hyperdrive.bot/fleet-protocol/error-utils";
+import { z } from "zod";
+import { execCommand } from "../../../utils/spawn.js";
+export const PASEO_CLI_PACKAGE = "@hyperdrive.bot/fleet-cli";
+const NPM_PROBE_TIMEOUT_MS = 10000;
+const NPM_INSTALL_TIMEOUT_MS = 300000;
+const NPM_MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+const NpmGlobalListSchema = z
+    .object({
+    path: z.string().optional(),
+    dependencies: z.record(z.string(), z.unknown()).optional(),
+})
+    .passthrough();
+const NpmGlobalCliPackageSchema = z
+    .object({
+    version: z.string(),
+    path: z.string(),
+    link: z.boolean().optional(),
+})
+    .passthrough();
+const CommandErrorSchema = z
+    .object({
+    code: z.union([z.number(), z.string()]).optional(),
+    stdout: z.string().optional(),
+    stderr: z.string().optional(),
+})
+    .passthrough();
+async function runExternalCommand(command, args, options) {
+    try {
+        const { stdout, stderr } = await execCommand(command, args, {
+            timeout: options?.timeout,
+            maxBuffer: options?.maxBuffer,
+        });
+        return { exitCode: 0, stdout, stderr };
+    }
+    catch (error) {
+        const parsed = CommandErrorSchema.safeParse(error);
+        if (!parsed.success) {
+            return { exitCode: 1, stdout: "", stderr: getErrorMessage(error) };
+        }
+        return {
+            exitCode: typeof parsed.data.code === "number" ? parsed.data.code : 1,
+            stdout: parsed.data.stdout ?? "",
+            stderr: parsed.data.stderr || getErrorMessage(error),
+        };
+    }
+}
+function parseNpmGlobalPaseoInstall(stdout) {
+    let parsedJson;
+    try {
+        parsedJson = JSON.parse(stdout);
+    }
+    catch {
+        return null;
+    }
+    const list = NpmGlobalListSchema.safeParse(parsedJson);
+    if (!list.success) {
+        return null;
+    }
+    const rawCliPackage = list.data.dependencies?.[PASEO_CLI_PACKAGE];
+    const cliPackage = NpmGlobalCliPackageSchema.safeParse(rawCliPackage);
+    if (!cliPackage.success) {
+        return null;
+    }
+    return {
+        version: cliPackage.data.version,
+        packagePath: cliPackage.data.path,
+        globalRootPath: list.data.path ?? null,
+        isLinked: cliPackage.data.link === true,
+    };
+}
+export class DefaultNpmGlobalPaseoCli {
+    constructor(runCommand = runExternalCommand) {
+        this.runCommand = runCommand;
+    }
+    async inspect() {
+        const result = await this.runCommand("npm", ["-g", "ls", PASEO_CLI_PACKAGE, "--json", "--depth=0", "--long"], {
+            timeout: NPM_PROBE_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+        if (result.exitCode !== 0 && result.stdout.trim().length === 0) {
+            throw new Error(result.stderr.trim() || "npm is not available on this host");
+        }
+        const install = parseNpmGlobalPaseoInstall(result.stdout);
+        if (!install) {
+            throw new Error(`${PASEO_CLI_PACKAGE} is not installed with npm -g on this host`);
+        }
+        return install;
+    }
+    installLatest() {
+        return this.runCommand("npm", ["install", "-g", `${PASEO_CLI_PACKAGE}@latest`], {
+            timeout: NPM_INSTALL_TIMEOUT_MS,
+            maxBuffer: NPM_MAX_BUFFER_BYTES,
+        });
+    }
+}
+export const npmGlobalPaseoCli = new DefaultNpmGlobalPaseoCli();
+//# sourceMappingURL=npm-global-cli.js.map

package/dist/server/server/session/files/workspace-files-session.d.ts

@@ -0,0 +1,53 @@
+import type pino from "pino";
+import type { FileTransferFrame } from "@hyperdrive.bot/fleet-protocol/binary-frames/index";
+import type { FileDownloadTokenRequest, FileExplorerRequest, FileUploadRequest, SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { DownloadTokenStore } from "../../file-download/token-store.js";
+/**
+ * What a workspace file-access request reaches outside its own domain: the
+ * outbound message channel (text + binary). `hasBinaryChannel` gates the
+ * binary file-explorer transfer path the same way the terminal subsystem does
+ * — old clients without a binary channel fall back to inline JSON file content.
+ */
+export interface WorkspaceFilesSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    emitBinary(frame: Uint8Array): void;
+    hasBinaryChannel(): boolean;
+}
+export interface WorkspaceFilesSessionOptions {
+    host: WorkspaceFilesSessionHost;
+    downloadTokenStore: DownloadTokenStore;
+    paseoHome: string;
+    logger: pino.Logger;
+}
+/**
+ * A client's workspace file-access surface: browsing directories, reading file
+ * contents (inline JSON or binary frames), receiving uploads, issuing download
+ * tokens, and reading project icons. It owns the upload store and reaches no
+ * workspace-git, registry, or subscription state — file I/O scoped to a cwd is
+ * the whole concern.
+ */
+export declare class WorkspaceFilesSession {
+    private readonly host;
+    private readonly downloadTokenStore;
+    private readonly logger;
+    private readonly fileUploads;
+    constructor(options: WorkspaceFilesSessionOptions);
+    handleFileExplorerRequest(request: FileExplorerRequest): Promise<void>;
+    /**
+     * Stream a file to the client as `FileBegin` → N × `FileChunk` → `FileEnd`.
+     *
+     * Uses positioned reads capped at `UPLOAD_CHUNK_SIZE_BYTES` per frame. The previous
+     * implementation read the whole file with `readExplorerFileBytes` and emitted it as a
+     * single `FileChunk`, which held the entire file in daemon memory and produced one
+     * oversized frame that head-of-line-blocked voice and terminal traffic on the shared
+     * socket. Callers must apply the size gate before calling this.
+     */
+    private streamFilePreview;
+    handleFileUploadRequest(request: FileUploadRequest): void;
+    handleFileTransferFrame(frame: FileTransferFrame): Promise<void>;
+    handleProjectIconRequest(request: Extract<SessionInboundMessage, {
+        type: "project_icon_request";
+    }>): Promise<void>;
+    handleFileDownloadTokenRequest(request: FileDownloadTokenRequest): Promise<void>;
+}
+//# sourceMappingURL=workspace-files-session.d.ts.map

package/dist/server/server/session/files/workspace-files-session.js

@@ -0,0 +1,245 @@
+import { getErrorMessage } from "@hyperdrive.bot/fleet-protocol/error-utils";
+import { FileUploadStore } from "../../file-upload/index.js";
+import { getDownloadableFileInfo, listDirectoryEntries, MAX_INLINE_PREVIEW_BYTES, openExplorerFileForDownload, readExplorerFile, readExplorerFileMetadata, } from "../../file-explorer/service.js";
+import { encodeFileDownloadFrames } from "../../file-explorer/file-download-frames.js";
+import { getProjectIcon } from "../../../utils/project-icon.js";
+/**
+ * A client's workspace file-access surface: browsing directories, reading file
+ * contents (inline JSON or binary frames), receiving uploads, issuing download
+ * tokens, and reading project icons. It owns the upload store and reaches no
+ * workspace-git, registry, or subscription state — file I/O scoped to a cwd is
+ * the whole concern.
+ */
+export class WorkspaceFilesSession {
+    constructor(options) {
+        this.host = options.host;
+        this.downloadTokenStore = options.downloadTokenStore;
+        this.logger = options.logger;
+        this.fileUploads = new FileUploadStore({ paseoHome: options.paseoHome });
+    }
+    async handleFileExplorerRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath = ".", mode, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            });
+            return;
+        }
+        try {
+            if (mode === "list") {
+                const directory = await listDirectoryEntries({
+                    root: cwd,
+                    relativePath: requestedPath,
+                });
+                this.host.emit({
+                    type: "file_explorer_response",
+                    payload: {
+                        cwd,
+                        path: directory.path,
+                        mode,
+                        directory,
+                        file: null,
+                        error: null,
+                        requestId,
+                    },
+                });
+            }
+            else {
+                if (request.acceptBinary && this.host.hasBinaryChannel()) {
+                    // Stat and classify before reading anything: a huge archive must not be
+                    // pulled into daemon memory just because someone tapped it in the explorer.
+                    const metadata = await readExplorerFileMetadata({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    if (metadata.kind !== "text" && metadata.size > MAX_INLINE_PREVIEW_BYTES) {
+                        // Too large to preview inline. The metadata-only response still carries an
+                        // honest mime and size, which is everything the client needs to render
+                        // "PDF document, 1.4 GB" with a download action. `legacyExplorerFileToBytes`
+                        // maps `encoding: "none"` to an empty byte array on the client.
+                        this.host.emit({
+                            type: "file_explorer_response",
+                            payload: {
+                                cwd,
+                                path: metadata.path,
+                                mode,
+                                directory: null,
+                                file: metadata,
+                                error: null,
+                                requestId,
+                            },
+                        });
+                        return;
+                    }
+                    await this.streamFilePreview({ cwd, relativePath: requestedPath, requestId });
+                }
+                else {
+                    const file = await readExplorerFile({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.host.emit({
+                        type: "file_explorer_response",
+                        payload: {
+                            cwd,
+                            path: file.path,
+                            mode,
+                            directory: null,
+                            file,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to fulfill file explorer request for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_explorer_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    mode,
+                    directory: null,
+                    file: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    /**
+     * Stream a file to the client as `FileBegin` → N × `FileChunk` → `FileEnd`.
+     *
+     * Uses positioned reads capped at `UPLOAD_CHUNK_SIZE_BYTES` per frame. The previous
+     * implementation read the whole file with `readExplorerFileBytes` and emitted it as a
+     * single `FileChunk`, which held the entire file in daemon memory and produced one
+     * oversized frame that head-of-line-blocked voice and terminal traffic on the shared
+     * socket. Callers must apply the size gate before calling this.
+     */
+    async streamFilePreview({ cwd, relativePath, requestId, }) {
+        const { handle, metadata } = await openExplorerFileForDownload({ root: cwd, relativePath });
+        try {
+            for await (const frame of encodeFileDownloadFrames({
+                requestId,
+                metadata,
+                read: (buf, offset, length, position) => handle.read(buf, offset, length, position),
+            })) {
+                this.host.emitBinary(frame);
+            }
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    handleFileUploadRequest(request) {
+        this.fileUploads.beginUpload(request);
+    }
+    async handleFileTransferFrame(frame) {
+        const response = await this.fileUploads.receiveFrame(frame);
+        if (response) {
+            this.host.emit(response);
+        }
+    }
+    async handleProjectIconRequest(request) {
+        const { cwd, requestId } = request;
+        try {
+            const icon = await getProjectIcon(cwd);
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "project_icon_response",
+                payload: {
+                    cwd,
+                    icon: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleFileDownloadTokenRequest(request) {
+        const { cwd: workspaceCwd, path: requestedPath, requestId } = request;
+        const cwd = workspaceCwd.trim();
+        if (!cwd) {
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd: workspaceCwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: "cwd is required",
+                    requestId,
+                },
+            });
+            return;
+        }
+        this.logger.debug({ cwd, path: requestedPath }, `Handling file download token request for workspace ${cwd} (${requestedPath})`);
+        try {
+            const info = await getDownloadableFileInfo({
+                root: cwd,
+                relativePath: requestedPath,
+            });
+            const entry = this.downloadTokenStore.issueToken({
+                path: info.path,
+                absolutePath: info.absolutePath,
+                fileName: info.fileName,
+                mimeType: info.mimeType,
+                size: info.size,
+            });
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: info.path,
+                    token: entry.token,
+                    fileName: entry.fileName,
+                    mimeType: entry.mimeType,
+                    size: entry.size,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error, cwd, path: requestedPath }, `Failed to issue download token for workspace ${cwd}`);
+            this.host.emit({
+                type: "file_download_token_response",
+                payload: {
+                    cwd,
+                    path: requestedPath,
+                    token: null,
+                    fileName: null,
+                    mimeType: null,
+                    size: null,
+                    error: getErrorMessage(error),
+                    requestId,
+                },
+            });
+        }
+    }
+}
+//# sourceMappingURL=workspace-files-session.js.map

package/dist/server/server/session/git-mutation/git-mutation-service.d.ts

@@ -0,0 +1,34 @@
+import type pino from "pino";
+import type { GitHubService } from "../../../services/github-service.js";
+import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+import type { WorkspaceGitService } from "../../workspace-git-service.js";
+/**
+ * The git branch / working-tree mutation primitives a client session performs on a
+ * workspace: switch to an existing branch, create a branch from a base, and force a
+ * snapshot refresh (plus optional GitHub cache invalidation) after any mutation.
+ *
+ * CheckoutSession (the branch/commit/merge commands), the worktree session-config
+ * builder, and the auto-naming + worktree-creation paths all funnel their git
+ * mutations through this one module, so the validate-ref → clean-tree → execute →
+ * refresh sequence lives in a single place instead of being smeared across the
+ * session as loose callbacks.
+ */
+export interface GitMutationService {
+    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
+    createBranchFromBase(params: {
+        cwd: string;
+        baseBranch: string;
+        newBranchName: string;
+    }): Promise<void>;
+    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
+        invalidateGithub?: boolean;
+    }): Promise<void>;
+}
+type GitMutationGitSource = Pick<WorkspaceGitService, "validateBranchRef" | "getSnapshot" | "hasLocalBranch">;
+export declare function createGitMutationService(deps: {
+    workspaceGitService: GitMutationGitSource;
+    github: Pick<GitHubService, "invalidate">;
+    logger: pino.Logger;
+}): GitMutationService;
+export {};
+//# sourceMappingURL=git-mutation-service.d.ts.map

package/dist/server/server/session/git-mutation/git-mutation-service.js

@@ -0,0 +1,71 @@
+import { getErrorMessage } from "@hyperdrive.bot/fleet-protocol/error-utils";
+import { checkoutResolvedBranch, } from "../../../utils/checkout-git.js";
+import { execCommand } from "../../../utils/spawn.js";
+import { assertSafeGitRef as assertWorktreeSafeGitRef } from "../../worktree-session.js";
+export function createGitMutationService(deps) {
+    const { workspaceGitService, github, logger } = deps;
+    function assertSafeGitRef(ref, label) {
+        if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+            throw new Error(`Invalid ${label}: ${ref}`);
+        }
+        assertWorktreeSafeGitRef(ref, label);
+    }
+    async function isWorkingTreeDirty(cwd) {
+        try {
+            const snapshot = await workspaceGitService.getSnapshot(cwd);
+            return snapshot.git.isDirty === true;
+        }
+        catch (error) {
+            throw new Error(`Unable to inspect git status for ${cwd}: ${getErrorMessage(error)}`, {
+                cause: error,
+            });
+        }
+    }
+    async function ensureCleanWorkingTree(cwd) {
+        const dirty = await isWorkingTreeDirty(cwd);
+        if (dirty) {
+            throw new Error("Working directory has uncommitted changes. Commit or stash before switching branches.");
+        }
+    }
+    async function notifyGitMutation(cwd, reason, options) {
+        if (options?.invalidateGithub) {
+            github.invalidate({ cwd });
+        }
+        try {
+            await workspaceGitService.getSnapshot(cwd, { force: true, reason });
+        }
+        catch (error) {
+            logger.warn({ err: error, cwd, reason }, "Failed to force-refresh workspace git snapshot after mutation");
+        }
+    }
+    return {
+        async checkoutExistingBranch(cwd, branch) {
+            assertSafeGitRef(branch, "branch");
+            const resolution = await workspaceGitService.validateBranchRef(cwd, branch);
+            if (resolution.kind === "not-found") {
+                throw new Error(`Branch not found: ${branch}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            const result = await checkoutResolvedBranch({ cwd, resolution });
+            await notifyGitMutation(cwd, "switch-branch", { invalidateGithub: true });
+            return result;
+        },
+        async createBranchFromBase({ cwd, baseBranch, newBranchName }) {
+            assertSafeGitRef(baseBranch, "base branch");
+            assertSafeGitRef(newBranchName, "new branch");
+            const baseResolution = await workspaceGitService.validateBranchRef(cwd, baseBranch);
+            if (baseResolution.kind === "not-found") {
+                throw new Error(`Base branch not found: ${baseBranch}`);
+            }
+            const exists = await workspaceGitService.hasLocalBranch(cwd, newBranchName);
+            if (exists) {
+                throw new Error(`Branch already exists: ${newBranchName}`);
+            }
+            await ensureCleanWorkingTree(cwd);
+            await execCommand("git", ["checkout", "-b", newBranchName, baseBranch], { cwd });
+            await notifyGitMutation(cwd, "create-branch");
+        },
+        notifyGitMutation,
+    };
+}
+//# sourceMappingURL=git-mutation-service.js.map

package/dist/server/server/session/ingestion/source-session.d.ts

@@ -0,0 +1,78 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { IngestionService } from "../../ingestion/service.js";
+/** What a source handler needs from the Session shell: somewhere to emit. */
+export interface SourceSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+export interface SourceSessionOptions {
+    host: SourceSessionHost;
+    ingestionService: IngestionService;
+    logger: pino.Logger;
+}
+/**
+ * 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 declare class SourceSession {
+    private readonly host;
+    private readonly ingestionService;
+    private readonly logger;
+    constructor(options: SourceSessionOptions);
+    /**
+     * 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.
+     */
+    private emitSourceRpcError;
+    handleSourceCatalogueRequest(request: Extract<SessionInboundMessage, {
+        type: "source/catalogue";
+    }>): Promise<void>;
+    handleSourceConnectRequest(request: Extract<SessionInboundMessage, {
+        type: "source/connect";
+    }>): Promise<void>;
+    handleSourceListRequest(request: Extract<SessionInboundMessage, {
+        type: "source/list";
+    }>): Promise<void>;
+    handleSourceCheckRequest(request: Extract<SessionInboundMessage, {
+        type: "source/check";
+    }>): Promise<void>;
+    /**
+     * 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.
+     */
+    handleIngestionFilterListRequest(request: Extract<SessionInboundMessage, {
+        type: "ingestion/filter/list";
+    }>): Promise<void>;
+    handleIngestionFilterCreateRequest(request: Extract<SessionInboundMessage, {
+        type: "ingestion/filter/create";
+    }>): Promise<void>;
+    /**
+     * 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".
+     */
+    handleIngestionFilterUpdateRequest(request: Extract<SessionInboundMessage, {
+        type: "ingestion/filter/update";
+    }>): Promise<void>;
+    handleIngestionFilterDeleteRequest(request: Extract<SessionInboundMessage, {
+        type: "ingestion/filter/delete";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=source-session.d.ts.map