@getpaseo/server 0.1.97 → 0.1.99

package/dist/server/server/session/chat/chat-schedule-loop-session.js

@@ -0,0 +1,489 @@
+import { ChatServiceError, parseMentionAgentIds, } from "../../chat/chat-service.js";
+import { notifyChatMentions, prepareChatMentionFanout } from "../../chat/chat-mentions.js";
+/**
+ * A client's chat, schedule, and loop request surface. The three families are the
+ * least-coupled in the session: each is a stateless request/response over its own
+ * service (chat rooms, cron routines, autonomous loops), with no shared observer,
+ * git, or voice state and no subscriptions to tear down. They live in one subsystem
+ * because they are dispatched together — schedule/* was historically reached through
+ * the chat dispatcher's fall-through arm. The three rpc-error emitters stay separate:
+ * they differ by default code, and only the chat one reads ChatServiceError.code.
+ */
+export class ChatScheduleLoopSession {
+    constructor(options) {
+        this.host = options.host;
+        this.chatService = options.chatService;
+        this.scheduleService = options.scheduleService;
+        this.loopService = options.loopService;
+        this.clientId = options.clientId;
+        this.logger = options.logger;
+    }
+    emitChatRpcError(request, error) {
+        const message = error instanceof Error ? error.message : "Chat request failed";
+        const code = error instanceof ChatServiceError ? error.code : "chat_request_failed";
+        this.logger.error({ err: error, requestType: request.type }, "Chat request failed");
+        this.host.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code,
+            },
+        });
+    }
+    async handleChatCreateRequest(request) {
+        try {
+            const room = await this.chatService.createRoom({
+                name: request.name,
+                purpose: request.purpose,
+            });
+            this.host.emit({
+                type: "chat/create/response",
+                payload: {
+                    requestId: request.requestId,
+                    room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatListRequest(request) {
+        try {
+            const rooms = await this.chatService.listRooms();
+            this.host.emit({
+                type: "chat/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    rooms,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatInspectRequest(request) {
+        try {
+            const result = await this.chatService.inspectRoom({
+                room: request.room,
+            });
+            this.host.emit({
+                type: "chat/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    room: result.room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatDeleteRequest(request) {
+        try {
+            const result = await this.chatService.deleteRoom({
+                room: request.room,
+            });
+            this.host.emit({
+                type: "chat/delete/response",
+                payload: {
+                    requestId: request.requestId,
+                    room: result.room,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatPostRequest(request) {
+        try {
+            const authorAgentId = request.authorAgentId?.trim() || this.clientId;
+            const mentionAgentIds = parseMentionAgentIds(request.body);
+            const storedAgents = await this.host.listStoredAgents();
+            const liveAgents = this.host.listLiveAgents();
+            const fanout = await prepareChatMentionFanout({
+                authorAgentId,
+                mentionAgentIds,
+                storedAgents,
+                liveAgents,
+                listRoomPosterAgentIds: () => this.chatService.listRoomPosterAgentIds({ room: request.room }),
+            });
+            if (!fanout.ok) {
+                throw new ChatServiceError("chat_mention_fanout_limit_exceeded", fanout.error);
+            }
+            const message = await this.chatService.dispatchMessage({
+                room: request.room,
+                authorAgentId,
+                body: request.body,
+                replyToMessageId: request.replyToMessageId,
+            });
+            this.host.emit({
+                type: "chat/post/response",
+                payload: {
+                    requestId: request.requestId,
+                    message,
+                    error: null,
+                },
+            });
+            void notifyChatMentions({
+                room: request.room,
+                authorAgentId,
+                body: request.body,
+                mentionAgentIds: message.mentionAgentIds,
+                logger: this.logger,
+                storedAgents,
+                liveAgents,
+                prepared: fanout.prepared,
+                resolveAgentIdentifier: (identifier) => this.host.resolveAgentIdentifier(identifier),
+                sendAgentMessage: (agentId, text) => this.host.sendAgentMessage(agentId, text),
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatReadRequest(request) {
+        try {
+            const messages = await this.chatService.readMessages({
+                room: request.room,
+                limit: request.limit,
+                since: request.since,
+                authorAgentId: request.authorAgentId,
+            });
+            this.host.emit({
+                type: "chat/read/response",
+                payload: {
+                    requestId: request.requestId,
+                    messages,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    async handleChatWaitRequest(request) {
+        try {
+            const messages = await this.chatService.waitForMessages({
+                room: request.room,
+                afterMessageId: request.afterMessageId,
+                timeoutMs: request.timeoutMs,
+            });
+            this.host.emit({
+                type: "chat/wait/response",
+                payload: {
+                    requestId: request.requestId,
+                    messages,
+                    timedOut: messages.length === 0,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitChatRpcError(request, error);
+        }
+    }
+    toScheduleSummary(schedule) {
+        const { runs: _runs, ...summary } = schedule;
+        return summary;
+    }
+    emitScheduleRpcError(request, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error({ err: error, requestType: request.type }, "Schedule request failed");
+        this.host.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "schedule_request_failed",
+            },
+        });
+    }
+    async handleScheduleCreateRequest(request) {
+        try {
+            const target = request.target.type === "self"
+                ? { type: "agent", agentId: request.target.agentId }
+                : request.target;
+            const schedule = await this.scheduleService.create({
+                prompt: request.prompt,
+                name: request.name,
+                cadence: request.cadence,
+                target,
+                maxRuns: request.maxRuns,
+                expiresAt: request.expiresAt,
+                runOnCreate: request.runOnCreate,
+            });
+            this.host.emit({
+                type: "schedule/create/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleListRequest(request) {
+        try {
+            const schedules = await this.scheduleService.list();
+            this.host.emit({
+                type: "schedule/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedules: schedules.map((schedule) => this.toScheduleSummary(schedule)),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleInspectRequest(request) {
+        try {
+            const schedule = await this.scheduleService.inspect(request.scheduleId);
+            this.host.emit({
+                type: "schedule/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleLogsRequest(request) {
+        try {
+            const runs = await this.scheduleService.logs(request.scheduleId);
+            this.host.emit({
+                type: "schedule/logs/response",
+                payload: {
+                    requestId: request.requestId,
+                    runs,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleSchedulePauseRequest(request) {
+        try {
+            const schedule = await this.scheduleService.pause(request.scheduleId);
+            this.host.emit({
+                type: "schedule/pause/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleResumeRequest(request) {
+        try {
+            const schedule = await this.scheduleService.resume(request.scheduleId);
+            this.host.emit({
+                type: "schedule/resume/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule: this.toScheduleSummary(schedule),
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleDeleteRequest(request) {
+        try {
+            await this.scheduleService.delete(request.scheduleId);
+            this.host.emit({
+                type: "schedule/delete/response",
+                payload: {
+                    requestId: request.requestId,
+                    scheduleId: request.scheduleId,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleRunOnceRequest(request) {
+        try {
+            const schedule = await this.scheduleService.runOnce(request.scheduleId);
+            this.host.emit({
+                type: "schedule/run-once/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    async handleScheduleUpdateRequest(request) {
+        try {
+            const schedule = await this.scheduleService.update({
+                id: request.scheduleId,
+                ...(request.name !== undefined ? { name: request.name } : {}),
+                ...(request.prompt !== undefined ? { prompt: request.prompt } : {}),
+                ...(request.cadence !== undefined ? { cadence: request.cadence } : {}),
+                ...(request.newAgentConfig !== undefined ? { newAgentConfig: request.newAgentConfig } : {}),
+                ...(request.maxRuns !== undefined ? { maxRuns: request.maxRuns } : {}),
+                ...(request.expiresAt !== undefined ? { expiresAt: request.expiresAt } : {}),
+            });
+            this.host.emit({
+                type: "schedule/update/response",
+                payload: {
+                    requestId: request.requestId,
+                    schedule,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitScheduleRpcError(request, error);
+        }
+    }
+    emitLoopRpcError(request, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error({ err: error, requestType: request.type }, "Loop request failed");
+        this.host.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "loop_request_failed",
+            },
+        });
+    }
+    async handleLoopRunRequest(request) {
+        try {
+            const loop = await this.loopService.runLoop({
+                prompt: request.prompt,
+                cwd: request.cwd,
+                provider: request.provider,
+                model: request.model,
+                modeId: request.modeId,
+                workerProvider: request.workerProvider,
+                workerModel: request.workerModel,
+                verifierProvider: request.verifierProvider,
+                verifierModel: request.verifierModel,
+                verifierModeId: request.verifierModeId,
+                verifyPrompt: request.verifyPrompt,
+                verifyChecks: request.verifyChecks,
+                archive: request.archive,
+                name: request.name,
+                sleepMs: request.sleepMs,
+                maxIterations: request.maxIterations,
+                maxTimeMs: request.maxTimeMs,
+            });
+            this.host.emit({
+                type: "loop/run/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopListRequest(request) {
+        try {
+            const loops = await this.loopService.listLoops();
+            this.host.emit({
+                type: "loop/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    loops,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopInspectRequest(request) {
+        try {
+            const loop = await this.loopService.inspectLoop(request.id);
+            this.host.emit({
+                type: "loop/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopLogsRequest(request) {
+        try {
+            const result = await this.loopService.getLoopLogs(request.id, request.afterSeq ?? 0);
+            this.host.emit({
+                type: "loop/logs/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop: result.loop,
+                    entries: result.entries,
+                    nextCursor: result.nextCursor,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+    async handleLoopStopRequest(request) {
+        try {
+            const loop = await this.loopService.stopLoop(request.id);
+            this.host.emit({
+                type: "loop/stop/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitLoopRpcError(request, error);
+        }
+    }
+}
+//# sourceMappingURL=chat-schedule-loop-session.js.map

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

@@ -0,0 +1,142 @@
+import type pino from "pino";
+import type { BranchSuggestionsRequest, CheckoutRefreshRequest, CheckoutRenameBranchRequest, CheckoutStatusRequest, SessionInboundMessage, SessionOutboundMessage, SubscribeCheckoutDiffRequest, UnsubscribeCheckoutDiffRequest, ValidateBranchRequest } from "../../messages.js";
+import type { CheckoutDiffCompareInput, CheckoutDiffSnapshotPayload } from "../../checkout-diff-manager.js";
+import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitService } from "../../workspace-git-service.js";
+import { type GitHubService } from "../../../services/github-service.js";
+import { type CheckoutExistingBranchResult, type GitMutationRefreshReason } from "../../../utils/checkout-git.js";
+/**
+ * The collaborators a checkout command reaches that are NOT part of the checkout
+ * domain: the git-mutation refresh primitive and workspace-update emitters owned
+ * by the Session shell (also used by worktree/workspace creation), the injected
+ * branch operations, and the LLM-backed commit/PR text generators. CheckoutSession
+ * orchestrates them but does not own them.
+ */
+export interface CheckoutSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    notifyGitMutation(cwd: string, reason: GitMutationRefreshReason, options?: {
+        invalidateGithub?: boolean;
+    }): Promise<void>;
+    emitWorkspaceUpdateForCwd(cwd: string): Promise<void>;
+    handleWorkspaceGitBranchSnapshot(cwd: string, branchName: string | null): void;
+    renameCurrentBranch(cwd: string, branch: string): Promise<{
+        previousBranch: string | null;
+        currentBranch: string | null;
+    }>;
+    checkoutExistingBranch(cwd: string, branch: string): Promise<CheckoutExistingBranchResult>;
+    generateCommitMessage(cwd: string): Promise<string>;
+    generatePullRequestText(cwd: string, baseRef?: string): Promise<{
+        title: string;
+        body: string;
+    }>;
+}
+/**
+ * The slice of CheckoutDiffManager that CheckoutSession needs: open a live diff
+ * subscription, and nudge open subscriptions to recompute after a mutation. The
+ * real CheckoutDiffManager satisfies this structurally; tests supply a fake.
+ */
+export interface CheckoutDiffSubscriber {
+    subscribe(params: {
+        cwd: string;
+        compare: CheckoutDiffCompareInput;
+    }, listener: (snapshot: CheckoutDiffSnapshotPayload) => void): Promise<{
+        initial: CheckoutDiffSnapshotPayload;
+        unsubscribe: () => void;
+    }>;
+    scheduleRefreshForCwd(cwd: string): void;
+}
+export interface CheckoutSessionOptions {
+    host: CheckoutSessionHost;
+    workspaceGitService: WorkspaceGitService;
+    github: GitHubService;
+    checkoutDiffManager: CheckoutDiffSubscriber;
+    paseoHome: string;
+    worktreesRoot: string | undefined;
+    logger: pino.Logger;
+}
+/**
+ * A client's checkout view, both sides: the read & live-stream side (status
+ * queries, branch validation/suggestions, manual refresh, live git-diff and
+ * checkout-status subscriptions) and the command side (switch/rename/commit/
+ * merge/pull/push/stash and the GitHub-PR operations).
+ *
+ * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
+ * and refresh the workspace git snapshot through host.notifyGitMutation(); the
+ * workspace git observer streams branch changes through emitStatusUpdate().
+ */
+export declare class CheckoutSession {
+    private static readonly PASEO_STASH_PREFIX;
+    private readonly host;
+    private readonly workspaceGitService;
+    private readonly github;
+    private readonly checkoutDiffManager;
+    private readonly paseoHome;
+    private readonly worktreesRoot;
+    private readonly logger;
+    private readonly diffSubscriptions;
+    constructor(options: CheckoutSessionOptions);
+    handleStatusRequest(msg: CheckoutStatusRequest): Promise<void>;
+    handleValidateBranchRequest(msg: ValidateBranchRequest): Promise<void>;
+    handleBranchSuggestionsRequest(msg: BranchSuggestionsRequest): Promise<void>;
+    handleSubscribeDiffRequest(msg: SubscribeCheckoutDiffRequest): Promise<void>;
+    handleUnsubscribeDiffRequest(msg: UnsubscribeCheckoutDiffRequest): void;
+    handleRefreshRequest(msg: CheckoutRefreshRequest): Promise<void>;
+    emitStatusUpdate(cwd: string, snapshot: WorkspaceGitRuntimeSnapshot): void;
+    /**
+     * Notify the live diff subscriptions that the working tree at `cwd` changed.
+     * Called by the command handlers below after they mutate the repository.
+     */
+    private scheduleDiffRefresh;
+    handleCheckoutSwitchBranchRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_switch_branch_request";
+    }>): Promise<void>;
+    handleCheckoutRenameBranchRequest(msg: CheckoutRenameBranchRequest): Promise<void>;
+    handleStashSaveRequest(msg: Extract<SessionInboundMessage, {
+        type: "stash_save_request";
+    }>): Promise<void>;
+    handleStashPopRequest(msg: Extract<SessionInboundMessage, {
+        type: "stash_pop_request";
+    }>): Promise<void>;
+    handleStashListRequest(msg: Extract<SessionInboundMessage, {
+        type: "stash_list_request";
+    }>): Promise<void>;
+    handleCheckoutCommitRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_commit_request";
+    }>): Promise<void>;
+    handleCheckoutMergeRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_merge_request";
+    }>): Promise<void>;
+    handleCheckoutMergeFromBaseRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_merge_from_base_request";
+    }>): Promise<void>;
+    handleCheckoutPullRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_pull_request";
+    }>): Promise<void>;
+    handleCheckoutPushRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_push_request";
+    }>): Promise<void>;
+    handleCheckoutPrCreateRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_pr_create_request";
+    }>): Promise<void>;
+    handleCheckoutPrMergeRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_pr_merge_request";
+    }>): Promise<void>;
+    private assertCurrentPullRequestHasGithubMergeFacts;
+    handleCheckoutGithubSetAutoMergeRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout.github.set_auto_merge.request";
+    }>): Promise<void>;
+    private resolveCurrentPullRequest;
+    handleCheckoutPrStatusRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout_pr_status_request";
+    }>): Promise<void>;
+    handlePullRequestTimelineRequest(msg: Extract<SessionInboundMessage, {
+        type: "pull_request_timeline_request";
+    }>): Promise<void>;
+    handleCheckoutGithubGetCheckDetailsRequest(msg: Extract<SessionInboundMessage, {
+        type: "checkout.github.get_check_details.request";
+    }>): Promise<void>;
+    handleGitHubSearchRequest(msg: Extract<SessionInboundMessage, {
+        type: "github_search_request";
+    }>): Promise<void>;
+    cleanup(): void;
+}
+//# sourceMappingURL=checkout-session.d.ts.map