@getpaseo/server 0.1.98 → 0.1.99

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

@@ -0,0 +1,50 @@
+import type pino from "pino";
+import type { ProviderAvailability } from "../../agent/agent-manager.js";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+export interface DaemonRuntimeConfig {
+    listen: string | null;
+    appBaseUrl?: string;
+    relay: {
+        enabled: boolean;
+        endpoint: string;
+        publicEndpoint: string;
+        useTls: boolean;
+        publicUseTls: boolean;
+    } | null;
+}
+export interface DaemonSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+export interface DaemonSessionOptions {
+    host: DaemonSessionHost;
+    paseoHome: string;
+    serverId: string | undefined;
+    daemonVersion: string | undefined;
+    daemonRuntimeConfig: DaemonRuntimeConfig | undefined;
+    listProviderAvailability: () => Promise<ProviderAvailability[]>;
+    logger: pino.Logger;
+}
+/**
+ * A client's read surface for the daemon process itself: its runtime status
+ * (pid-lock start time, listen address, relay config, provider availability) and
+ * a fresh local pairing offer for connecting a new client. Owns the `daemon.*`
+ * RPCs. Reaches no state beyond the never-mutated runtime values injected at
+ * construction and the outbound channel.
+ */
+export declare class DaemonSession {
+    private readonly host;
+    private readonly paseoHome;
+    private readonly serverId;
+    private readonly daemonVersion;
+    private readonly daemonRuntimeConfig;
+    private readonly listProviderAvailability;
+    private readonly logger;
+    constructor(options: DaemonSessionOptions);
+    handleGetStatusRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.get_status.request";
+    }>): Promise<void>;
+    handleGetPairingOfferRequest(msg: Extract<SessionInboundMessage, {
+        type: "daemon.get_pairing_offer.request";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=daemon-session.d.ts.map

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

@@ -0,0 +1,98 @@
+import { getPidLockInfo } from "../../pid-lock.js";
+import { generateLocalPairingOffer } from "../../pairing-offer.js";
+/**
+ * A client's read surface for the daemon process itself: its runtime status
+ * (pid-lock start time, listen address, relay config, provider availability) and
+ * a fresh local pairing offer for connecting a new client. Owns the `daemon.*`
+ * RPCs. Reaches no state beyond the never-mutated runtime values injected at
+ * construction and the outbound channel.
+ */
+export class DaemonSession {
+    constructor(options) {
+        this.host = options.host;
+        this.paseoHome = options.paseoHome;
+        this.serverId = options.serverId;
+        this.daemonVersion = options.daemonVersion;
+        this.daemonRuntimeConfig = options.daemonRuntimeConfig;
+        this.listProviderAvailability = options.listProviderAvailability;
+        this.logger = options.logger;
+    }
+    async handleGetStatusRequest(msg) {
+        try {
+            const pidInfo = await getPidLockInfo(this.paseoHome);
+            const providers = (await this.listProviderAvailability()).map((p) => ({
+                provider: p.provider,
+                available: p.available,
+                error: p.error ?? null,
+            }));
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: pidInfo?.startedAt ?? null,
+                    listen: this.daemonRuntimeConfig?.listen ?? null,
+                    relay: this.daemonRuntimeConfig?.relay ?? null,
+                    providers,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon status request");
+            this.host.emit({
+                type: "daemon.get_status.response",
+                payload: {
+                    requestId: msg.requestId,
+                    serverId: this.serverId ?? "",
+                    version: this.daemonVersion ?? null,
+                    pid: process.pid,
+                    nodePath: process.execPath,
+                    startedAt: null,
+                    listen: null,
+                    relay: null,
+                    providers: [],
+                },
+            });
+        }
+    }
+    async handleGetPairingOfferRequest(msg) {
+        try {
+            const relay = this.daemonRuntimeConfig?.relay;
+            const pairing = await generateLocalPairingOffer({
+                paseoHome: this.paseoHome,
+                relayEnabled: relay?.enabled ?? true,
+                relayEndpoint: relay?.endpoint,
+                relayPublicEndpoint: relay?.publicEndpoint,
+                relayUseTls: relay?.useTls,
+                relayPublicUseTls: relay?.publicUseTls,
+                appBaseUrl: this.daemonRuntimeConfig?.appBaseUrl,
+                includeQr: true,
+                logger: this.logger,
+            });
+            this.host.emit({
+                type: "daemon.get_pairing_offer.response",
+                payload: {
+                    requestId: msg.requestId,
+                    url: pairing.url ?? "",
+                    qr: pairing.qr ?? null,
+                    relayEnabled: pairing.relayEnabled,
+                },
+            });
+        }
+        catch (error) {
+            this.logger.error({ err: error }, "Failed to handle daemon pairing offer request");
+            this.host.emit({
+                type: "rpc_error",
+                payload: {
+                    requestId: msg.requestId,
+                    requestType: "daemon.get_pairing_offer.request",
+                    error: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+}
+//# sourceMappingURL=daemon-session.js.map

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

@@ -0,0 +1,43 @@
+import type pino from "pino";
+import { type FileTransferFrame } from "@getpaseo/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>;
+    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,218 @@
+import { getErrorMessage } from "@getpaseo/protocol/error-utils";
+import { encodeFileTransferFrame, FileTransferOpcode, } from "@getpaseo/protocol/binary-frames/index";
+import { FileUploadStore } from "../../file-upload/index.js";
+import { getDownloadableFileInfo, listDirectoryEntries, readExplorerFile, readExplorerFileBytes, } from "../../file-explorer/service.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()) {
+                    const file = await readExplorerFileBytes({
+                        root: cwd,
+                        relativePath: requestedPath,
+                    });
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileBegin,
+                        requestId,
+                        metadata: {
+                            mime: file.mimeType,
+                            size: file.size,
+                            encoding: file.encoding,
+                            modifiedAt: file.modifiedAt,
+                        },
+                    }));
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileChunk,
+                        requestId,
+                        payload: file.bytes,
+                    }));
+                    this.host.emitBinary(encodeFileTransferFrame({
+                        opcode: FileTransferOpcode.FileEnd,
+                        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,
+                },
+            });
+        }
+    }
+    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/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,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