@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/node-control-channel.js

@@ -0,0 +1,85 @@
+import WebSocket from 'ws';
+import { createEnvelope } from '@myagentroam/protocol';
+import { ControlOutboundScheduler } from '../control-outbound-scheduler.js';
+import { nodeConnectEndpoint } from '../runner/codex/conversation-parser.js';
+export class NodeControlChannel {
+    options;
+    socket;
+    outbound = new ControlOutboundScheduler(() => this.socket);
+    reconnectTimer;
+    attempts = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    connect() {
+        const config = this.options.config();
+        if (config === undefined ||
+            this.options.stopped() ||
+            (this.socket !== undefined &&
+                (this.socket.readyState === WebSocket.OPEN ||
+                    this.socket.readyState === WebSocket.CONNECTING)))
+            return;
+        this.options.onConnecting(this.attempts);
+        const socket = new WebSocket(nodeConnectEndpoint(config.serverUrl));
+        this.socket = socket;
+        socket.once('open', () => {
+            this.attempts = 0;
+            if (config.nodeId !== undefined && config.credential !== undefined)
+                this.send('authenticate', { nodeId: config.nodeId, credential: config.credential });
+            else if (config.registrationToken !== undefined)
+                this.send('register', {
+                    registrationToken: config.registrationToken,
+                    capabilities: this.options.capabilities()
+                });
+            else
+                socket.close(4000, 'NODE_CREDENTIAL_MISSING');
+        });
+        socket.on('message', (raw) => this.options.onMessage(raw.toString()));
+        socket.once('close', (code, reason) => {
+            if (this.socket !== socket)
+                return;
+            this.socket = undefined;
+            this.outbound.reset();
+            const reasonText = reason.toString();
+            this.options.onClose(code, reasonText);
+            if (!(code === 4000 && reasonText === 'NODE_CONNECTION_REPLACED'))
+                this.scheduleReconnect();
+        });
+        socket.once('error', () => undefined);
+    }
+    connected() {
+        return this.socket?.readyState === WebSocket.OPEN;
+    }
+    /** Keeps transport injection at the transport boundary for contract tests. */
+    replaceSocketForTesting(socket) {
+        this.socket = socket;
+    }
+    close(code, reason) {
+        this.socket?.close(code, reason);
+    }
+    stop() {
+        if (this.reconnectTimer !== undefined)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = undefined;
+        this.outbound.reset();
+        this.socket?.close();
+        this.socket = undefined;
+    }
+    send(type, payload, replyTo) {
+        this.sendEnvelope(createEnvelope(type, payload, { ...(replyTo === undefined ? {} : { replyTo }) }));
+    }
+    sendEnvelope(envelope) {
+        if (!this.connected())
+            return;
+        this.outbound.enqueue(envelope, envelope.type === 'workbench.event' ? 'normal' : 'high');
+    }
+    scheduleReconnect() {
+        if (this.options.stopped() || !this.options.reconnect || this.reconnectTimer !== undefined)
+            return;
+        this.options.onReconnectScheduled();
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.connect();
+        }, this.options.reconnectDelay(this.attempts++));
+    }
+}

package/dist/service/node-control-message-service.d.ts

@@ -0,0 +1,28 @@
+import { type NodeEnvelope } from '@myagentroam/protocol';
+import type { NodeConfig } from '../config.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+interface NodeControlMessageServiceOptions {
+    readonly config: () => NodeConfig | undefined;
+    readonly register: (nodeId: string, credential: string) => Promise<void>;
+    readonly connected: () => void;
+    readonly close: (code: number, reason: string) => void;
+    readonly inspectWorkspace: (envelope: NodeEnvelope) => Promise<void>;
+    readonly handleNodeRequest: (envelope: NodeEnvelope) => Promise<void>;
+    readonly acknowledgeWorkbenchEvent: (replyTo: string | undefined) => void;
+    readonly reconcileRuns: (envelope: NodeEnvelope) => void;
+    readonly runners: RunnerRegistry;
+    readonly deliverSessionChannelMessage: (envelope: NodeEnvelope) => void;
+    readonly completeUncontrolledCancellation: (runId: string) => void;
+    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
+}
+/** Owns parsing and dispatch of the closed Node control-message protocol. */
+export declare class NodeControlMessageService {
+    private readonly options;
+    constructor(options: NodeControlMessageServiceOptions);
+    handle(raw: string): void;
+    private dispatch;
+    private register;
+    private decideApproval;
+    private cancelRun;
+}
+export {};

package/dist/service/node-control-message-service.js

@@ -0,0 +1,104 @@
+import { nodeEnvelopeSchema } from '@myagentroam/protocol';
+/** Owns parsing and dispatch of the closed Node control-message protocol. */
+export class NodeControlMessageService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    handle(raw) {
+        let envelope;
+        try {
+            envelope = nodeEnvelopeSchema.parse(JSON.parse(raw));
+        }
+        catch {
+            this.options.close(4002, 'MESSAGE_INVALID');
+            return;
+        }
+        this.dispatch(envelope);
+    }
+    dispatch(envelope) {
+        if (envelope.type === 'registered') {
+            this.register(envelope);
+            return;
+        }
+        if (envelope.type === 'authenticated') {
+            this.options.connected();
+            return;
+        }
+        if (envelope.type === 'workspace.inspect') {
+            void this.options.inspectWorkspace(envelope);
+            return;
+        }
+        if (envelope.type === 'node.request') {
+            void this.options.handleNodeRequest(envelope);
+            return;
+        }
+        if (envelope.type === 'ack') {
+            const payload = envelope.payload;
+            if (payload.type === 'workbench.event')
+                this.options.acknowledgeWorkbenchEvent(envelope.replyTo);
+            return;
+        }
+        if (envelope.type === 'runs.reconcile') {
+            this.options.reconcileRuns(envelope);
+            return;
+        }
+        if (envelope.type === 'run.approval.decision') {
+            this.decideApproval(envelope);
+            return;
+        }
+        if (envelope.type === 'run.start') {
+            this.options.send('ack', { type: envelope.type }, envelope.id);
+            this.options.runners.startManagedRun(envelope);
+            return;
+        }
+        if (envelope.type === 'session.channel.message') {
+            this.options.deliverSessionChannelMessage(envelope);
+            return;
+        }
+        if (envelope.type === 'run.cancel' || envelope.type === 'run.interrupt') {
+            this.cancelRun(envelope);
+            return;
+        }
+        if (envelope.type === 'session.resume' || envelope.type === 'lease.reconcile') {
+            this.options.send('ack', { type: envelope.type }, envelope.id);
+            return;
+        }
+        if (envelope.type !== 'error')
+            this.options.send('error', { code: 'MESSAGE_TYPE_UNKNOWN' }, envelope.id);
+    }
+    register(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.nodeId !== 'string' ||
+            typeof payload.credential !== 'string' ||
+            this.options.config() === undefined) {
+            this.options.close(4002, 'MESSAGE_INVALID');
+            return;
+        }
+        void this.options.register(payload.nodeId, payload.credential);
+    }
+    decideApproval(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.runId !== 'string' ||
+            typeof payload.approvalId !== 'string' ||
+            (payload.decision !== 'APPROVED' && payload.decision !== 'REJECTED')) {
+            this.options.send('error', { code: 'MESSAGE_INVALID' }, envelope.id);
+            return;
+        }
+        this.options.runners.decideApproval({
+            runId: payload.runId,
+            approvalId: payload.approvalId,
+            decision: payload.decision
+        });
+        this.options.send('ack', { type: envelope.type }, envelope.id);
+    }
+    cancelRun(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.runId === 'string') {
+            const handled = this.options.runners.cancelManagedRun(payload.runId, envelope.type === 'run.cancel' ? 'CANCEL' : 'INTERRUPT');
+            if (!handled)
+                this.options.completeUncontrolledCancellation(payload.runId);
+        }
+        this.options.send('ack', { type: envelope.type }, envelope.id);
+    }
+}

package/dist/service/node-request-service.d.ts

@@ -0,0 +1,14 @@
+import type { NodeEnvelope } from '@myagentroam/protocol';
+interface NodeRequestServiceOptions {
+    readonly nodeId: () => string | undefined;
+    readonly databaseAvailable: () => boolean;
+    readonly execute: (operation: string, data: unknown) => Promise<unknown>;
+    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
+}
+/** Validates and executes the closed Admin-facing Node operation envelope. */
+export declare class NodeRequestService {
+    private readonly options;
+    constructor(options: NodeRequestServiceOptions);
+    handle(envelope: NodeEnvelope): Promise<void>;
+}
+export {};

package/dist/service/node-request-service.js

@@ -0,0 +1,50 @@
+import { nodeLog } from '../operational.js';
+import { validUserAuthorization } from '../runner/codex/conversation-parser.js';
+/** Validates and executes the closed Admin-facing Node operation envelope. */
+export class NodeRequestService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async handle(envelope) {
+        const payload = envelope.payload;
+        if (typeof payload.operation !== 'string' || !this.options.databaseAvailable()) {
+            this.options.send('node.response', { error: 'MESSAGE_INVALID' }, envelope.id);
+            return;
+        }
+        if (!validUserAuthorization(payload.userAuthorization, envelope, payload.operation, this.options.nodeId())) {
+            this.options.send('node.response', { error: 'USER_AUTHORIZATION_REQUIRED' }, envelope.id);
+            return;
+        }
+        const startedAt = performance.now();
+        try {
+            const data = payload.data !== null && typeof payload.data === 'object'
+                ? {
+                    ...payload.data,
+                    __workspaceWatchSessionHash: payload.userAuthorization
+                        .sessionHash
+                }
+                : payload.data;
+            const result = await this.options.execute(payload.operation, data);
+            this.options.send('node.response', { result }, envelope.id);
+            const durationMs = Math.round(performance.now() - startedAt);
+            if (durationMs >= 250)
+                nodeLog('node.operation.completed', {
+                    nodeId: this.options.nodeId(),
+                    operation: payload.operation,
+                    requestId: envelope.id,
+                    durationMs
+                });
+        }
+        catch (error) {
+            nodeLog('node.operation.failed', {
+                nodeId: this.options.nodeId(),
+                operation: payload.operation,
+                requestId: envelope.id,
+                durationMs: Math.round(performance.now() - startedAt),
+                error: error instanceof Error ? error.message : 'INTERNAL_ERROR'
+            });
+            this.options.send('node.response', { error: error instanceof Error ? error.message : 'INTERNAL_ERROR' }, envelope.id);
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+import type { NodeEnvelope, WorkbenchEventCategory } from '@myagentroam/protocol';
+import type { FakeRunnerStatus } from '../fake-runner.js';
+import type { CodexRunner } from '../runner/codex-runner.js';
+import type { ClaudeCodeRunner } from '../runner/claude-code-runner.js';
+import type { OpenCodeRunner } from '../runner/opencode-runner.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunDomainState } from './run-domain-state.js';
+import type { RunEventService } from './run-event-service.js';
+import type { WorkbenchEventService } from './workbench-event-service.js';
+import type { WorkspaceQueueWorkbenchService } from './workspace-queue-workbench-service.js';
+import type { RunnerImageAttachment } from './run-attachment-service.js';
+export declare function workbenchPayloadSessionId(runtime: NodeRuntimeState, category: WorkbenchEventCategory, payload: unknown): string | undefined;
+interface NodeRunEventBridgeOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly state: RunDomainState;
+    readonly events: RunEventService;
+    readonly workbench: WorkbenchEventService;
+    readonly queues: WorkspaceQueueWorkbenchService<RunnerImageAttachment>;
+    readonly codex: CodexRunner;
+    readonly claude: ClaudeCodeRunner;
+    readonly openCode: OpenCodeRunner;
+    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
+}
+/** Bridges process-local Run state to normalized control and Workbench events. */
+export declare class NodeRunEventBridge {
+    private readonly options;
+    constructor(options: NodeRunEventBridgeOptions);
+    publishApproval(input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly payload: unknown;
+        readonly expiresAt: number;
+    }): void;
+    emitRun(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
+    emitWorkbench(category: WorkbenchEventCategory, payload: unknown): void;
+    emitQueue(workspaceId: string, sessionId: string): void;
+    migrateRunnerSessionIdentity(sessionId: string, nativeSessionId: string): void;
+    reconcile(envelope: NodeEnvelope): void;
+}
+export {};

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

@@ -0,0 +1,83 @@
+import { isNodeAgentRun, isNodeConversationTurn, isPlainRecord } from '../runner/codex/conversation-parser.js';
+export function workbenchPayloadSessionId(runtime, category, payload) {
+    if (!isPlainRecord(payload))
+        return undefined;
+    if (category === 'session' && isPlainRecord(payload.session)) {
+        const id = payload.session.id;
+        return typeof id === 'string' ? id : undefined;
+    }
+    if (category === 'run' && isNodeAgentRun(payload.run))
+        return payload.run.sessionId;
+    if (category === 'conversation' && isNodeConversationTurn(payload.turn))
+        return payload.turn.sessionId;
+    if (category === 'conversation' && isPlainRecord(payload.event)) {
+        const runId = payload.event.runId;
+        return typeof runId === 'string' ? runtime.getRun(runId)?.sessionId : undefined;
+    }
+    if (category === 'queue') {
+        const id = payload.sessionId;
+        return typeof id === 'string' ? id : undefined;
+    }
+    return undefined;
+}
+/** Bridges process-local Run state to normalized control and Workbench events. */
+export class NodeRunEventBridge {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    publishApproval(input) {
+        this.options.send('approval.request', input);
+        this.emitRun(input.runId, 'approval.request', input);
+    }
+    emitRun(runId, eventType, payload, status) {
+        this.options.events.emit(runId, eventType, payload, status);
+    }
+    emitWorkbench(category, payload) {
+        this.options.workbench.emit(category, payload);
+    }
+    emitQueue(workspaceId, sessionId) {
+        this.emitWorkbench('queue', {
+            workspaceId,
+            sessionId,
+            queue: this.options.queues.present(workspaceId, sessionId)
+        });
+    }
+    migrateRunnerSessionIdentity(sessionId, nativeSessionId) {
+        for (const [turnId, managed] of this.options.codex.execution.managedTurns) {
+            if (managed.sessionId === sessionId)
+                this.options.codex.execution.managedTurns.set(turnId, {
+                    ...managed,
+                    sessionId: nativeSessionId
+                });
+        }
+        for (const [runId, managed] of this.options.codex.execution.runs) {
+            if (managed.sessionId === sessionId)
+                this.options.codex.execution.runs.set(runId, { ...managed, sessionId: nativeSessionId });
+        }
+        for (const [runId, managed] of this.options.claude.execution.runs) {
+            if (managed.marSessionId === sessionId)
+                this.options.claude.execution.runs.set(runId, {
+                    ...managed,
+                    marSessionId: nativeSessionId
+                });
+        }
+        for (const [runId, managed] of this.options.openCode.execution) {
+            if (managed.sessionId === sessionId)
+                this.options.openCode.execution.set(runId, { ...managed, sessionId: nativeSessionId });
+        }
+    }
+    reconcile(envelope) {
+        const payload = envelope.payload;
+        if (!Array.isArray(payload.runIds) || payload.runIds.some((id) => typeof id !== 'string')) {
+            this.options.send('error', { code: 'MESSAGE_INVALID' }, envelope.id);
+            return;
+        }
+        for (const runId of payload.runIds) {
+            const known = this.options.state.active.has(runId);
+            this.options.runtime.reconcileRun(runId, known);
+            this.options.send('lease.reconcile', { runId, known });
+        }
+        this.options.send('ack', { type: 'runs.reconcile' }, envelope.id);
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { NodeConfig } from '../config.js';
+import type { TerminalManager } from '../terminal.js';
+interface NodeTerminalChannelOptions {
+    readonly config: () => NodeConfig | undefined;
+    readonly controlConnected: () => boolean;
+    readonly stopped: () => boolean;
+    readonly reconnect: boolean;
+    readonly reconnectDelay: (attempt: number) => number;
+    readonly manager: TerminalManager;
+}
+export declare class NodeTerminalChannel {
+    private readonly options;
+    private socket;
+    private reconnectTimer;
+    private attempts;
+    private readonly state;
+    constructor(options: NodeTerminalChannelOptions);
+    connect(): void;
+    disconnect(): void;
+    stop(): void;
+    private scheduleReconnect;
+    private handle;
+    private publish;
+    private sendFrame;
+    private send;
+    private invalid;
+    private releaseAttachments;
+}
+export {};

package/dist/service/node-terminal-channel.js

@@ -0,0 +1,182 @@
+import WebSocket from 'ws';
+import { terminalDataFrameSchema } from '@myagentroam/protocol';
+import { nodeTerminalConnectEndpoint, isPlainRecord } from '../runner/codex/conversation-parser.js';
+import { TerminalRelayState } from './terminal-relay-state.js';
+export class NodeTerminalChannel {
+    options;
+    socket;
+    reconnectTimer;
+    attempts = 0;
+    state = new TerminalRelayState();
+    constructor(options) {
+        this.options = options;
+        options.manager.onFrame((frame) => this.publish(frame));
+    }
+    connect() {
+        const config = this.options.config();
+        if (config?.nodeId === undefined ||
+            config.credential === undefined ||
+            this.options.stopped() ||
+            (this.socket !== undefined &&
+                (this.socket.readyState === this.socket.OPEN ||
+                    this.socket.readyState === this.socket.CONNECTING)))
+            return;
+        const socket = new WebSocket(nodeTerminalConnectEndpoint(config.serverUrl));
+        this.socket = socket;
+        socket.once('open', () => this.send({ type: 'authenticate', nodeId: config.nodeId, credential: config.credential }));
+        socket.on('message', (raw, isBinary) => isBinary ? socket.close(4002, 'TERMINAL_MESSAGE_INVALID') : this.handle(raw.toString()));
+        socket.once('close', () => {
+            if (this.socket !== socket)
+                return;
+            this.socket = undefined;
+            this.releaseAttachments();
+            this.scheduleReconnect();
+        });
+        socket.once('error', () => undefined);
+    }
+    disconnect() {
+        this.socket?.close();
+    }
+    stop() {
+        if (this.reconnectTimer !== undefined)
+            clearTimeout(this.reconnectTimer);
+        this.reconnectTimer = undefined;
+        this.releaseAttachments();
+        this.socket?.close();
+        this.socket = undefined;
+    }
+    scheduleReconnect() {
+        if (this.options.stopped() ||
+            !this.options.reconnect ||
+            !this.options.controlConnected() ||
+            this.reconnectTimer !== undefined)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            this.connect();
+        }, this.options.reconnectDelay(this.attempts++));
+    }
+    handle(raw) {
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            this.invalid();
+            return;
+        }
+        if (!isPlainRecord(message) || typeof message.type !== 'string') {
+            this.invalid();
+            return;
+        }
+        if (message.type === 'authenticated') {
+            if (typeof message.nodeId !== 'string' ||
+                Object.keys(message).some((key) => key !== 'type' && key !== 'nodeId'))
+                this.invalid();
+            else
+                this.attempts = 0;
+            return;
+        }
+        if (message.type === 'attach') {
+            if (typeof message.ticket !== 'string' ||
+                typeof message.terminalId !== 'string' ||
+                typeof message.attachmentId !== 'string' ||
+                Object.keys(message).some((key) => !['type', 'ticket', 'terminalId', 'attachmentId'].includes(key))) {
+                this.invalid();
+                return;
+            }
+            this.state.attachments.set(message.ticket, {
+                terminalId: message.terminalId,
+                attachmentId: message.attachmentId
+            });
+            return;
+        }
+        if (message.type === 'detach' || message.type === 'close') {
+            if (typeof message.ticket !== 'string' ||
+                Object.keys(message).some((key) => !['type', 'ticket'].includes(key))) {
+                this.invalid();
+                return;
+            }
+            const attachment = this.state.attachments.get(message.ticket);
+            if (attachment === undefined)
+                return;
+            this.state.attachments.delete(message.ticket);
+            if (message.type === 'detach')
+                this.options.manager.detach(attachment.attachmentId);
+            else
+                void this.options.manager
+                    .acceptFrame(attachment.attachmentId, {
+                    type: 'close',
+                    terminalId: attachment.terminalId
+                })
+                    .catch(() => undefined);
+            return;
+        }
+        if (message.type === 'frame') {
+            if (typeof message.ticket !== 'string' ||
+                Object.keys(message).some((key) => !['type', 'ticket', 'frame'].includes(key))) {
+                this.invalid();
+                return;
+            }
+            const parsed = terminalDataFrameSchema.safeParse(message.frame);
+            const attachment = this.state.attachments.get(message.ticket);
+            if (!parsed.success || !['input', 'resize', 'close'].includes(parsed.data.type)) {
+                this.invalid();
+                return;
+            }
+            if (attachment === undefined)
+                return;
+            if (parsed.data.terminalId !== attachment.terminalId) {
+                this.invalid();
+                return;
+            }
+            void this.options.manager.acceptFrame(attachment.attachmentId, parsed.data).catch(() => {
+                this.state.attachments.delete(message.ticket);
+                this.options.manager.detach(attachment.attachmentId);
+                this.sendFrame(message.ticket, {
+                    type: 'error',
+                    terminalId: attachment.terminalId,
+                    code: 'TERMINAL_FRAME_REJECTED'
+                });
+            });
+            return;
+        }
+        if (message.type === 'shutdown' && Object.keys(message).length === 1) {
+            this.state.attachments.clear();
+            void this.options.manager.shutdown();
+            return;
+        }
+        this.invalid();
+    }
+    publish(frame) {
+        for (const [ticket, attachment] of this.state.attachments) {
+            if (attachment.terminalId !== frame.terminalId)
+                continue;
+            this.sendFrame(ticket, frame);
+            if (frame.type === 'exit')
+                this.state.attachments.delete(ticket);
+        }
+    }
+    sendFrame(ticket, frame) {
+        this.send({ type: 'frame', ticket, frame });
+    }
+    send(message) {
+        const socket = this.socket;
+        if (socket === undefined || socket.readyState !== socket.OPEN)
+            return;
+        try {
+            socket.send(JSON.stringify(message));
+        }
+        catch {
+            socket.close(1011, 'TERMINAL_SEND_FAILED');
+        }
+    }
+    invalid() {
+        this.socket?.close(4002, 'TERMINAL_MESSAGE_INVALID');
+    }
+    releaseAttachments() {
+        for (const attachment of this.state.attachments.values())
+            this.options.manager.detach(attachment.attachmentId);
+        this.state.attachments.clear();
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { NodeUpgradeStatus } from '@myagentroam/protocol';
+export declare class NodeUpgradeCoordinator {
+    private readonly requestPath;
+    private readonly activeRunCount;
+    private readonly onStatus;
+    private readonly onReady;
+    private readonly now;
+    private status;
+    private timer;
+    constructor(requestPath: () => string, activeRunCount: () => number, onStatus: (status: NodeUpgradeStatus) => void, onReady: () => void, now?: () => number);
+    snapshot(): NodeUpgradeStatus;
+    loadResult(resultPath: string): Promise<void>;
+    request(data: unknown): {
+        status: 'ACCEPTED' | 'ALREADY_PENDING';
+        targetVersion: string;
+        activeRunCount: number;
+    };
+    cancel(): {
+        cancelled: true;
+    };
+    blocks(operation: string): boolean;
+    pending(): boolean;
+    stop(): void;
+    private checkReady;
+    private checkReadySafely;
+    private update;
+    private clearTimer;
+}
+export declare function nodeUpgradeRequestPath(databasePath: string): string;