@hyperdrive.bot/fleet-server 0.3.99

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

@@ -0,0 +1,720 @@
+import { ChatServiceError, parseMentionAgentIds, } from "../../chat/chat-service.js";
+import { notifyChatMentions, prepareChatMentionFanout } from "../../chat/chat-mentions.js";
+import { FleetService } from "../../fleet/fleet-service.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;
+        // The loop fleet is a zero-dependency reader over the super-repo; if the daemon
+        // did not inject one, self-provision a default (configurable via PASEO_FLEET_* env).
+        this.fleetService = options.fleetService ?? new FleetService();
+        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);
+        }
+    }
+    emitFleetRpcError(request, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error({ err: error, requestType: request.type }, "Fleet request failed");
+        this.host.emit({
+            type: "rpc_error",
+            payload: {
+                requestId: request.requestId,
+                requestType: request.type,
+                error: message,
+                code: "fleet_request_failed",
+            },
+        });
+    }
+    async handleFleetListRequest(request) {
+        try {
+            const loops = this.fleetService.list();
+            this.host.emit({
+                type: "fleet/list/response",
+                payload: {
+                    requestId: request.requestId,
+                    loops,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetInspectRequest(request) {
+        try {
+            const loop = this.fleetService.inspect(request.name);
+            this.host.emit({
+                type: "fleet/inspect/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetRunNowRequest(request) {
+        try {
+            const result = this.fleetService.runNow(request.name);
+            this.host.emit({
+                type: "fleet/run-now/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop: result.loop,
+                    started: result.started,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetPauseRequest(request) {
+        try {
+            const loop = this.fleetService.pause(request.name);
+            this.host.emit({
+                type: "fleet/pause/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetResumeRequest(request) {
+        try {
+            const loop = this.fleetService.resume(request.name);
+            this.host.emit({
+                type: "fleet/resume/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    /**
+     * Promote a loop to live, or demote it to dry-run.
+     *
+     * `changed: false` means the loop was already in that mode and nothing was written,
+     * which the UI reports as a no-op rather than a success so a stale toggle cannot look
+     * like it did something.
+     */
+    async handleFleetSetModeRequest(request) {
+        try {
+            const { loop, result } = this.fleetService.setMode(request.name, request.mode);
+            this.host.emit({
+                type: "fleet/set-mode/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop,
+                    previousMode: result?.previousMode ?? null,
+                    changed: result?.changed ?? false,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    /** A loop raising a typed question for a human. */
+    async handleFleetAskRequest(request) {
+        try {
+            const decision = this.fleetService.createDecision({
+                loopName: request.name,
+                kind: request.kind,
+                question: request.question,
+                posture: request.posture,
+                options: request.options,
+                runId: request.runId ?? null,
+                itemKey: request.itemKey ?? null,
+                evidence: request.evidence ?? null,
+                onExpiry: request.onExpiry ?? null,
+                expiresInMs: request.expiresInMs ?? null,
+            });
+            this.host.emit({
+                type: "fleet/ask/response",
+                payload: { requestId: request.requestId, decision, error: null },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    /** The decision inbox: what a loop is waiting on a person for. */
+    async handleFleetDecisionsRequest(request) {
+        try {
+            const decisions = this.fleetService.listDecisions(request.name, request.includeResolved ?? false);
+            this.host.emit({
+                type: "fleet/decisions/response",
+                payload: { requestId: request.requestId, decisions, error: null },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    /**
+     * Answer a decision. Attributed to a human, which is what distinguishes it from the
+     * same option being applied by the clock running out.
+     */
+    async handleFleetResolveDecisionRequest(request) {
+        try {
+            const decision = this.fleetService.resolveDecision(request.decisionId, request.optionId, {
+                kind: "human",
+            });
+            this.host.emit({
+                type: "fleet/resolve-decision/response",
+                payload: { requestId: request.requestId, decision, error: null },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetSetParamsRequest(request) {
+        try {
+            const { loop } = this.fleetService.setParams(request.name, request.values);
+            this.host.emit({
+                type: "fleet/set-params/response",
+                payload: { requestId: request.requestId, loop, error: null },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetCreateRequest(request) {
+        try {
+            const result = this.fleetService.create({
+                name: request.name,
+                description: request.description,
+                cron: request.cron,
+                action: request.action,
+                mode: request.mode ?? "dry-run",
+                ...(request.rails !== undefined ? { rails: request.rails } : {}),
+                ...(request.allowed !== undefined ? { allowed: request.allowed } : {}),
+            });
+            this.host.emit({
+                type: "fleet/create/response",
+                payload: {
+                    requestId: request.requestId,
+                    loop: result.loop,
+                    cronLine: result.cronLine,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+    async handleFleetExecutionsRequest(request) {
+        try {
+            const executions = await this.host.listLoopExecutions(request.name);
+            this.host.emit({
+                type: "fleet/executions/response",
+                payload: {
+                    requestId: request.requestId,
+                    executions,
+                    error: null,
+                },
+            });
+        }
+        catch (error) {
+            this.emitFleetRpcError(request, error);
+        }
+    }
+}
+//# sourceMappingURL=chat-schedule-loop-session.js.map