@myagentroam/node 0.9.9 → 0.9.11

package/dist/service/native-session-projection-service.d.ts

@@ -1,52 +0,0 @@
-import type { NodeCapabilities, RunnerDefaultConfiguration } 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 { RunnerRegistry } from '../runner/runner-registry.js';
-import type { RunnerDiscoveryContext } from '../runner/abstract-runner.js';
-import type { CommandStateStore } from '../runner-command-engine.js';
-import type { SessionDomainState } from './session-domain-state.js';
-interface NativeSessionProjectionServiceOptions {
-    readonly database: () => NodeDatabase | undefined;
-    readonly nodeId: () => string;
-    readonly runtime: NodeRuntimeState;
-    readonly runners: RunnerRegistry;
-    readonly capabilities: () => NodeCapabilities;
-    readonly state: SessionDomainState<NodeAgentSession, unknown>;
-    readonly commands: CommandStateStore;
-    readonly present: (session: NodeAgentSession) => NodeAgentSession & {
-        readonly control: CodexSessionControl;
-    };
-}
-export declare class NativeSessionProjectionService {
-    private readonly options;
-    constructor(options: NativeSessionProjectionServiceOptions);
-    discover(runnerName: NodeAgentSession['runner'], workspaceId?: string): Promise<readonly NodeAgentSession[]>;
-    discoverCodex(workspaceId?: string): Promise<{
-        readonly sessions: readonly (NodeAgentSession & {
-            readonly control: CodexSessionControl;
-        })[];
-    }>;
-    list(): Promise<readonly (NodeAgentSession & {
-        readonly control: CodexSessionControl;
-    })[]>;
-    discoverWorkspace(workspaceId: string): Promise<readonly NodeAgentSession[]>;
-    resolve(sessionId: string): Promise<NodeAgentSession | undefined>;
-    resolveCurrent(sessionId: string): Promise<NodeAgentSession | undefined>;
-    createMetadataProjection(sessionId: string): Promise<NodeAgentSession | undefined>;
-    resumedConfiguration(session: NodeAgentSession): RunnerDefaultConfiguration;
-    ensureResumedConfiguration(session: NodeAgentSession): NodeAgentSession;
-    rename(session: NodeAgentSession, input: {
-        readonly title?: string | null;
-        readonly pinned?: boolean;
-    }): Promise<void>;
-    project(input: Parameters<RunnerDiscoveryContext['createProjection']>[0]): NodeAgentSession;
-    remember(sessions: readonly NodeAgentSession[]): void;
-    projectionForNative(native: NodeAgentSession): NodeAgentSession | undefined;
-    managedForNative(native: NodeAgentSession): NodeAgentSession | undefined;
-    nativeIds(session: NodeAgentSession): ReadonlySet<string>;
-    forget(session: NodeAgentSession, knownNativeIds: ReadonlySet<string>): void;
-    private isManagedProjection;
-    private requireDatabase;
-}
-export {};

package/dist/service/native-session-watch-service.d.ts

@@ -1,62 +0,0 @@
-import type { NodeAgentSession } from '../database.js';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-export interface NativeSessionWatchOptions<TPage extends {
-    readonly turns: readonly unknown[];
-    readonly source?: unknown;
-}> {
-    readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
-    readonly managedActive: (session: NodeAgentSession) => boolean;
-    readonly suspended?: (sessionId: string) => boolean;
-    readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
-    readonly present: (session: NodeAgentSession) => unknown;
-    readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
-    readonly convergePage: (previous: TPage | undefined, previousObserved: TPage | undefined, next: TPage, previousAuthority: unknown) => {
-        readonly page: TPage;
-        readonly authority: unknown;
-    };
-    readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
-    readonly emitSession: (session: unknown) => void;
-    readonly emitPage: (session: NodeAgentSession, page: TPage) => void;
-    readonly nodeId?: () => string;
-    readonly nodeGeneration?: () => string;
-    readonly emitWatchEvent?: (payload: unknown) => void;
-}
-export declare class NativeSessionWatchService<TPage extends {
-    readonly turns: readonly unknown[];
-    readonly source?: unknown;
-}> {
-    private readonly options;
-    private readonly watches;
-    private readonly leases;
-    private snapshotSequence;
-    constructor(options: NativeSessionWatchOptions<TPage>);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private executeWatch;
-    private executeUnwatch;
-    watch(session: NodeAgentSession): {
-        readonly expiresAt: number;
-    } | undefined;
-    renew(session: NodeAgentSession): {
-        readonly expiresAt: number;
-    } | undefined;
-    stop(sessionId: string): void;
-    clear(): void;
-    has(sessionId: string): boolean;
-    entry(sessionId: string): {
-        readonly expiresAt: number;
-    } | undefined;
-    get size(): number;
-    refresh(sessionId: string, limit?: number, emit?: boolean): Promise<TPage | undefined>;
-    private performRefresh;
-    private sessionHash;
-    private ownerKey;
-    private accepted;
-    private initializeLease;
-    private removeLease;
-    private emitObservedPage;
-    private failSession;
-    private releaseSessionLeases;
-    private leaseTimer;
-    private latestLeaseExpiry;
-    private refreshTimer;
-}

package/dist/service/node-connection-lifecycle-service.d.ts

@@ -1,36 +0,0 @@
-import type { NodeCapabilities } from '@myagentroam/protocol';
-import { type NodeConfig } from '../config.js';
-import type { NodeMetrics } from '../operational.js';
-import type { NodeControlChannel } from './node-control-channel.js';
-import type { NodeTerminalChannel } from './node-terminal-channel.js';
-interface NodeConnectionLifecycleServiceOptions {
-    readonly config: () => NodeConfig | undefined;
-    readonly setConfig: (config: NodeConfig) => void;
-    readonly configPath: string | undefined;
-    readonly capabilities: () => NodeCapabilities;
-    readonly detectCapabilities: () => NodeCapabilities | Promise<NodeCapabilities>;
-    readonly capabilitiesProvided: boolean;
-    readonly stopped: () => boolean;
-    readonly setCapabilities: (capabilities: NodeCapabilities) => void;
-    readonly control: NodeControlChannel;
-    readonly terminal: NodeTerminalChannel;
-    readonly metrics: NodeMetrics;
-    readonly heartbeatMs: number;
-    readonly refreshMs: number;
-    readonly onConnected?: () => void;
-}
-/** Owns registration completion, heartbeat and background capability refresh timers. */
-export declare class NodeConnectionLifecycleService {
-    private readonly options;
-    private heartbeat;
-    private refreshTimer;
-    private refreshing;
-    constructor(options: NodeConnectionLifecycleServiceOptions);
-    start(): void;
-    startCapabilityRefresh(): void;
-    stop(): void;
-    register(nodeId: string, credential: string): Promise<void>;
-    connected(): void;
-    refreshCapabilities(): Promise<void>;
-}
-export {};

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

@@ -1,32 +0,0 @@
-import WebSocket from 'ws';
-import { type NodeCapabilities, type NodeEnvelope } from '@myagentroam/protocol';
-import type { NodeConfig } from '../config.js';
-interface NodeControlChannelOptions {
-    readonly config: () => NodeConfig | undefined;
-    readonly capabilities: () => NodeCapabilities;
-    readonly stopped: () => boolean;
-    readonly reconnect: boolean;
-    readonly reconnectDelay: (attempt: number) => number;
-    readonly onConnecting: (attempt: number) => void;
-    readonly onReconnectScheduled: () => void;
-    readonly onMessage: (raw: string) => void;
-    readonly onClose: (code: number, reason: string) => void;
-}
-export declare class NodeControlChannel {
-    private readonly options;
-    private socket;
-    private readonly outbound;
-    private reconnectTimer;
-    private attempts;
-    constructor(options: NodeControlChannelOptions);
-    connect(): void;
-    connected(): boolean;
-    /** Keeps transport injection at the transport boundary for contract tests. */
-    replaceSocketForTesting(socket: WebSocket | undefined): void;
-    close(code?: number, reason?: string): void;
-    stop(): void;
-    send(type: string, payload: unknown, replyTo?: string): void;
-    sendEnvelope(envelope: NodeEnvelope): void;
-    private scheduleReconnect;
-}
-export {};

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

@@ -1,27 +0,0 @@
-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 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-request-service.d.ts

@@ -1,14 +0,0 @@
-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-run-event-bridge.d.ts

@@ -1,40 +0,0 @@
-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-terminal-channel.d.ts

@@ -1,29 +0,0 @@
-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-upgrade-coordinator.d.ts

@@ -1,29 +0,0 @@
-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;

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

@@ -1,29 +0,0 @@
-import type { NodeEnvelope } from '@myagentroam/protocol';
-import type { NodeConfig } from '../config.js';
-import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.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 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 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>;
-}
-export {};

package/dist/service/recent-run-projection-service.d.ts

@@ -1,14 +0,0 @@
-import type { NodeAgentRun, NodeAgentSession } from '../database.js';
-import type { RecentRunProjection, RecentRunProjectionMessage } from '@myagentroam/protocol';
-export declare class RecentRunProjectionService {
-    private readonly emit;
-    private readonly now;
-    private readonly runs;
-    private readonly cleanupTimer;
-    constructor(emit: (message: RecentRunProjectionMessage) => void, now?: () => number);
-    record(run: NodeAgentRun, session: NodeAgentSession): void;
-    snapshot(): readonly RecentRunProjection[];
-    publishSnapshot(): void;
-    dispose(): void;
-    private cleanup;
-}

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

@@ -1,38 +0,0 @@
-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;
-    readonly root: string;
-}
-export type RunnerImageAttachment = NodeMessageAttachmentInput & {
-    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
-};
-export declare class RunAttachmentService {
-    private readonly nativeImageRoots;
-    readonly state: AttachmentDomainState<CachedRunImages, NativeImageSource>;
-    constructor(nativeImageRoots: (session: NodeAgentSession) => readonly string[]);
-    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-domain-state.d.ts

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

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

@@ -1,33 +0,0 @@
-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;
-    flushPendingText(runId: string): void;
-    private enqueueText;
-    private flushText;
-    private emitNow;
-    private notificationPayload;
-}

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

@@ -1,25 +0,0 @@
-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 cancelQueued: (runId: string) => void;
-    readonly pauseQueue: (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 image;
-    private respond;
-    private interruptSession;
-    private cancelOrInterrupt;
-    private approvals;
-    private decideApproval;
-    private requireRun;
-}

package/dist/service/runner-channel-message-service.d.ts

@@ -1,13 +0,0 @@
-import type { NodeEnvelope } from '@myagentroam/protocol';
-import type { RunnerInteractionService } from './runner-interaction-service.js';
-interface RunnerChannelMessageServiceOptions {
-    readonly interactions: RunnerInteractionService;
-    readonly send: (type: string, payload: unknown, replyTo?: string) => void;
-}
-/** Validates shared-control channel messages before delivery to a Runner. */
-export declare class RunnerChannelMessageService {
-    private readonly options;
-    constructor(options: RunnerChannelMessageServiceOptions);
-    handle(envelope: NodeEnvelope): void;
-}
-export {};

package/dist/service/runner-interaction-service.d.ts

@@ -1,39 +0,0 @@
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { NodeAgentSession } from '../database.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-import type { ClaudeCodeRunner } from '../runner/claude-code-runner.js';
-import type { CodexRunner } from '../runner/codex-runner.js';
-import { type PublicConversationItem } from '../runner/codex/conversation-parser.js';
-import type { RunDomainState } from './run-domain-state.js';
-interface RunnerInteractionServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly state: RunDomainState;
-    readonly codex: () => CodexRunner;
-    readonly claude: () => ClaudeCodeRunner;
-    readonly runners: RunnerRegistry;
-    readonly emitRun: (runId: string, eventType: string, payload: unknown, status?: 'FAILED' | 'CANCELLED' | 'INTERRUPTED') => void;
-    readonly emitItem: (runId: string, item: PublicConversationItem) => void;
-    readonly approvalTimeoutMs: number;
-    readonly publishApproval: (input: {
-        readonly runId: string;
-        readonly approvalId: string;
-        readonly payload: unknown;
-        readonly expiresAt: number;
-    }) => void;
-}
-export declare class RunnerInteractionService {
-    private readonly options;
-    constructor(options: RunnerInteractionServiceOptions);
-    requestClaudeApproval(runId: string, toolName: string, toolInput: Record<string, unknown>): Promise<import("@anthropic-ai/claude-agent-sdk").PermissionResult>;
-    requestClaudeUserInput(runId: string, toolInput: Record<string, unknown>, toolUseId: string): Promise<import("@anthropic-ai/claude-agent-sdk").PermissionResult>;
-    deliverChannel(runner: NodeAgentSession['runner'], sessionId: string, messageId: string, senderId: string, token: string, content: string): import("../claude-channel.js").ChannelDelivery;
-    decideCodexApproval(approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
-    decideClaudeApproval(approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
-    cancelClaudeRun(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
-    cancelCodexTurn(runId: string, threadId: string, turnId: string, cwd: string, terminalStatus: 'CANCELLED' | 'INTERRUPTED'): Promise<void>;
-    respondUserInput(runId: string, requestId: string, rawAnswers: Record<string, unknown>): void;
-    completeCancelledRun(runId: string): boolean;
-    private respondCodexUserInput;
-    private answers;
-}
-export {};

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

@@ -1,46 +0,0 @@
-import { type NodeCapabilities } from '@myagentroam/protocol';
-import type { NodeDatabase } from '../database.js';
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-import type { RunnerUsageReader } from '../runner-usage.js';
-export declare class RunnerService {
-    private readonly database;
-    private readonly capabilities;
-    private readonly runners;
-    private readonly usage;
-    constructor(database: () => NodeDatabase, capabilities: () => NodeCapabilities, runners: RunnerRegistry, usage: RunnerUsageReader);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    profiles(): readonly {
-        runner: "codex" | "claude-code" | "opencode";
-        capabilities: string[];
-        models: {
-            id: string;
-            label: string;
-            supportedEfforts: string[];
-            isDefault?: boolean | undefined;
-            defaultEffort?: string | undefined;
-        }[];
-        accessOptions: {
-            id: string;
-            description: string;
-            label: string;
-        }[];
-        commands: {
-            id: string;
-            description: string;
-            available: boolean;
-            runner: "codex" | "claude-code" | "opencode";
-            reasonCode: string | null;
-            label: string;
-            inputHint: string;
-            source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
-            interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";
-            stateLabel?: string | undefined;
-        }[];
-    }[];
-    private refreshProfiles;
-    private usageStatuses;
-    private readUsage;
-    private listProfiles;
-    private saveDefaults;
-}

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

@@ -1,45 +0,0 @@
-import type { NodeOperationHandler } from '../connector/node-operation-router.js';
-import type { NodeAgentSession, NodeConversationTurn, NodeDatabase } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
-import type { ExternalSessionResumeService } from './external-session-resume-service.js';
-import type { NativeSessionProjectionService } from './native-session-projection-service.js';
-import type { RunnerRegistry } from '../runner/runner-registry.js';
-interface SessionCatalogServiceOptions {
-    readonly database: () => NodeDatabase;
-    readonly nodeId: () => string;
-    readonly runtime: NodeRuntimeState;
-    readonly runners: RunnerRegistry;
-    readonly projection: NativeSessionProjectionService;
-    readonly resume: ExternalSessionResumeService;
-    readonly cachedNative: () => readonly NodeAgentSession[];
-    readonly cachedWorkspace: (workspaceId: string) => Promise<readonly NodeAgentSession[]>;
-    readonly present: (session: NodeAgentSession) => NodeAgentSession;
-    readonly projectionForNative: (session: NodeAgentSession) => NodeAgentSession | undefined;
-    readonly nativeIds: (session: NodeAgentSession) => ReadonlySet<string>;
-    readonly forget: (session: NodeAgentSession, nativeIds: ReadonlySet<string>) => void;
-    readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
-    readonly externalActivity: (sessionId: string) => unknown;
-    readonly history: (session: NodeAgentSession, input: {
-        readonly cursor?: string;
-        readonly limit?: number;
-    }) => Promise<{
-        readonly turns: readonly NodeConversationTurn[];
-        readonly nextCursor: string | null;
-    }>;
-    readonly emitSession: (session: NodeAgentSession) => void;
-}
-export declare class SessionCatalogService {
-    private readonly options;
-    private rewindQueue;
-    constructor(options: SessionCatalogServiceOptions);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private list;
-    private mergePersisted;
-    private resume;
-    private enqueueRewind;
-    private rewind;
-    private findTurn;
-    private remove;
-}
-export declare function rewindTitle(sourceTitle: string, existingTitles?: readonly string[]): string;
-export {};

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

@@ -1,24 +0,0 @@
-import type { RunnerProfile } from '@myagentroam/protocol';
-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 { ExternalSessionResumeService } from './external-session-resume-service.js';
-import type { NativeSessionProjectionService } from './native-session-projection-service.js';
-interface SessionCommandServiceOptions {
-    readonly runtime: NodeRuntimeState;
-    readonly runners: RunnerRegistry;
-    readonly projection: NativeSessionProjectionService;
-    readonly resume: ExternalSessionResumeService;
-    readonly profiles: () => readonly RunnerProfile[];
-    readonly present: (session: NodeAgentSession) => unknown;
-    readonly resumeQueueAfterCommandRun: (sessionId: string) => void;
-}
-export declare class SessionCommandService {
-    private readonly options;
-    constructor(options: SessionCommandServiceOptions);
-    operations(): Readonly<Record<string, NodeOperationHandler>>;
-    private runnerCommand;
-    private sessionCommand;
-}
-export {};