@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/node-upgrade-coordinator.js

@@ -0,0 +1,137 @@
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
+export class NodeUpgradeCoordinator {
+    requestPath;
+    activeRunCount;
+    onStatus;
+    onReady;
+    now;
+    status = { state: 'IDLE', updatedAt: Date.now() };
+    timer;
+    constructor(requestPath, activeRunCount, onStatus, onReady, now = Date.now) {
+        this.requestPath = requestPath;
+        this.activeRunCount = activeRunCount;
+        this.onStatus = onStatus;
+        this.onReady = onReady;
+        this.now = now;
+    }
+    snapshot() {
+        return this.status;
+    }
+    async loadResult(resultPath) {
+        try {
+            const result = JSON.parse(await readFile(resultPath, 'utf8'));
+            if (result['state'] === 'FAILED' && typeof result['errorCode'] === 'string')
+                this.update({
+                    state: 'FAILED',
+                    errorCode: result['errorCode'],
+                    updatedAt: typeof result['updatedAt'] === 'number' ? result['updatedAt'] : this.now()
+                });
+        }
+        catch {
+            // Missing or malformed historical result does not prevent Node startup.
+        }
+    }
+    request(data) {
+        const targetVersion = record(data).targetVersion;
+        if (typeof targetVersion !== 'string' || !STABLE_VERSION.test(targetVersion))
+            throw new Error('NODE_UPGRADE_VERSION_INVALID');
+        if (this.status.state !== 'IDLE' && this.status.state !== 'FAILED') {
+            if (this.status.targetVersion !== targetVersion)
+                throw new Error('NODE_UPGRADE_ALREADY_PENDING');
+            return { status: 'ALREADY_PENDING', targetVersion, activeRunCount: this.activeRunCount() };
+        }
+        this.update({
+            state: 'WAITING_FOR_RUNS',
+            targetVersion,
+            activeRunCount: this.activeRunCount(),
+            updatedAt: this.now()
+        });
+        this.timer = setInterval(() => void this.checkReadySafely(), 250);
+        void this.checkReadySafely();
+        return { status: 'ACCEPTED', targetVersion, activeRunCount: this.activeRunCount() };
+    }
+    cancel() {
+        if (this.status.state !== 'WAITING_FOR_RUNS')
+            throw new Error('NODE_UPGRADE_NOT_CANCELLABLE');
+        this.clearTimer();
+        this.update({ state: 'IDLE', updatedAt: this.now() });
+        return { cancelled: true };
+    }
+    blocks(operation) {
+        return (this.pending() &&
+            (operation === 'session.start' ||
+                operation === 'session.resume' ||
+                operation === 'session.message' ||
+                operation === 'session.command.execute' ||
+                operation === 'runner.command.execute' ||
+                operation === 'session.channel.message' ||
+                operation === 'workspace.queue.message.execute' ||
+                operation === 'terminal.open'));
+    }
+    pending() {
+        return this.status.state === 'WAITING_FOR_RUNS' || this.status.state === 'READY_TO_RESTART';
+    }
+    stop() {
+        this.clearTimer();
+    }
+    async checkReady() {
+        if (this.status.state !== 'WAITING_FOR_RUNS')
+            return;
+        const activeRunCount = this.activeRunCount();
+        if (activeRunCount > 0) {
+            if (this.status.activeRunCount !== activeRunCount)
+                this.update({ ...this.status, activeRunCount, updatedAt: this.now() });
+            return;
+        }
+        this.clearTimer();
+        const targetVersion = this.status.targetVersion;
+        this.update({
+            state: 'READY_TO_RESTART',
+            targetVersion,
+            activeRunCount: 0,
+            updatedAt: this.now()
+        });
+        const path = this.requestPath();
+        const temporary = `${path}.${process.pid}.tmp`;
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        await writeFile(temporary, `${JSON.stringify({ schemaVersion: 1, targetVersion, createdAt: this.now() })}\n`, { mode: 0o600 });
+        await rename(temporary, path).catch(async (error) => {
+            await rm(temporary, { force: true });
+            throw error;
+        });
+        this.onReady();
+    }
+    async checkReadySafely() {
+        try {
+            await this.checkReady();
+        }
+        catch {
+            this.clearTimer();
+            this.update({
+                state: 'FAILED',
+                targetVersion: this.status.targetVersion,
+                errorCode: 'NODE_UPGRADE_REQUEST_WRITE_FAILED',
+                updatedAt: this.now()
+            });
+        }
+    }
+    update(status) {
+        this.status = status;
+        this.onStatus(status);
+    }
+    clearTimer() {
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+}
+export function nodeUpgradeRequestPath(databasePath) {
+    return resolve(dirname(databasePath), 'upgrade-request.json');
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('NODE_UPGRADE_REQUEST_INVALID');
+    return value;
+}

package/dist/service/node-workspace-coordinator.d.ts

@@ -0,0 +1,32 @@
+import type { NodeEnvelope } from '@myagentroam/protocol';
+import type { NodeConfig } from '../config.js';
+import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { TerminalSummary } from '../terminal.js';
+import type { WorkspaceChangeService } from './workspace-change-service.js';
+import type { WorkspaceSessionService } from './workspace-session-service.js';
+import type { WorkspaceWatchService } from './workspace-watch-service.js';
+interface NodeWorkspaceCoordinatorOptions {
+    readonly config: () => NodeConfig | undefined;
+    readonly database: () => NodeDatabase | undefined;
+    readonly runtime: NodeRuntimeState;
+    readonly watches: WorkspaceWatchService;
+    readonly sessions: WorkspaceSessionService;
+    readonly changes: WorkspaceChangeService;
+    readonly emit: (workspaceId: string, topic: 'files' | 'changes', revision: number) => void;
+    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
+}
+/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+export declare class NodeWorkspaceCoordinator {
+    private readonly options;
+    constructor(options: NodeWorkspaceCoordinatorOptions);
+    require(workspaceId: unknown): NodeWorkspace;
+    clearWatches(workspaceId: string): void;
+    cachedSessions(workspaceId: string): Promise<readonly NodeAgentSession[]>;
+    invalidate(workspaceId: string): void;
+    invalidateChanges(workspaceId: string): void;
+    persistTerminal(summary: TerminalSummary): void;
+    inspect(envelope: NodeEnvelope): Promise<void>;
+    captureRunSnapshot(runId: string, cwd: string): Promise<void>;
+}
+export {};

package/dist/service/node-workspace-coordinator.js

@@ -0,0 +1,80 @@
+import { inspectWorkspace, readGitSummary } from '../workspace.js';
+/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+export class NodeWorkspaceCoordinator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    require(workspaceId) {
+        if (typeof workspaceId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const workspace = this.options.database()?.getWorkspace(workspaceId);
+        if (workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        return workspace;
+    }
+    clearWatches(workspaceId) {
+        this.options.watches.clear(workspaceId);
+    }
+    cachedSessions(workspaceId) {
+        return this.options.sessions.cached(workspaceId);
+    }
+    invalidate(workspaceId) {
+        this.options.changes.invalidate(workspaceId);
+        for (const topic of ['files', 'changes']) {
+            if (!this.options.watches.topicActive(workspaceId, topic))
+                continue;
+            this.options.emit(workspaceId, topic, this.options.watches.nextRevision(workspaceId));
+        }
+    }
+    invalidateChanges(workspaceId) {
+        this.options.changes.invalidate(workspaceId);
+    }
+    persistTerminal(summary) {
+        const database = this.options.database();
+        if (database === undefined)
+            return;
+        const value = {
+            id: summary.id,
+            workspaceId: summary.workspaceId,
+            profileId: summary.profileId,
+            state: summary.state,
+            exitCode: summary.exitCode,
+            rows: summary.rows,
+            cols: summary.cols,
+            latestSequence: summary.latestSequence,
+            createdAt: summary.createdAt,
+            updatedAt: summary.updatedAt
+        };
+        database.saveTerminalSession(value);
+    }
+    async inspect(envelope) {
+        const requestedPath = typeof envelope.payload === 'object' &&
+            envelope.payload !== null &&
+            'path' in envelope.payload
+            ? envelope.payload.path
+            : undefined;
+        const config = this.options.config();
+        if (typeof requestedPath !== 'string' || config === undefined) {
+            this.options.send('workspace.inspect.result', { error: 'WORKSPACE_INVALID' }, envelope.id);
+            return;
+        }
+        try {
+            const inspection = await inspectWorkspace(requestedPath, config.allowedRoots);
+            this.options.send('workspace.inspect.result', inspection, envelope.id);
+        }
+        catch {
+            this.options.send('workspace.inspect.result', { error: 'WORKSPACE_INVALID' }, envelope.id);
+        }
+    }
+    async captureRunSnapshot(runId, cwd) {
+        try {
+            const snapshot = await readGitSummary(cwd);
+            this.options.runtime.saveSnapshot(runId, snapshot);
+            this.options.send('workspace.snapshot', { runId, snapshot });
+        }
+        catch {
+            // Ordinary directories have no Git snapshot and keep the existing Run result.
+        }
+    }
+}

package/dist/service/run-attachment-service.d.ts

@@ -0,0 +1,37 @@
+import type { CodexComposerInput } from '../codex-app-server.js';
+import type { NodeAgentSession, NodeMessageAttachmentInput } from '../database.js';
+import type { NativeTranscriptImageAttachment } from '../native-session-history.js';
+import { AttachmentDomainState } from './attachment-domain-state.js';
+export interface CachedRunImages {
+    images: readonly NodeMessageAttachmentInput[];
+    expiresAt: number | undefined;
+    timer: NodeJS.Timeout | undefined;
+}
+export interface NativeImageSource {
+    readonly name: string;
+    readonly mime: string;
+    readonly path: string;
+}
+export type RunnerImageAttachment = NodeMessageAttachmentInput & {
+    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
+};
+export declare class RunAttachmentService {
+    private readonly nativeImageRoot;
+    readonly state: AttachmentDomainState<CachedRunImages, NativeImageSource>;
+    constructor(nativeImageRoot: (session: NodeAgentSession) => string | undefined);
+    materializeCodex(runId: string, attachments: readonly RunnerImageAttachment[]): Promise<readonly Extract<CodexComposerInput, {
+        readonly type: 'localImage';
+    }>[]>;
+    persistFiles(workspacePath: string, runId: string, attachments: readonly NodeMessageAttachmentInput[]): Promise<readonly string[]>;
+    cleanup(runId: string): void;
+    cache(runId: string, images: readonly NodeMessageAttachmentInput[]): void;
+    append(runId: string, images: readonly NodeMessageAttachmentInput[]): readonly Record<string, unknown>[];
+    read(runId: string, imageIndex: number): NodeMessageAttachmentInput | undefined;
+    registerNative(session: NodeAgentSession, images: readonly NativeTranscriptImageAttachment[]): readonly Record<string, unknown>[];
+    readNative(runId: string, imageIndex: number): Promise<(NativeImageSource & {
+        readonly dataBase64: string;
+    }) | undefined>;
+    expire(runId: string): void;
+    clear(runId: string): void;
+    dispose(): void;
+}

package/dist/service/run-attachment-service.js

@@ -0,0 +1,160 @@
+import { tmpdir } from 'node:os';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { lstat, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { AttachmentDomainState } from './attachment-domain-state.js';
+const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
+const IMAGE_CACHE_TTL_MS = 60 * 60_000;
+export class RunAttachmentService {
+    nativeImageRoot;
+    state = new AttachmentDomainState();
+    constructor(nativeImageRoot) {
+        this.nativeImageRoot = nativeImageRoot;
+    }
+    async materializeCodex(runId, attachments) {
+        if (attachments.length === 0)
+            return [];
+        const directory = await mkdtemp(join(tmpdir(), 'myagentroam-attachment-'));
+        this.state.runDirectories.set(runId, directory);
+        try {
+            return await Promise.all(attachments.map(async (attachment, index) => {
+                const extension = attachment.mime.slice('image/'.length).replace('jpeg', 'jpg');
+                const path = join(directory, `${index + 1}.${extension}`);
+                await writeFile(path, Buffer.from(attachment.dataBase64, 'base64'), { mode: 0o600 });
+                return { type: 'localImage', path };
+            }));
+        }
+        catch (error) {
+            this.cleanup(runId);
+            throw error;
+        }
+    }
+    async persistFiles(workspacePath, runId, attachments) {
+        if (attachments.length === 0)
+            return [];
+        const marDirectory = resolve(workspacePath, '.mar');
+        await mkdir(marDirectory, { recursive: true, mode: 0o700 });
+        const marMetadata = await lstat(marDirectory);
+        if (!marMetadata.isDirectory() || marMetadata.isSymbolicLink())
+            throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
+        const filesDirectory = join(marDirectory, 'temp-files');
+        await mkdir(filesDirectory, { recursive: true, mode: 0o700 });
+        const filesMetadata = await lstat(filesDirectory);
+        if (!filesMetadata.isDirectory() || filesMetadata.isSymbolicLink())
+            throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
+        const runDirectory = join(filesDirectory, runId);
+        await mkdir(runDirectory, { mode: 0o700 });
+        try {
+            await Promise.all(attachments.map((attachment) => writeFile(join(runDirectory, attachment.name), Buffer.from(attachment.dataBase64, 'base64'), { flag: 'wx', mode: 0o600 })));
+            return attachments.map((attachment) => `.mar/temp-files/${runId}/${attachment.name}`);
+        }
+        catch (error) {
+            await rm(runDirectory, { recursive: true, force: true });
+            throw error;
+        }
+    }
+    cleanup(runId) {
+        const directory = this.state.runDirectories.get(runId);
+        if (directory === undefined)
+            return;
+        this.state.runDirectories.delete(runId);
+        void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+    }
+    cache(runId, images) {
+        if (images.length === 0)
+            return;
+        this.clear(runId);
+        this.state.runImages.set(runId, { images, expiresAt: undefined, timer: undefined });
+    }
+    append(runId, images) {
+        if (images.length === 0)
+            return [];
+        const cached = this.state.runImages.get(runId);
+        const existing = cached?.images ?? [];
+        const imageIndex = existing.length;
+        const next = [...existing, ...images];
+        if (cached === undefined)
+            this.state.runImages.set(runId, { images: next, expiresAt: undefined, timer: undefined });
+        else
+            cached.images = next;
+        return images.map((image, index) => ({
+            name: image.name,
+            mime: image.mime,
+            byteSize: Buffer.byteLength(image.dataBase64, 'base64'),
+            runId,
+            imageIndex: imageIndex + index
+        }));
+    }
+    read(runId, imageIndex) {
+        const cached = this.state.runImages.get(runId);
+        if (cached === undefined)
+            return undefined;
+        if (cached.expiresAt !== undefined && cached.expiresAt <= Date.now()) {
+            this.clear(runId);
+            return undefined;
+        }
+        return cached.images[imageIndex];
+    }
+    registerNative(session, images) {
+        const root = this.nativeImageRoot(session);
+        if (root === undefined)
+            return [];
+        const runId = `native-history:${session.id}`;
+        const sources = this.state.nativeHistoryImages.get(runId) ?? [];
+        const attachments = [];
+        for (const image of images) {
+            if (image.localPath === undefined || !image.mime.startsWith('image/')) {
+                attachments.push({ name: image.name, mime: image.mime });
+                continue;
+            }
+            const path = resolve(image.localPath);
+            const relation = relative(root, path);
+            if (relation.length === 0 || relation.startsWith('..') || isAbsolute(relation)) {
+                attachments.push({ name: image.name, mime: image.mime });
+                continue;
+            }
+            let imageIndex = sources.findIndex((source) => source.path === path);
+            if (imageIndex < 0) {
+                imageIndex = sources.length;
+                sources.push({ name: image.name, mime: image.mime, path });
+            }
+            attachments.push({ name: image.name, mime: image.mime, runId, imageIndex });
+        }
+        if (sources.length > 0)
+            this.state.nativeHistoryImages.set(runId, sources);
+        return attachments;
+    }
+    async readNative(runId, imageIndex) {
+        const source = this.state.nativeHistoryImages.get(runId)?.[imageIndex];
+        if (source === undefined)
+            return undefined;
+        try {
+            const info = await lstat(source.path);
+            if (!info.isFile() || info.size <= 0 || info.size > MAX_ATTACHMENT_BYTES)
+                return undefined;
+            return { ...source, dataBase64: (await readFile(source.path)).toString('base64') };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    expire(runId) {
+        const cached = this.state.runImages.get(runId);
+        if (cached === undefined || cached.expiresAt !== undefined)
+            return;
+        cached.expiresAt = Date.now() + IMAGE_CACHE_TTL_MS;
+        cached.timer = setTimeout(() => this.clear(runId), IMAGE_CACHE_TTL_MS);
+    }
+    clear(runId) {
+        const cached = this.state.runImages.get(runId);
+        if (cached?.timer !== undefined)
+            clearTimeout(cached.timer);
+        this.state.runImages.delete(runId);
+    }
+    dispose() {
+        for (const runId of this.state.runDirectories.keys())
+            this.cleanup(runId);
+        for (const runId of this.state.runImages.keys())
+            this.clear(runId);
+        this.state.nativeHistoryImages.clear();
+    }
+}

package/dist/service/run-domain-state.d.ts

@@ -0,0 +1,4 @@
+export declare class RunDomainState {
+    readonly active: Set<string>;
+    readonly interruptRequested: Set<string>;
+}

package/dist/service/run-domain-state.js

@@ -0,0 +1,4 @@
+export class RunDomainState {
+    active = new Set();
+    interruptRequested = new Set();
+}

package/dist/service/run-event-service.d.ts

@@ -0,0 +1,31 @@
+import type { WorkbenchEventCategory } from '@myagentroam/protocol';
+import type { NodeAgentSession } from '../database.js';
+import type { FakeRunnerStatus } from '../fake-runner.js';
+import { NodeMetrics } from '../operational.js';
+import { NodeRuntimeState } from '../runtime-state.js';
+import { RunDomainState } from './run-domain-state.js';
+export interface RunEventServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly metrics: NodeMetrics;
+    readonly state: RunDomainState;
+    readonly isBootstrapSession: (sessionId: string) => boolean;
+    readonly presentSession: (session: NodeAgentSession) => unknown;
+    readonly rejectBootstrap: (sessionId: string, code: string) => void;
+    readonly emitWorkbench: (category: WorkbenchEventCategory, payload: unknown) => void;
+    readonly cleanupAttachments: (runId: string) => void;
+    readonly expireImages: (runId: string) => void;
+    readonly scheduleContextRefresh: (sessionId: string) => void;
+    readonly dispatchQueue: (sessionId: string) => Promise<void>;
+    readonly removeQueuedStart: (runId: string) => void;
+}
+export declare class RunEventService {
+    private readonly options;
+    private readonly sequences;
+    private readonly pendingText;
+    constructor(options: RunEventServiceOptions);
+    emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
+    clear(): void;
+    private enqueueText;
+    private flushText;
+    private emitNow;
+}

package/dist/service/run-event-service.js

@@ -0,0 +1,102 @@
+import { nodeLog } from '../operational.js';
+import { isPlainRecord, isTerminalRunStatus } from '../util/node-operation-parsers.js';
+const COALESCE_MS = 200;
+const MAX_BATCH_CHARS = 16_384;
+export class RunEventService {
+    options;
+    sequences = new Map();
+    pendingText = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    emit(runId, eventType, payload, status) {
+        if (eventType === 'text.delta' &&
+            status === undefined &&
+            isPlainRecord(payload) &&
+            typeof payload.text === 'string') {
+            this.enqueueText(runId, payload.text);
+            return;
+        }
+        this.flushText(runId);
+        this.emitNow(runId, eventType, payload, status);
+    }
+    clear() {
+        for (const pending of this.pendingText.values())
+            clearTimeout(pending.timer);
+        this.pendingText.clear();
+    }
+    enqueueText(runId, text) {
+        if (text.length === 0)
+            return;
+        const pending = this.pendingText.get(runId);
+        if (pending !== undefined) {
+            pending.text += text;
+            if (pending.text.length >= MAX_BATCH_CHARS)
+                this.flushText(runId);
+            return;
+        }
+        const timer = setTimeout(() => this.flushText(runId), COALESCE_MS);
+        this.pendingText.set(runId, { text, timer });
+    }
+    flushText(runId) {
+        const pending = this.pendingText.get(runId);
+        if (pending === undefined)
+            return;
+        clearTimeout(pending.timer);
+        this.pendingText.delete(runId);
+        this.emitNow(runId, 'text.delta', { text: pending.text });
+    }
+    emitNow(runId, eventType, payload, status) {
+        const event = {
+            runId,
+            sequence: (this.sequences.get(runId) ?? 0) + 1,
+            eventType,
+            payload,
+            ...(status === undefined ? {} : { status })
+        };
+        this.sequences.set(runId, event.sequence);
+        if (eventType !== 'text.delta')
+            nodeLog('run.event', { runId, eventType, status });
+        if (status === 'FAILED')
+            this.options.metrics.runnerFailed();
+        try {
+            this.options.runtime.appendRunEvent({
+                runId,
+                sequence: event.sequence,
+                eventType,
+                payload,
+                ...(status === undefined ? {} : { status })
+            });
+        }
+        catch {
+            /* A stale relayed run may race the storage boundary. */
+        }
+        if (status !== undefined && isTerminalRunStatus(status)) {
+            this.options.state.interruptRequested.delete(runId);
+            const terminalRun = this.options.runtime.getRun(runId);
+            if (terminalRun !== undefined && this.options.isBootstrapSession(terminalRun.sessionId))
+                this.options.rejectBootstrap(terminalRun.sessionId, 'SESSION_START_FAILED');
+        }
+        if (status !== undefined) {
+            const run = this.options.runtime.getRun(runId);
+            this.options.emitWorkbench('run', { run });
+            const session = run === undefined ? undefined : this.options.runtime.getAgentSession(run.sessionId);
+            if (session !== undefined)
+                this.options.emitWorkbench('session', { session: this.options.presentSession(session) });
+        }
+        this.options.emitWorkbench('conversation', { event });
+        if (status === undefined || !isTerminalRunStatus(status))
+            return;
+        const turn = this.options.runtime.conversationTurnForRun(runId);
+        if (turn !== undefined)
+            this.options.emitWorkbench('conversation', { turn });
+        this.options.cleanupAttachments(runId);
+        this.options.expireImages(runId);
+        this.options.removeQueuedStart(runId);
+        const run = this.options.runtime.getRun(runId);
+        if (run !== undefined) {
+            this.options.scheduleContextRefresh(run.sessionId);
+            void this.options.dispatchQueue(run.sessionId);
+        }
+    }
+}

package/dist/service/run-workbench-service.d.ts

@@ -0,0 +1,27 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+export interface RunWorkbenchServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly readImage: (runId: string, imageIndex: number) => Promise<unknown | undefined>;
+    readonly respondUserInput: (runId: string, requestId: string, answers: Record<string, unknown>) => void;
+    readonly deleteQueuedStart: (runId: string) => void;
+    readonly clearImages: (runId: string) => void;
+    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
+    readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'CANCELLED') => void;
+    readonly control: (operation: string, payload: Record<string, unknown>) => void;
+    readonly markInterrupted: (runId: string) => void;
+}
+export declare class RunWorkbenchService {
+    private readonly options;
+    constructor(options: RunWorkbenchServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private get;
+    private snapshot;
+    private image;
+    private respond;
+    private interruptSession;
+    private cancelOrInterrupt;
+    private approvals;
+    private decideApproval;
+    private requireRun;
+}