@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/session-lifecycle-service.js

@@ -0,0 +1,242 @@
+import { validSessionEffort, validSessionOption, validSessionTitle } from '../util/node-operation-parsers.js';
+import { isPlainRecord } from '../util/node-operation-parsers.js';
+export class SessionLifecycleService {
+    options;
+    starts = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'session.metadata.update': (data) => this.updateMetadata(record(data)),
+            'session.pin.move': (data) => this.movePin(record(data)),
+            'session.create': (data) => this.create(record(data)),
+            'session.start': (data) => this.start(record(data)),
+            'session.config.update': (data) => this.updateConfiguration(record(data))
+        };
+    }
+    clear() {
+        this.starts.clear();
+    }
+    async updateMetadata(input) {
+        if (typeof input.sessionId !== 'string' ||
+            (input.customTitle !== undefined &&
+                input.customTitle !== null &&
+                typeof input.customTitle !== 'string') ||
+            (input.pinned !== undefined && typeof input.pinned !== 'boolean'))
+            throw new Error('SESSION_INVALID');
+        if (input.customTitle === null || input.customTitle?.trim().length === 0)
+            throw new Error('SESSION_TITLE_REQUIRED');
+        if (input.customTitle !== undefined && input.customTitle.trim().length > 160)
+            throw new Error('SESSION_TITLE_INVALID');
+        const current = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.createMetadataProjection(input.sessionId));
+        if (current === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const nativeCodexRename = this.options.runners.require(current.runner).usesRunnerTitleForRename() &&
+            current.externalSessionId !== null &&
+            input.customTitle !== undefined;
+        await this.options.projection.rename(current, {
+            ...(input.customTitle === undefined ? {} : { title: input.customTitle }),
+            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
+        });
+        const metadataTitle = nativeCodexRename ? null : input.customTitle;
+        const updated = this.options.runtime.updateSessionMetadata({
+            sessionId: current.id,
+            ...(metadataTitle === undefined ? {} : { customTitle: metadataTitle }),
+            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
+        });
+        return {
+            session: this.options.present(nativeCodexRename
+                ? this.options.runtime.setRunnerTitleFromNative(updated.id, input.customTitle ?? '')
+                : updated)
+        };
+    }
+    movePin(input) {
+        if (typeof input.sessionId !== 'string' ||
+            (input.direction !== 'up' && input.direction !== 'down'))
+            throw new Error('SESSION_PIN_MOVE_INVALID');
+        this.options.database().movePinnedSession(input.sessionId, input.direction);
+        return { moved: true };
+    }
+    create(input) {
+        const runner = this.options.runners.product(input.runner);
+        if (typeof input.workspaceId !== 'string' ||
+            runner === undefined ||
+            typeof input.cwd !== 'string' ||
+            input.cwd.length === 0 ||
+            (input.externalSessionId !== undefined && typeof input.externalSessionId !== 'string') ||
+            !validSessionTitle(input.title) ||
+            !validSessionOption(input.model) ||
+            !validSessionEffort(input.effort) ||
+            !validSessionOption(input.access))
+            throw new Error('SESSION_INVALID');
+        const database = this.options.database();
+        const workspace = database.getWorkspace(input.workspaceId);
+        if (workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const saved = database
+            .getRunnerDefaults()
+            .find((value) => value.runner === runner.name &&
+            this.options.runners.supportsConfiguration(value, workspace));
+        const fallback = runner.defaultConfiguration(workspace);
+        const configuration = {
+            runner: runner.name,
+            model: typeof input.model === 'string' ? input.model : (saved?.model ?? fallback.model),
+            effort: typeof input.effort === 'string' ? input.effort : (saved?.effort ?? fallback.effort),
+            access: typeof input.access === 'string' ? input.access : (saved?.access ?? fallback.access)
+        };
+        if (!this.options.runners.supportsConfiguration(configuration, workspace))
+            throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
+        const session = this.options.runtime.createAgentSession({
+            workspaceId: input.workspaceId,
+            runner: runner.name,
+            cwd: input.cwd,
+            ...(typeof input.externalSessionId === 'string'
+                ? { externalSessionId: input.externalSessionId }
+                : {}),
+            model: configuration.model,
+            effort: configuration.effort,
+            access: configuration.access,
+            ...(typeof input.title === 'string' ? { title: input.title } : {})
+        });
+        if (input.bootstrapOnly === true)
+            this.options.identity.markBootstrap(session.id);
+        database.saveRunnerDefaults(configuration);
+        if (input.bootstrapOnly !== true)
+            this.options.emitSession(session);
+        return { session: this.options.present(session) };
+    }
+    async updateConfiguration(input) {
+        if (typeof input.sessionId !== 'string' ||
+            typeof input.model !== 'string' ||
+            typeof input.effort !== 'string' ||
+            !validSessionEffort(input.effort) ||
+            typeof input.access !== 'string')
+            throw new Error('SESSION_INVALID');
+        const current = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.createMetadataProjection(input.sessionId));
+        if (current === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const configuration = {
+            runner: current.runner,
+            model: input.model,
+            effort: input.effort,
+            access: input.access
+        };
+        const workspace = this.options.database().getWorkspace(current.workspaceId);
+        if (workspace === undefined ||
+            !this.options.runners.supportsConfiguration(configuration, workspace))
+            throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
+        const session = this.options.runtime.updateAgentSessionConfiguration({
+            sessionId: current.id,
+            model: input.model,
+            effort: input.effort,
+            access: input.access
+        });
+        if (session.externalSessionId !== null)
+            this.options.database().saveNativeSessionMetadata({
+                runner: session.runner,
+                externalSessionId: session.externalSessionId,
+                workspaceId: session.workspaceId,
+                model: session.model,
+                effort: session.effort,
+                access: session.access
+            });
+        this.options.emitSession(session);
+        return { session: this.options.present(session) };
+    }
+    async start(input) {
+        if (typeof input.clientMessageId !== 'string' ||
+            input.clientMessageId.length === 0 ||
+            typeof input.content !== 'string' ||
+            input.content.length === 0)
+            throw new Error('MESSAGE_INVALID');
+        if (input.deferredCommands !== undefined &&
+            (!Array.isArray(input.deferredCommands) ||
+                input.deferredCommands.some((value) => !isPlainRecord(value) ||
+                    typeof value.commandId !== 'string' ||
+                    typeof value.input !== 'string')))
+            throw new Error('RUNNER_COMMAND_INVALID');
+        const startKey = `${input.workspaceId}\u0000${input.runner}\u0000${input.clientMessageId}`;
+        const existing = this.starts.get(startKey);
+        if (existing !== undefined)
+            return existing;
+        const start = this.startFresh(input);
+        this.starts.set(startKey, start);
+        try {
+            const result = await start;
+            while (this.starts.size > 512) {
+                const oldest = this.starts.keys().next().value;
+                if (oldest === undefined || oldest === startKey)
+                    break;
+                this.starts.delete(oldest);
+            }
+            return result;
+        }
+        catch (error) {
+            this.starts.delete(startKey);
+            throw error;
+        }
+    }
+    async startFresh(input) {
+        const created = (await this.options.execute('session.create', {
+            ...input,
+            bootstrapOnly: true
+        }));
+        const bootstrapId = created.session.id;
+        const identity = this.options.identity.wait(bootstrapId);
+        try {
+            if (Array.isArray(input.deferredCommands))
+                for (const value of input.deferredCommands)
+                    if (isPlainRecord(value))
+                        await this.options.execute('session.command.execute', {
+                            sessionId: bootstrapId,
+                            commandId: value.commandId,
+                            input: value.input,
+                            ...(input.secretEnvironment === undefined
+                                ? {}
+                                : { secretEnvironment: input.secretEnvironment })
+                        });
+            const interceptedId = this.options.interceptedSessionId(input.clientMessageId);
+            const messageSessionId = interceptedId ?? bootstrapId;
+            if (interceptedId !== undefined)
+                this.options.identity.promote(bootstrapId, interceptedId);
+            const message = (await this.options.execute('session.message', {
+                sessionId: messageSessionId,
+                clientMessageId: input.clientMessageId,
+                content: input.content,
+                ...(input.secretEnvironment === undefined
+                    ? {}
+                    : { secretEnvironment: input.secretEnvironment }),
+                ...(input.attachmentIds === undefined ? {} : { attachmentIds: input.attachmentIds })
+            }));
+            const nativeSessionId = await identity;
+            const session = this.options.runtime.getAgentSession(nativeSessionId);
+            const run = this.options.runtime.getRun(message.run.id);
+            if (session === undefined || run === undefined)
+                throw new Error('SESSION_START_FAILED');
+            return {
+                session: this.options.present(session),
+                run,
+                delivery: message.delivery,
+                idempotent: message.idempotent
+            };
+        }
+        catch (error) {
+            this.options.identity.reject(bootstrapId, 'SESSION_START_FAILED');
+            const promotedSessionId = await identity.catch(() => undefined);
+            if (promotedSessionId !== undefined)
+                try {
+                    this.options.runtime.removeAgentSession(promotedSessionId);
+                }
+                catch {
+                    // A started Run owns the promoted Session and finishes normally.
+                }
+            throw error;
+        }
+    }
+}
+function record(data) {
+    return data !== null && typeof data === 'object' ? data : {};
+}

package/dist/service/session-message-service.d.ts

@@ -0,0 +1,33 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { CommandStateStore } from '../runner-command-engine.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { WorkspaceUploadService } from './workspace-upload-service.js';
+import type { RunnerImageAttachment, RunAttachmentService } from './run-attachment-service.js';
+import type { RunnerInteractionService } from './runner-interaction-service.js';
+import type { WorkspaceQueueWorkbenchService } from './workspace-queue-workbench-service.js';
+interface SessionMessageServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly uploads: WorkspaceUploadService;
+    readonly attachments: RunAttachmentService;
+    readonly commands: CommandStateStore;
+    readonly queue: WorkspaceQueueWorkbenchService<RunnerImageAttachment>;
+    readonly interaction: RunnerInteractionService;
+    readonly runners: RunnerRegistry;
+    readonly resolve: (sessionId: string) => Promise<NodeAgentSession>;
+    readonly present: (session: NodeAgentSession) => unknown;
+    readonly emitSession: (session: NodeAgentSession) => void;
+    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
+    readonly channelToken: (sessionId: string) => string | undefined;
+}
+export declare class SessionMessageService {
+    private readonly options;
+    constructor(options: SessionMessageServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private message;
+    private persistAttachments;
+    private channelMessage;
+    private channelToken;
+}
+export {};

package/dist/service/session-message-service.js

@@ -0,0 +1,157 @@
+import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, sessionTitleFromFirstMessage, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
+import { parseSecretEnvironment } from '../util/secret-environment.js';
+export class SessionMessageService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'session.message': (data) => this.message(record(data)),
+            'session.channel.message': (data) => this.channelMessage(record(data)),
+            'session.channel.token': (data) => this.channelToken(record(data))
+        };
+    }
+    async message(input) {
+        if (typeof input.sessionId !== 'string' ||
+            typeof input.clientMessageId !== 'string' ||
+            input.clientMessageId.length === 0 ||
+            typeof input.content !== 'string' ||
+            input.content.length === 0)
+            throw new Error('MESSAGE_INVALID');
+        const inlineAttachments = parseMessageAttachments(input.attachments);
+        const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
+        const attachmentIds = parseComposerAttachmentIds(input.attachmentIds);
+        if (inlineAttachments.length > 0 && attachmentIds.length > 0)
+            throw new Error('MESSAGE_ATTACHMENTS_INVALID');
+        const session = this.options.runtime.setTemporaryTitleIfMissing((await this.options.resolve(input.sessionId)).id, sessionTitleFromFirstMessage(input.content));
+        this.options.emitSession(session);
+        const intent = input.deliveryIntent;
+        if (intent !== undefined &&
+            intent !== 'SEND' &&
+            intent !== 'QUEUE' &&
+            intent !== 'REPLACE_CURRENT')
+            throw new Error('MESSAGE_INVALID');
+        const existing = this.options.runtime.findMessageRun(session.id, input.clientMessageId);
+        if (existing !== undefined)
+            return {
+                session: this.options.present(session),
+                run: existing,
+                delivery: this.options.runtime.isQueuedRun(existing.id) ? 'QUEUED' : 'STARTED',
+                idempotent: true
+            };
+        const uploaded = await this.options.uploads.resolve(session.workspaceId, attachmentIds);
+        const attachments = attachmentIds.length === 0
+            ? inlineAttachments
+            : uploaded.map((attachment) => attachment.attachment);
+        const imageAttachments = attachments.filter(isImageAttachment);
+        const runnerImageAttachments = attachments.filter(isRunnerImageAttachment);
+        const active = this.options.runtime
+            .listRunsForSession(session.id)
+            .find((run) => run.status === 'STARTING' || run.status === 'RUNNING');
+        const replaceCurrentRun = intent === 'REPLACE_CURRENT' ? active : undefined;
+        const queueWasPaused = this.options.runtime.sessionQueue(session.id).paused;
+        const queuedBeforeCreate = this.options.runtime.hasActiveSessionLease(session.id) || intent === 'QUEUE';
+        const created = this.options.runtime.createMessageRun({
+            sessionId: session.id,
+            clientMessageId: input.clientMessageId,
+            content: input.content,
+            ...(attachments.length === 0 ? {} : { attachments })
+        });
+        if (!created.created)
+            return {
+                session: this.options.present(session),
+                run: created.run,
+                delivery: this.options.runtime.isQueuedRun(created.run.id) ? 'QUEUED' : 'STARTED',
+                idempotent: true
+            };
+        this.options.attachments.cache(created.run.id, imageAttachments);
+        let attachmentPaths;
+        try {
+            attachmentPaths = await this.persistAttachments(session, created.run.id, attachmentIds, attachments, uploaded);
+        }
+        catch (error) {
+            this.options.runtime.deleteQueuedRun(created.run.id);
+            this.options.attachments.clear(created.run.id);
+            throw error;
+        }
+        const runnerInput = withNonImageAttachmentPrompt(input.content, attachmentPaths);
+        this.options.runtime.updateQueuedMessage(created.run.id, runnerInput);
+        const planActive = this.options.commands
+            .list(session.id)
+            .some((state) => state.commandId === 'plan');
+        this.options.queue.remember({
+            runId: created.run.id,
+            sessionId: created.run.sessionId,
+            workspaceId: created.run.workspaceId,
+            runner: created.run.runner,
+            input: this.options.runners
+                .require(created.run.runner)
+                .prepareMessageInput(runnerInput, planActive ? 'plan' : 'default'),
+            attachments: runnerImageAttachments,
+            attachmentPaths,
+            cwd: session.cwd,
+            externalSessionId: session.externalSessionId,
+            model: session.model,
+            effort: session.effort,
+            access: session.access,
+            collaborationMode: planActive ? 'plan' : 'default',
+            secretEnvironment,
+            ...(this.options.runners.require(created.run.runner).serviceTier() === 'fast'
+                ? { serviceTier: 'fast' }
+                : {})
+        });
+        if (queueWasPaused && active === undefined && intent !== 'QUEUE')
+            this.options.runtime.prioritizeQueuedRun(created.run.id);
+        if (!queueWasPaused || intent !== 'QUEUE')
+            this.options.runtime.resumeSessionQueue(session.id);
+        this.options.emitQueue(session.workspaceId, session.id);
+        if (replaceCurrentRun !== undefined)
+            this.options.queue.replace(created.run.id, replaceCurrentRun.id);
+        else if (intent !== 'QUEUE' || !queuedBeforeCreate)
+            this.options.queue.schedule(session.id);
+        return {
+            session: this.options.present(session),
+            run: created.run,
+            delivery: replaceCurrentRun !== undefined ? 'RESTARTING' : queuedBeforeCreate ? 'QUEUED' : 'STARTED',
+            idempotent: false
+        };
+    }
+    async persistAttachments(session, runId, attachmentIds, attachments, uploaded) {
+        return [
+            ...uploaded
+                .filter(({ attachment }) => !isRunnerImageAttachment(attachment))
+                .map(({ path }) => path),
+            ...(await this.options.attachments.persistFiles(session.cwd, runId, attachmentIds.length === 0
+                ? attachments.filter((attachment) => !isRunnerImageAttachment(attachment))
+                : []))
+        ];
+    }
+    channelMessage(input) {
+        if (typeof input.sessionId !== 'string' ||
+            typeof input.token !== 'string' ||
+            typeof input.clientMessageId !== 'string' ||
+            typeof input.content !== 'string' ||
+            input.content.length === 0)
+            throw new Error('MESSAGE_INVALID');
+        const session = this.options.runtime.getAgentSession(input.sessionId);
+        if (session === undefined || session.channelToken !== input.token)
+            throw new Error('SESSION_CHANNEL_UNAVAILABLE');
+        return {
+            delivery: this.options.interaction.deliverChannel(session.runner, input.sessionId, input.clientMessageId, 'admin', input.token, input.content)
+        };
+    }
+    channelToken(input) {
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const token = this.options.channelToken(input.sessionId);
+        if (token === undefined)
+            throw new Error('SESSION_CHANNEL_UNAVAILABLE');
+        return { token };
+    }
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return value;
+}

package/dist/service/session-presentation-service.d.ts

@@ -0,0 +1,33 @@
+import type { NodeCapabilities, SessionActivityState, RunnerCommandState } from '@myagentroam/protocol';
+import type { CodexSessionControl } from '../codex-app-server.js';
+import type { NodeAgentSession, NodeDatabase } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { CommandStateStore } from '../runner-command-engine.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+export type PresentedSession = NodeAgentSession & {
+    readonly control: CodexSessionControl;
+    readonly activity: SessionActivityState;
+    readonly runtime: {
+        readonly level: CodexSessionControl['level'];
+        readonly capabilities: readonly string[];
+        readonly reasonCode: string | null;
+    };
+    readonly commandStates: readonly RunnerCommandState[];
+};
+interface SessionPresentationServiceOptions {
+    readonly database: () => NodeDatabase | undefined;
+    readonly runtime: NodeRuntimeState;
+    readonly commands: CommandStateStore;
+    readonly runners: RunnerRegistry;
+    readonly capabilities: () => NodeCapabilities;
+    readonly hasManagedActiveRun: (session: NodeAgentSession) => boolean;
+    readonly externalActivity: (sessionId: string) => SessionActivityState | undefined;
+    readonly projectionForNative: (session: NodeAgentSession) => NodeAgentSession | undefined;
+}
+export declare class SessionPresentationService {
+    private readonly options;
+    constructor(options: SessionPresentationServiceOptions);
+    present(session: NodeAgentSession): PresentedSession;
+    presentDiscovered(sessions: readonly NodeAgentSession[]): readonly PresentedSession[];
+}
+export {};

package/dist/service/session-presentation-service.js

@@ -0,0 +1,36 @@
+export class SessionPresentationService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    present(session) {
+        const database = this.options.database();
+        if (session.externalSessionId !== null && database !== undefined) {
+            const metadata = database.getNativeSessionMetadata(session.runner, session.externalSessionId, session.workspaceId);
+            if (metadata !== undefined)
+                session = { ...session, pinnedAt: metadata.pinnedAt, pinOrder: metadata.pinOrder };
+        }
+        const presentation = this.options.runners
+            .require(session.runner)
+            .presentSession(session, this.options.capabilities(), {
+            managedActive: this.options.hasManagedActiveRun(session),
+            externalActivity: this.options.externalActivity(session.id),
+            commandStates: this.options.commands.list(session.id)
+        });
+        return {
+            ...session,
+            ...presentation
+        };
+    }
+    presentDiscovered(sessions) {
+        return sessions.map((session) => {
+            const projected = this.options.projectionForNative(session);
+            if (projected === undefined)
+                return this.present(session);
+            const synchronized = session.runnerTitle === null
+                ? projected
+                : this.options.runtime.setRunnerTitleFromNative(projected.id, session.runnerTitle);
+            return this.present({ ...synchronized, lastActivityAt: session.lastActivityAt });
+        });
+    }
+}

package/dist/service/session-query-service.d.ts

@@ -0,0 +1,31 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { SessionContextService } from './session-context-service.js';
+import type { RunnerName } from '@myagentroam/protocol';
+export interface SessionQueryServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
+    readonly present: (session: NodeAgentSession) => unknown;
+    readonly history: (session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }) => Promise<unknown>;
+    readonly context: SessionContextService;
+    readonly discover: (runner: RunnerName, workspaceId?: string) => Promise<readonly NodeAgentSession[]>;
+    readonly workspaceIdForCwd: (cwd: string) => string | undefined;
+}
+export declare class SessionQueryService {
+    private readonly options;
+    constructor(options: SessionQueryServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private get;
+    private runs;
+    private turns;
+    private events;
+    private readContext;
+    private discover;
+    private requireSession;
+}

package/dist/service/session-query-service.js

@@ -0,0 +1,77 @@
+import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+export class SessionQueryService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'session.get': (data) => this.get(record(data)),
+            'session.runs': (data) => this.runs(record(data)),
+            'session.turns.list': (data) => this.turns(record(data)),
+            'session.events.read': (data) => this.events(record(data)),
+            'session.context.read': (data) => this.readContext(record(data)),
+            'session.discover': (data) => this.discover(record(data))
+        };
+    }
+    async get(input) {
+        return { session: this.options.present(await this.requireSession(input.sessionId)) };
+    }
+    async runs(input) {
+        const session = await this.requireSession(input.sessionId);
+        return { runs: this.options.runtime.listRunsForSession(session.id) };
+    }
+    async turns(input) {
+        const page = pageInput(input);
+        return this.options.history(await this.requireSession(input.sessionId), page);
+    }
+    events(input) {
+        const page = pageInput(input);
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_NOT_FOUND');
+        const session = this.options.runtime.getAgentSession(input.sessionId);
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        return this.options.runtime.listConversationItems({ sessionId: session.id, ...page });
+    }
+    async readContext(input) {
+        return this.options.context.read(await this.requireSession(input.sessionId));
+    }
+    async discover(input) {
+        const runner = this.options.runners.product(input.runner);
+        if (runner === undefined)
+            throw new Error('SESSION_INVALID');
+        const workspaceId = typeof input.workspaceId === 'string'
+            ? input.workspaceId
+            : typeof input.cwd === 'string'
+                ? this.options.workspaceIdForCwd(input.cwd)
+                : undefined;
+        if (runner.discoveryScope === 'WORKSPACE_REQUIRED' && workspaceId === undefined)
+            throw new Error('SESSION_INVALID');
+        const sessions = await this.options.discover(runner.name, workspaceId);
+        return { sessions: sessions.map((session) => this.options.present(session)) };
+    }
+    async requireSession(sessionId) {
+        if (typeof sessionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const session = this.options.runtime.getAgentSession(sessionId) ?? (await this.options.resolve(sessionId));
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        return session;
+    }
+}
+function pageInput(input) {
+    if ((input.cursor !== undefined && typeof input.cursor !== 'string') ||
+        (input.limit !== undefined &&
+            (!Number.isInteger(input.limit) ||
+                input.limit < 1 ||
+                input.limit > 500)))
+        throw new Error('EVENT_CURSOR_INVALID');
+    return {
+        ...(typeof input.cursor === 'string' ? { cursor: input.cursor } : {}),
+        ...(typeof input.limit === 'number' ? { limit: input.limit } : {})
+    };
+}
+function record(value) {
+    return isPlainRecord(value) ? value : {};
+}

package/dist/service/terminal-relay-state.d.ts

@@ -0,0 +1,6 @@
+export declare class TerminalRelayState {
+    readonly attachments: Map<string, {
+        readonly attachmentId: string;
+        readonly terminalId: string;
+    }>;
+}

package/dist/service/terminal-relay-state.js

@@ -0,0 +1,3 @@
+export class TerminalRelayState {
+    attachments = new Map();
+}

package/dist/service/terminal-service.d.ts

@@ -0,0 +1,12 @@
+import type { NodeDatabase } from '../database.js';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { TerminalManager } from '../terminal.js';
+export declare class TerminalService {
+    private readonly database;
+    private readonly terminalManager;
+    constructor(database: () => NodeDatabase, terminalManager: TerminalManager);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private open;
+    private close;
+    private authorizeAttach;
+}