@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/session/agent-config/agent-config-session.d.ts

@@ -0,0 +1,50 @@
+import type pino from "pino";
+import type { AgentProviderNotice } from "../../agent/agent-sdk-types.js";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+export interface AgentConfigSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+}
+/**
+ * The per-agent config mutations this subsystem drives. The shell adapts these
+ * onto the live AgentManager (mode still routes through setAgentModeCommand);
+ * tests wire an in-memory fake. Mode and thinking yield a provider notice; model
+ * and feature do not.
+ */
+export interface AgentConfigOperations {
+    setMode(agentId: string, modeId: string): Promise<AgentProviderNotice | null>;
+    setModel(agentId: string, modelId: string | null): Promise<void>;
+    setFeature(agentId: string, featureId: string, value: unknown): Promise<void>;
+    setThinking(agentId: string, thinkingOptionId: string | null): Promise<AgentProviderNotice | null>;
+}
+export interface AgentConfigSessionOptions {
+    host: AgentConfigSessionHost;
+    operations: AgentConfigOperations;
+    logger: pino.Logger;
+}
+/**
+ * A client's per-agent config surface: set mode, model, feature, and thinking
+ * option. Each request shares one envelope — log, run the mutation, then emit the
+ * accepted response, or on failure emit an activity_log error frame followed by
+ * the rejected response. Reaches no state beyond the injected operations and the
+ * outbound channel.
+ */
+export declare class AgentConfigSession {
+    private readonly host;
+    private readonly operations;
+    private readonly logger;
+    constructor(options: AgentConfigSessionOptions);
+    handleSetAgentModeRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_mode_request";
+    }>): Promise<void>;
+    handleSetAgentModelRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_model_request";
+    }>): Promise<void>;
+    handleSetAgentFeatureRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_feature_request";
+    }>): Promise<void>;
+    handleSetAgentThinkingRequest(msg: Extract<SessionInboundMessage, {
+        type: "set_agent_thinking_request";
+    }>): Promise<void>;
+    private applyConfigChange;
+}
+//# sourceMappingURL=agent-config-session.d.ts.map

package/dist/server/server/session/agent-config/agent-config-session.js

@@ -0,0 +1,98 @@
+import { v4 as uuidv4 } from "uuid";
+import { getErrorMessage, getErrorMessageOr } from "@hyperdrive.bot/paseo-protocol/error-utils";
+/**
+ * A client's per-agent config surface: set mode, model, feature, and thinking
+ * option. Each request shares one envelope — log, run the mutation, then emit the
+ * accepted response, or on failure emit an activity_log error frame followed by
+ * the rejected response. Reaches no state beyond the injected operations and the
+ * outbound channel.
+ */
+export class AgentConfigSession {
+    constructor(options) {
+        this.host = options.host;
+        this.operations = options.operations;
+        this.logger = options.logger;
+    }
+    handleSetAgentModeRequest(msg) {
+        const { agentId, modeId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_mode_request",
+            logFields: { agentId, modeId, requestId },
+            failureText: "Failed to set agent mode",
+            run: () => this.operations.setMode(agentId, modeId),
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_mode_response", payload }),
+        });
+    }
+    handleSetAgentModelRequest(msg) {
+        const { agentId, modelId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_model_request",
+            logFields: { agentId, modelId, requestId },
+            failureText: "Failed to set agent model",
+            run: async () => {
+                await this.operations.setModel(agentId, modelId);
+                return undefined;
+            },
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_model_response", payload }),
+        });
+    }
+    handleSetAgentFeatureRequest(msg) {
+        const { agentId, featureId, value, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_feature_request",
+            logFields: { agentId, featureId, value, requestId },
+            failureText: "Failed to set agent feature",
+            run: async () => {
+                await this.operations.setFeature(agentId, featureId, value);
+                return undefined;
+            },
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_feature_response", payload }),
+        });
+    }
+    handleSetAgentThinkingRequest(msg) {
+        const { agentId, thinkingOptionId, requestId } = msg;
+        return this.applyConfigChange({
+            agentId,
+            requestId,
+            logLabel: "set_agent_thinking_request",
+            logFields: { agentId, thinkingOptionId, requestId },
+            failureText: "Failed to set agent thinking option",
+            run: () => this.operations.setThinking(agentId, thinkingOptionId),
+            emitResponse: (payload) => this.host.emit({ type: "set_agent_thinking_response", payload }),
+        });
+    }
+    async applyConfigChange(change) {
+        const { agentId, requestId, logLabel, logFields, failureText, run, emitResponse } = change;
+        this.logger.info(logFields, `session: ${logLabel}`);
+        try {
+            const notice = await run();
+            this.logger.info(logFields, `session: ${logLabel} success`);
+            emitResponse({ requestId, agentId, accepted: true, error: null, notice });
+        }
+        catch (error) {
+            this.logger.error({ err: error, ...logFields }, `session: ${logLabel} error`);
+            this.host.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `${failureText}: ${getErrorMessage(error)}`,
+                },
+            });
+            emitResponse({
+                requestId,
+                agentId,
+                accepted: false,
+                error: getErrorMessageOr(error, failureText),
+            });
+        }
+    }
+}
+//# sourceMappingURL=agent-config-session.js.map

package/dist/server/server/session/agent-updates/agent-updates-service.d.ts

@@ -0,0 +1,59 @@
+import type pino from "pino";
+import type { AgentSnapshotPayload, ProjectPlacementPayload, SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import type { StoredAgentRecord } from "../../agent/agent-storage.js";
+type AgentUpdatesFilter = NonNullable<Extract<SessionInboundMessage, {
+    type: "fetch_agents_request";
+}>["filter"]>;
+/**
+ * Owns the single per-client `agent_update` subscription: when a client subscribes
+ * via `fetch_agents_request`, every later agent lifecycle change (live forward,
+ * stored-record archive/detach, delete) is filtered against the subscription's
+ * filter and either emitted or — while the initial snapshot is still being built —
+ * buffered and replayed on flush. Keeping the mutable subscription state, the
+ * bootstrap buffer, the provider-visibility gate, and the filter predicate behind
+ * one interface stops the rest of session.ts from poking the subscription shape or
+ * hand-rolling `agent_update` payloads, and the (previously untested) filter/buffer/
+ * flush branches become exercisable through injected fakes.
+ *
+ * The snapshot listing path applies the SAME filter via the pure
+ * `matchesAgentUpdatesFilter` so a subscription's initial page and its live updates
+ * stay consistent.
+ */
+export interface AgentUpdatesService {
+    beginSubscription(input: {
+        subscriptionId: string;
+        filter?: AgentUpdatesFilter;
+    }): void;
+    flushBootstrapped(subscriptionId: string, options?: {
+        snapshotUpdatedAtByAgentId?: Map<string, number>;
+    }): void;
+    clearSubscription(subscriptionId: string): void;
+    hasSubscription(): boolean;
+    forwardLiveAgent(agent: ManagedAgent): Promise<void>;
+    emitStoredRecord(record: StoredAgentRecord): Promise<AgentSnapshotPayload>;
+    removeAgent(agentId: string): void;
+    dispose(): void;
+}
+export interface AgentUpdatesServiceDeps {
+    emit(message: SessionOutboundMessage): void;
+    buildAgentPayload(agent: ManagedAgent): Promise<AgentSnapshotPayload>;
+    buildStoredAgentPayload(record: StoredAgentRecord): AgentSnapshotPayload;
+    isProviderVisibleToClient(provider: string): boolean;
+    buildProjectPlacementForWorkspaceId(workspaceId: string): Promise<ProjectPlacementPayload | null>;
+    emitWorkspaceUpdateForWorkspaceId(workspaceId: string): Promise<void>;
+    logger: pino.Logger;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export declare function matchesAgentUpdatesFilter(input: {
+    agent: AgentSnapshotPayload;
+    project: ProjectPlacementPayload;
+    filter?: AgentUpdatesFilter;
+}): boolean;
+export declare function createAgentUpdatesService(deps: AgentUpdatesServiceDeps): AgentUpdatesService;
+export {};
+//# sourceMappingURL=agent-updates-service.d.ts.map

package/dist/server/server/session/agent-updates/agent-updates-service.js

@@ -0,0 +1,220 @@
+import { resolveEffectiveThinkingOptionId } from "../../agent/agent-projections.js";
+function agentThinkingOptionMatchesFilter(agent, filter) {
+    if (filter.thinkingOptionId === undefined) {
+        return true;
+    }
+    const expectedThinkingOptionId = resolveEffectiveThinkingOptionId({
+        configuredThinkingOptionId: filter.thinkingOptionId ?? null,
+    });
+    const resolvedThinkingOptionId = agent.effectiveThinkingOptionId ??
+        resolveEffectiveThinkingOptionId({
+            runtimeInfo: agent.runtimeInfo,
+            configuredThinkingOptionId: agent.thinkingOptionId ?? null,
+        });
+    return resolvedThinkingOptionId === expectedThinkingOptionId;
+}
+function matchesAgentStructuralFilter(agent, project, filter) {
+    if (filter.statuses && filter.statuses.length > 0) {
+        const statuses = new Set(filter.statuses);
+        if (!statuses.has(agent.status)) {
+            return false;
+        }
+    }
+    if (typeof filter.requiresAttention === "boolean") {
+        const requiresAttention = agent.requiresAttention ?? false;
+        if (requiresAttention !== filter.requiresAttention) {
+            return false;
+        }
+    }
+    if (filter.projectKeys && filter.projectKeys.length > 0) {
+        const projectKeys = new Set(filter.projectKeys.filter((item) => item.trim().length > 0));
+        if (projectKeys.size > 0 && !projectKeys.has(project.projectKey)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Pure predicate shared by the live subscription stream and the snapshot listing
+ * pager: does an agent (with its resolved project placement) satisfy a
+ * `fetch_agents` filter?
+ */
+export function matchesAgentUpdatesFilter(input) {
+    const { agent, project, filter } = input;
+    if (filter?.labels) {
+        const matchesLabels = Object.entries(filter.labels).every(([key, value]) => agent.labels[key] === value);
+        if (!matchesLabels) {
+            return false;
+        }
+    }
+    const includeArchived = filter?.includeArchived ?? false;
+    if (!includeArchived && agent.archivedAt) {
+        return false;
+    }
+    if (filter && !agentThinkingOptionMatchesFilter(agent, filter)) {
+        return false;
+    }
+    if (filter && !matchesAgentStructuralFilter(agent, project, filter)) {
+        return false;
+    }
+    return true;
+}
+function agentUpdateTargetId(update) {
+    return update.kind === "remove" ? update.agentId : update.agent.id;
+}
+export function createAgentUpdatesService(deps) {
+    let subscription = null;
+    function bufferOrEmit(sub, payload) {
+        if (payload.kind === "upsert" && !deps.isProviderVisibleToClient(payload.agent.provider)) {
+            return;
+        }
+        if (sub.isBootstrapping) {
+            sub.pendingUpdatesByAgentId.set(agentUpdateTargetId(payload), payload);
+            return;
+        }
+        deps.emit({
+            type: "agent_update",
+            payload,
+        });
+    }
+    function beginSubscription(input) {
+        subscription = {
+            subscriptionId: input.subscriptionId,
+            filter: input.filter,
+            isBootstrapping: true,
+            pendingUpdatesByAgentId: new Map(),
+        };
+    }
+    function flushBootstrapped(subscriptionId, options) {
+        if (!subscription || subscription.subscriptionId !== subscriptionId) {
+            return;
+        }
+        if (!subscription.isBootstrapping) {
+            return;
+        }
+        subscription.isBootstrapping = false;
+        const pending = Array.from(subscription.pendingUpdatesByAgentId.values());
+        subscription.pendingUpdatesByAgentId.clear();
+        for (const payload of pending) {
+            if (payload.kind === "upsert") {
+                const snapshotUpdatedAt = options?.snapshotUpdatedAtByAgentId?.get(payload.agent.id);
+                if (typeof snapshotUpdatedAt === "number") {
+                    const updateUpdatedAt = Date.parse(payload.agent.updatedAt);
+                    if (!Number.isNaN(updateUpdatedAt) && updateUpdatedAt <= snapshotUpdatedAt) {
+                        continue;
+                    }
+                }
+            }
+            deps.emit({
+                type: "agent_update",
+                payload,
+            });
+        }
+    }
+    function clearSubscription(subscriptionId) {
+        if (subscription && subscription.subscriptionId === subscriptionId) {
+            subscription = null;
+        }
+    }
+    function hasSubscription() {
+        return subscription !== null;
+    }
+    function removeAgent(agentId) {
+        if (!subscription) {
+            return;
+        }
+        bufferOrEmit(subscription, { kind: "remove", agentId });
+    }
+    async function emitStoredRecord(record) {
+        const payload = deps.buildStoredAgentPayload(record);
+        const sub = subscription;
+        if (!sub) {
+            return payload;
+        }
+        const project = payload.workspaceId
+            ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+            : null;
+        if (!project) {
+            bufferOrEmit(sub, {
+                kind: "remove",
+                agentId: payload.id,
+            });
+            return payload;
+        }
+        const matches = matchesAgentUpdatesFilter({
+            agent: payload,
+            project,
+            filter: sub.filter,
+        });
+        bufferOrEmit(sub, matches
+            ? {
+                kind: "upsert",
+                agent: payload,
+                project,
+            }
+            : {
+                kind: "remove",
+                agentId: payload.id,
+            });
+        return payload;
+    }
+    async function forwardLiveAgent(agent) {
+        try {
+            const sub = subscription;
+            const payload = await deps.buildAgentPayload(agent);
+            if (sub) {
+                const project = payload.workspaceId
+                    ? await deps.buildProjectPlacementForWorkspaceId(payload.workspaceId)
+                    : null;
+                if (!project) {
+                    bufferOrEmit(sub, {
+                        kind: "remove",
+                        agentId: payload.id,
+                    });
+                }
+                else {
+                    const matches = matchesAgentUpdatesFilter({
+                        agent: payload,
+                        project,
+                        filter: sub.filter,
+                    });
+                    if (matches) {
+                        bufferOrEmit(sub, {
+                            kind: "upsert",
+                            agent: payload,
+                            project,
+                        });
+                    }
+                    else {
+                        bufferOrEmit(sub, {
+                            kind: "remove",
+                            agentId: payload.id,
+                        });
+                    }
+                }
+            }
+            // A lifecycle change updates exactly the agent's owning workspace, never
+            // every workspace sharing its cwd. Ownership is the agent's workspaceId.
+            if (payload.workspaceId) {
+                await deps.emitWorkspaceUpdateForWorkspaceId(payload.workspaceId);
+            }
+        }
+        catch (error) {
+            deps.logger.error({ err: error }, "Failed to emit agent update");
+        }
+    }
+    function dispose() {
+        subscription = null;
+    }
+    return {
+        beginSubscription,
+        flushBootstrapped,
+        clearSubscription,
+        hasSubscription,
+        forwardLiveAgent,
+        emitStoredRecord,
+        removeAgent,
+        dispose,
+    };
+}
+//# sourceMappingURL=agent-updates-service.js.map

package/dist/server/server/session/chat/chat-schedule-loop-session.d.ts

@@ -0,0 +1,120 @@
+import type pino from "pino";
+import type { SessionInboundMessage, SessionOutboundMessage } from "../../messages.js";
+import type { StoredAgentRecord } from "../../agent/agent-storage.js";
+import type { ManagedAgent } from "../../agent/agent-manager.js";
+import { type FileBackedChatService } from "../../chat/chat-service.js";
+import type { LoopService } from "../../loop-service.js";
+import type { ScheduleService } from "../../schedule/service.js";
+/**
+ * The collaborators a chat command reaches that are NOT part of the chat/schedule/loop
+ * domain: the agent roster reads and the agent-message send used only by chat/post
+ * mention fanout. The Session shell owns the agent lifecycle; this subsystem orchestrates
+ * a notification through it but does not own it.
+ */
+export interface ChatScheduleLoopSessionHost {
+    emit(msg: SessionOutboundMessage): void;
+    listStoredAgents(): Promise<StoredAgentRecord[]>;
+    listLiveAgents(): ManagedAgent[];
+    resolveAgentIdentifier(identifier: string): Promise<{
+        ok: true;
+        agentId: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    sendAgentMessage(agentId: string, text: string): Promise<void>;
+}
+export interface ChatScheduleLoopSessionOptions {
+    host: ChatScheduleLoopSessionHost;
+    chatService: FileBackedChatService;
+    scheduleService: ScheduleService;
+    loopService: LoopService;
+    clientId: string;
+    logger: pino.Logger;
+}
+/**
+ * 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 declare class ChatScheduleLoopSession {
+    private readonly host;
+    private readonly chatService;
+    private readonly scheduleService;
+    private readonly loopService;
+    private readonly clientId;
+    private readonly logger;
+    constructor(options: ChatScheduleLoopSessionOptions);
+    private emitChatRpcError;
+    handleChatCreateRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/create";
+    }>): Promise<void>;
+    handleChatListRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/list";
+    }>): Promise<void>;
+    handleChatInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/inspect";
+    }>): Promise<void>;
+    handleChatDeleteRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/delete";
+    }>): Promise<void>;
+    handleChatPostRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/post";
+    }>): Promise<void>;
+    handleChatReadRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/read";
+    }>): Promise<void>;
+    handleChatWaitRequest(request: Extract<SessionInboundMessage, {
+        type: "chat/wait";
+    }>): Promise<void>;
+    private toScheduleSummary;
+    private emitScheduleRpcError;
+    handleScheduleCreateRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/create";
+    }>): Promise<void>;
+    handleScheduleListRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/list";
+    }>): Promise<void>;
+    handleScheduleInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/inspect";
+    }>): Promise<void>;
+    handleScheduleLogsRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/logs";
+    }>): Promise<void>;
+    handleSchedulePauseRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/pause";
+    }>): Promise<void>;
+    handleScheduleResumeRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/resume";
+    }>): Promise<void>;
+    handleScheduleDeleteRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/delete";
+    }>): Promise<void>;
+    handleScheduleRunOnceRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/run-once";
+    }>): Promise<void>;
+    handleScheduleUpdateRequest(request: Extract<SessionInboundMessage, {
+        type: "schedule/update";
+    }>): Promise<void>;
+    private emitLoopRpcError;
+    handleLoopRunRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/run";
+    }>): Promise<void>;
+    handleLoopListRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/list";
+    }>): Promise<void>;
+    handleLoopInspectRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/inspect";
+    }>): Promise<void>;
+    handleLoopLogsRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/logs";
+    }>): Promise<void>;
+    handleLoopStopRequest(request: Extract<SessionInboundMessage, {
+        type: "loop/stop";
+    }>): Promise<void>;
+}
+//# sourceMappingURL=chat-schedule-loop-session.d.ts.map