@myagentroam/node 0.9.9 → 0.9.10

package/dist/process-tree.d.ts

@@ -1,9 +0,0 @@
-export type ProcessTreeCommand = (file: string, args: readonly string[], options: {
-    readonly windowsHide: boolean;
-}) => Promise<unknown>;
-export interface ManagedProcess {
-    readonly pid?: number;
-    kill(signal?: NodeJS.Signals | number): boolean;
-}
-/** Kills the process group on Unix and the complete task tree on Windows. */
-export declare function terminateProcessTree(child: ManagedProcess, platform?: NodeJS.Platform, runCommand?: ProcessTreeCommand): Promise<void>;

package/dist/rotating-log.d.ts

@@ -1,17 +0,0 @@
-export declare function configureNodeLog(dataDirectory: string): void;
-export declare function writeNodeLog(content: string): void;
-export declare class RotatingNodeLog {
-    private readonly maxBytes;
-    private readonly retentionMs;
-    private readonly now;
-    private readonly activePath;
-    private bytes;
-    private day;
-    private rotation;
-    private lastCleanup;
-    constructor(directory: string, maxBytes?: number, retentionMs?: number, now?: () => number);
-    write(content: string): void;
-    private currentDay;
-    private rotate;
-    private cleanup;
-}

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

@@ -1,172 +0,0 @@
-import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerCommandDescriptor, NodeEnvelope, RunnerName, RunnerProfile, RunnerCommandState, SessionActivityState } from '@myagentroam/protocol';
-import type { NodeAgentSession, NodeConversationTurn, NodeDatabase, NodeWorkspace } from '../database.js';
-import type { ChannelDelivery } from '../claude-channel.js';
-import type { CodexSessionControl } from '../codex-app-server.js';
-export type RegisteredRunnerName = RunnerName | 'fake';
-/**
- * Stable lifecycle boundary for every Node Runner implementation.
- *
- * Vendor clients and payload decoders stay behind subclasses. Domain services
- * depend on this boundary (or a capability interface implemented by it), never
- * on an SDK/App Server client directly.
- */
-export declare abstract class AbstractRunner<TName extends RegisteredRunnerName = RegisteredRunnerName> {
-    private control;
-    private commandControl;
-    abstract readonly name: TName;
-    /** Test-only runners are registered explicitly but never advertised. */
-    readonly advertised: boolean;
-    readonly interceptsRuns: boolean;
-    abstract readonly discoveryScope: 'ALL_WORKSPACES' | 'WORKSPACE_REQUIRED';
-    abstract profile(capabilities: NodeCapabilities): RunnerProfile | undefined;
-    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile | undefined>;
-    abstract available(capabilities: NodeCapabilities): boolean;
-    abstract defaultConfiguration(workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
-    protected abstract profileForValidation(): RunnerProfile;
-    abstract resumeExternal(session: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
-    abstract discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
-    abstract readContextUsage(session: NodeAgentSession): Promise<RunnerContextUsage | undefined>;
-    presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
-    prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
-    mcpConfiguration(rawInstallations: unknown, secretEnvironment: Readonly<Record<string, string>>): unknown;
-    channelToken(sessionId: string): string | undefined;
-    deliverChannel(sessionId: string, messageId: string, senderId: string, token: string, content: string, notify: (runId: string, messageId: string, delivery: ChannelDelivery) => void): ChannelDelivery;
-    executeGlobalCommand(commandId: string, input: string): unknown;
-    serviceTier(): 'fast' | undefined;
-    usesRunnerTitleForRename(): boolean;
-    renameNative(session: NodeAgentSession, input: {
-        readonly title?: string | null;
-        readonly pinned?: boolean;
-    }, database: NodeDatabase): Promise<void>;
-    removeNative(session: NodeAgentSession, nativeSessionId: string): Promise<boolean>;
-    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
-    projectedRunnerTitle(metadata: ReturnType<NodeDatabase['getNativeSessionMetadata']>, input: RunnerProjectionTitleInput, database: NodeDatabase | undefined): string | null;
-    managedAliasId(nativeSessionId: string): string | undefined;
-    nativeAliasesFor(managedSessionId: string): readonly string[];
-    forgetNativeAlias(nativeSessionId: string): void;
-    rememberManagedNative(session: NodeAgentSession, nativeSessionId: string): void;
-    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
-    readOfficialConversation(session: NodeAgentSession, input: {
-        readonly cursor?: string;
-        readonly limit?: number;
-    }, managedTurn: (nativeTurnId: string) => NodeConversationTurn | undefined): Promise<RunnerConversationPage | undefined>;
-    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
-    readExternalActivity(session: NodeAgentSession): Promise<SessionActivityState | undefined>;
-    acceptsTruncatedNativeHistory(): boolean;
-    nativeImageRoots(session: NodeAgentSession): readonly string[];
-    managedRunForNativeTurn(nativeTurnId: string): string | undefined;
-    abstract stop(): void | Promise<void>;
-    bindControl(control: RunnerControl): void;
-    acceptsRun(runner: unknown): boolean;
-    startManagedRun(envelope: NodeEnvelope): void;
-    cancelManagedRun(runId: string, intent: RunnerCancellationIntent): boolean;
-    decideApproval(input: RunnerApprovalDecision): boolean;
-    respondUserInput(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
-    bindCommandControl(control: RunnerCommandControl): void;
-    executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
-        readonly secretEnvironment: Readonly<Record<string, string>>;
-    }): Promise<unknown>;
-}
-export interface ResolvedMcpServer {
-    readonly name: string;
-    readonly transport: 'STDIO' | 'HTTP';
-    readonly command?: string;
-    readonly args?: readonly string[];
-    readonly environment?: Readonly<Record<string, string>>;
-    readonly url?: string;
-    readonly headers?: Readonly<Record<string, string>>;
-}
-export type RunnerCancellationIntent = 'CANCEL' | 'INTERRUPT';
-export interface RunnerControl {
-    start(envelope: NodeEnvelope): void;
-    cancel(runId: string, intent: RunnerCancellationIntent): boolean;
-    decideApproval?(input: RunnerApprovalDecision): boolean;
-    respondUserInput?(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
-}
-export interface RunnerCommandControl {
-    execute(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
-        readonly secretEnvironment: Readonly<Record<string, string>>;
-    }): Promise<unknown>;
-}
-export interface RunnerApprovalDecision {
-    readonly runId: string;
-    readonly approvalId: string;
-    readonly decision: 'APPROVED' | 'REJECTED';
-}
-export interface RunnerDiscoveryContext {
-    readonly workspaces: readonly NodeWorkspace[];
-    createProjection(input: {
-        readonly workspace: NodeWorkspace;
-        readonly runner: RunnerName;
-        readonly externalSessionId: string;
-        readonly cwd: string;
-        readonly title?: string;
-        readonly titleOrigin?: 'OFFICIAL' | 'NATIVE';
-        readonly lastActivityAt?: number;
-    }): NodeAgentSession;
-}
-export interface ExternalResumeContext {
-    readonly available: boolean;
-    projectionFor(session: NodeAgentSession): NodeAgentSession | undefined;
-    managedAliasFor(session: NodeAgentSession): NodeAgentSession | undefined;
-    currentResumed(sessionId: string): NodeAgentSession | undefined;
-    promote(sessionId: string): NodeAgentSession | undefined;
-    ensureConfiguration(session: NodeAgentSession): NodeAgentSession;
-    create(session: NodeAgentSession): NodeAgentSession;
-    workspacePath(workspaceId: string): string | undefined;
-    rememberManagedNative(nativeSessionId: string, sessionId: string): void;
-}
-export interface ExternalResumeResult {
-    readonly session?: NodeAgentSession;
-    readonly activity?: 'IDLE' | 'EXTERNAL_ACTIVE' | 'UNAVAILABLE';
-    readonly failureCode?: string;
-    readonly failureDetail?: string;
-    readonly messageFailureCode?: string;
-}
-export interface RunnerContextUsage {
-    readonly model?: string | null;
-    readonly usedTokens: number;
-    readonly maxTokens: number;
-}
-export interface RunnerProjectionTitleInput {
-    readonly externalSessionId: string;
-    readonly workspaceId: string;
-    readonly title?: string;
-    readonly titleOrigin?: 'OFFICIAL' | 'NATIVE';
-}
-export interface RunnerConversationPage {
-    readonly turns: readonly NodeConversationTurn[];
-    readonly nextCursor: string | null;
-}
-export type RunnerConversationHistorySource = 'native' | 'official';
-export interface RunnerConversationHistoryReaders {
-    readonly native: () => Promise<RunnerConversationPage | undefined>;
-    readonly official: () => Promise<RunnerConversationPage | undefined>;
-}
-export interface RunnerConversationHistoryPage extends RunnerConversationPage {
-    readonly source: RunnerConversationHistorySource;
-}
-export interface RunnerSessionPresentationContext {
-    readonly managedActive: boolean;
-    readonly externalActivity: SessionActivityState | undefined;
-    readonly commandStates: readonly RunnerCommandState[];
-}
-export interface RunnerSessionPresentation {
-    readonly activity: SessionActivityState;
-    readonly control: {
-        readonly level: CodexSessionControl['level'];
-        readonly capabilities: CodexSessionControl['capabilities'];
-    };
-    readonly runtime: {
-        readonly level: CodexSessionControl['level'];
-        readonly capabilities: readonly string[];
-        readonly reasonCode: string | null;
-    };
-    readonly commandStates: readonly RunnerCommandState[];
-}
-export declare class RunnerCapabilityError extends Error {
-    readonly runner: RegisteredRunnerName;
-    readonly capability: string;
-    constructor(runner: RegisteredRunnerName, capability: string);
-}

package/dist/runner/claude/managed-run-controller.d.ts

@@ -1,51 +0,0 @@
-import type { NodeEnvelope, RunnerCommandDescriptor, RunnerCommandState } from '@myagentroam/protocol';
-import { denyPermission } from '../../claude-agent-sdk.js';
-import type { NodeAgentSession } from '../../database.js';
-import type { FakeRunnerStatus } from '../../fake-runner.js';
-import { type PublicConversationItem } from '../codex/conversation-parser.js';
-import { ClaudeCodeRunner } from '../claude-code-runner.js';
-export interface ClaudeRunnerImageAttachment {
-    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
-    readonly dataBase64: string;
-}
-export interface ClaudeManagedRunHost<TAttachment extends ClaudeRunnerImageAttachment> {
-    intercepted(): boolean;
-    readonly active: Set<string>;
-    parseAttachments(value: unknown): readonly TAttachment[];
-    emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
-    adopt(input: {
-        runId: string;
-        sessionId: string;
-        runner: 'claude-code';
-        cwd: string;
-        externalSessionId?: string;
-    }): void;
-    run(runId: string): {
-        readonly status: string;
-    } | undefined;
-    hasActiveSessionLease(sessionId: string): boolean;
-    session(sessionId: string): NodeAgentSession | undefined;
-    completeCancelled(runId: string, cwd: string): boolean;
-    requestUserInput(runId: string, input: Record<string, unknown>, toolUseId: string): Promise<ReturnType<typeof denyPermission>>;
-    requestApproval(runId: string, toolName: string, input: Record<string, unknown>): Promise<ReturnType<typeof denyPermission>>;
-    rememberNative(nativeSessionId: string, sessionId: string): void;
-    promote(sessionId: string, nativeSessionId: string): void;
-    send(type: string, payload: unknown): void;
-    emitItem(runId: string, item: PublicConversationItem): void;
-    syncTitle(sessionId: string, nativeSessionId: string, cwd: string): Promise<void>;
-    setChannelToken(sessionId: string, token: string): void;
-    commandState(sessionId: string, commandId: string): RunnerCommandState | undefined;
-    setCommandState(sessionId: string, state: RunnerCommandState): void;
-    clearCommandState(sessionId: string, commandId: string): void;
-    commandStates(sessionId: string): readonly RunnerCommandState[];
-}
-export declare class ClaudeManagedRunController<TAttachment extends ClaudeRunnerImageAttachment> {
-    private readonly runner;
-    private readonly host;
-    constructor(runner: ClaudeCodeRunner, host: ClaudeManagedRunHost<TAttachment>);
-    executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
-        readonly secretEnvironment: Readonly<Record<string, string>>;
-    }): Promise<unknown>;
-    private compact;
-    start(envelope: NodeEnvelope): void;
-}

package/dist/runner/claude-code-runner.d.ts

@@ -1,72 +0,0 @@
-import { ClaudeAgentSdkAdapter, type ClaudeChannelRunHandle, type ClaudeQueryInput, type ClaudeRunHandle } from '../claude-agent-sdk.js';
-import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentationContext, type RunnerSessionPresentation } from './abstract-runner.js';
-import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
-import { ClaudeChannelGate } from '../claude-channel.js';
-import type { ChannelDelivery } from '../claude-channel.js';
-import { claudeUserInputQuestions } from '../util/runner-native-session-parsers.js';
-import type { NodeAgentSession, NodeWorkspace } from '../database.js';
-import { type NativeSessionHistory } from '../native-session-history.js';
-export declare class ClaudeCodeRunner extends AbstractRunner<'claude-code'> {
-    private readonly client;
-    private readonly environment;
-    readonly name: "claude-code";
-    readonly discoveryScope: "WORKSPACE_REQUIRED";
-    readonly execution: ClaudeExecutionState;
-    constructor(client?: ClaudeAgentSdkAdapter, environment?: NodeJS.ProcessEnv);
-    profile(capabilities: NodeCapabilities): RunnerProfile;
-    available(capabilities: NodeCapabilities): boolean;
-    protected profileForValidation(): RunnerProfile;
-    defaultConfiguration(): RunnerDefaultConfiguration;
-    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
-    resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
-    discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
-    readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeClaudeContextUsage | undefined>;
-    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
-    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string | null>;
-    presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
-    prepareMessageInput(input: string, collaborationMode: 'default' | 'plan'): string;
-    channelToken(sessionId: string): string | undefined;
-    deliverChannel(sessionId: string, messageId: string, senderId: string, token: string, content: string, notify: (runId: string, messageId: string, delivery: ChannelDelivery) => void): ChannelDelivery;
-    managedAliasId(nativeSessionId: string): string | undefined;
-    nativeAliasesFor(managedSessionId: string): readonly string[];
-    forgetNativeAlias(nativeSessionId: string): void;
-    rememberManagedNative(session: NodeAgentSession, nativeSessionId: string): void;
-    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
-    projectDiscoveredSessions(context: RunnerDiscoveryContext, workspace: NodeWorkspace, discovered: readonly ClaudeDiscoveredSession[]): readonly NodeAgentSession[];
-    stop(): void;
-    start(input: ClaudeQueryInput): ClaudeRunHandle;
-    startChannel(input: ClaudeQueryInput): ClaudeChannelRunHandle;
-    listSessions(cwd: string): ReturnType<ClaudeAgentSdkAdapter['listSessions']>;
-    sessionInfo(sessionId: string, cwd: string): ReturnType<ClaudeAgentSdkAdapter['sessionInfo']>;
-}
-export declare class ClaudeExecutionState {
-    readonly runs: Map<string, {
-        marSessionId: string;
-        nativeSessionId?: string;
-        cwd: string;
-        handle: ClaudeChannelRunHandle;
-        gate: ClaudeChannelGate;
-    }>;
-    readonly managedNativeIds: Set<string>;
-    readonly managedSessionByNativeId: Map<string, string>;
-    readonly approvals: Map<string, {
-        readonly runId: string;
-        readonly resolve: (decision: "APPROVED" | "REJECTED") => void;
-        readonly timer: NodeJS.Timeout;
-    }>;
-    readonly userInputs: Map<string, {
-        readonly runId: string;
-        readonly requestId: string;
-        readonly questions: ReturnType<typeof claudeUserInputQuestions>;
-        readonly input: Record<string, unknown>;
-        readonly resolve: (answers: Record<string, string>) => void;
-        readonly reject: (message?: string) => void;
-        readonly timer: NodeJS.Timeout;
-    }>;
-}
-type ClaudeDiscoveredSession = NativeSessionHistory | {
-    readonly externalSessionId: string;
-    readonly cwd: string;
-    readonly title?: string;
-};
-export {};

package/dist/runner/codex/conversation-parser.d.ts

@@ -1,59 +0,0 @@
-import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
-export type PublicConversationItem = {
-    readonly itemId: string;
-    readonly kind: 'assistant_message' | 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
-    readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
-    readonly payload: Record<string, unknown>;
-    readonly merge?: boolean;
-    readonly append?: 'sections' | 'outputPreview' | 'outputSummary';
-};
-export * from '../../util/runner-native-session-parsers.js';
-export declare function codexOfficialConversationPage(session: NodeAgentSession, result: unknown, input: {
-    readonly cursor?: string;
-    readonly limit?: number;
-}, managedTurnForNative: (nativeTurnId: string) => NodeConversationTurn | undefined): {
-    readonly turns: readonly NodeConversationTurn[];
-    readonly nextCursor: string | null;
-} | undefined;
-export declare function codexOfficialTurn(session: NodeAgentSession, value: unknown, sequence: number, managedTurn: NodeConversationTurn | undefined): NodeConversationTurn | undefined;
-/**
- * Codex's authoritative thread records omit MAR's Node-local generated-image
- * references. Preserve those references like user-image metadata: cache expiry
- * only makes the bytes unavailable, while the conversation still renders its
- * image placeholder.
- */
-export declare function retainManagedImageAttachments(managedTurn: NodeConversationTurn, nativeTurnId: string, officialItems: readonly NodeConversationItem[]): readonly NodeConversationItem[];
-export declare function codexNativeItemIds(values: readonly unknown[]): ReadonlySet<string>;
-export declare function conversationItemNativeId(itemId: string): string | undefined;
-/** Keep a custom tool invocation and its output in one Workbench card. */
-export declare function codexOfficialItems(session: NodeAgentSession, nativeTurnId: string, values: readonly unknown[], turnSequence: number, startedAt: number | null, completedAt: number | null): NodeConversationItem[];
-export declare function codexPairedToolCallId(value: unknown): string | undefined;
-export declare function mergeCodexCustomToolItems(invocation: NodeConversationItem, result: NodeConversationItem): NodeConversationItem;
-export declare function coalesceImageGenerationItems(items: readonly NodeConversationItem[]): readonly NodeConversationItem[];
-export declare function codexPlanText(value: Record<string, unknown>): string | undefined;
-/**
- * A final Claude tagged Plan Mode plan is fully wrapped in `<proposed_plan>` tags;
- * text with missing or unclosed tags remains a regular assistant message.
- */
-export declare function codexOfficialItem(session: NodeAgentSession, nativeTurnId: string, value: unknown, turnSequence: number, itemSequence: number, startedAt: number | null, completedAt: number | null): NodeConversationItem | undefined;
-export declare function codexLiveConversationItem(value: Record<string, unknown>, completed: boolean, imageAttachments?: readonly Record<string, unknown>[]): PublicConversationItem | undefined;
-export declare function codexImageAttachments(value: unknown): readonly NodeMessageAttachmentInput[];
-export declare function codexUserInputQuestions(value: unknown): readonly {
-    readonly id: string;
-    readonly prompt: string;
-    readonly options: readonly {
-        readonly value: string;
-        readonly label: string;
-        readonly description: string | null;
-    }[];
-    readonly allowOther: boolean;
-}[];
-export declare function codexItemStatus(value: unknown, completed: boolean): PublicConversationItem['status'];
-export declare function codexContentText(value: unknown): string;
-export declare function codexCompactJson(value: unknown): string;
-export declare function codexToolOutputSummary(value: unknown): string;
-/** App Server custom output is an array of text blocks, not JSON to show verbatim. */
-export declare function codexToolOutput(value: unknown): unknown;
-export declare function codexVisibleToolText(value: string): string;
-export declare function isCodexImageBlock(value: unknown): boolean;
-export * from '../../util/node-operation-parsers.js';

package/dist/runner/codex/managed-run-controller.d.ts

@@ -1,90 +0,0 @@
-import type { NodeEnvelope, RunnerCommandDescriptor, RunnerCommandState } from '@myagentroam/protocol';
-import type { NodeAgentSession, NodeMessageAttachmentInput } from '../../database.js';
-import type { CodexComposerInput } from '../../codex-app-server.js';
-import type { FakeRunnerStatus } from '../../fake-runner.js';
-import { CodexRunner } from '../codex-runner.js';
-type CodexImageInput = Extract<CodexComposerInput, {
-    readonly type: 'localImage';
-}>;
-interface CodexNotificationRun {
-    readonly threadId: string;
-    readonly turnId?: string;
-}
-export declare function resolveCodexNotificationRun<T extends CodexNotificationRun>(runs: ReadonlyMap<string, T>, input: {
-    readonly threadId?: string;
-    readonly turnId?: string;
-    readonly allowUnboundFallback?: boolean;
-}): readonly [string, T] | undefined;
-export interface CodexManagedRunHost<TAttachment> {
-    readonly available: () => boolean;
-    readonly intercepted: () => boolean;
-    readonly active: ReadonlySet<string>;
-    addActive(runId: string): void;
-    removeActive(runId: string): void;
-    adopt(input: {
-        runId: string;
-        sessionId: string;
-        runner: 'codex';
-        cwd: string;
-        externalSessionId?: string;
-    }): void;
-    session(sessionId: string): NodeAgentSession | undefined;
-    runStatus(runId: string): string | undefined;
-    run(runId: string): unknown;
-    interrupted(runId: string): boolean;
-    parseAttachments(value: unknown): readonly TAttachment[];
-    materialize(runId: string, attachments: readonly TAttachment[]): Promise<readonly CodexImageInput[]>;
-    completeCancelled(runId: string, cwd: string): boolean;
-    promoteSession(sessionId: string, nativeSessionId: string): void;
-    send(type: string, payload: unknown): void;
-    emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
-    cancel(runId: string, threadId: string, turnId: string, cwd: string, status: 'INTERRUPTED' | 'CANCELLED'): Promise<void>;
-    createApproval(input: {
-        runId: string;
-        approvalId: string;
-        payload: unknown;
-        expiresAt: number;
-    }): void;
-    publishApproval(input: {
-        runId: string;
-        approvalId: string;
-        payload: unknown;
-        expiresAt: number;
-    }): void;
-    emitItem(runId: string, item: {
-        readonly itemId: string;
-        readonly kind: 'reasoning_summary' | 'tool_call' | 'command_execution' | 'user_input_request' | 'assistant_message' | 'plan' | 'context_compaction' | 'file_change' | 'error' | 'unknown';
-        readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'DECLINED';
-        readonly payload: Record<string, unknown>;
-        readonly merge?: boolean;
-        readonly append?: 'sections' | 'outputPreview' | 'outputSummary';
-    }): void;
-    appendImages(runId: string, images: readonly NodeMessageAttachmentInput[]): readonly Record<string, unknown>[];
-    syncTitle(sessionId: string, nativeSessionId: string, cwd: string): Promise<void>;
-    commandState(sessionId: string, commandId: string): RunnerCommandState | undefined;
-    setCommandState(sessionId: string, state: RunnerCommandState): void;
-    clearCommandState(sessionId: string, commandId: string): void;
-    commandStates(sessionId: string): readonly RunnerCommandState[];
-    hasActiveSessionLease(sessionId: string): boolean;
-    fast(input: string): Promise<unknown>;
-}
-export declare class CodexManagedRunController<TAttachment> {
-    private readonly runner;
-    private readonly host;
-    constructor(runner: CodexRunner, host: CodexManagedRunHost<TAttachment>);
-    executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, input: string, context: {
-        readonly secretEnvironment: Readonly<Record<string, string>>;
-    }): Promise<unknown>;
-    private compact;
-    handleNotification(notification: {
-        readonly method: string;
-        readonly params: unknown;
-        readonly requestId?: string | number;
-    }): void;
-    private requestApproval;
-    private requestUserInput;
-    start(envelope: NodeEnvelope): void;
-    private run;
-    private emitError;
-}
-export {};

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

@@ -1,103 +0,0 @@
-import { CodexAppServerClient, type CodexComposerInput, type CodexRunConfiguration, type JsonRpcNotification } from '../codex-app-server.js';
-import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentationContext, type RunnerSessionPresentation, type RunnerProjectionTitleInput } from './abstract-runner.js';
-import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
-import type { NodeAgentSession, NodeDatabase } from '../database.js';
-import type { NodeWorkspace } from '../database.js';
-export declare class CodexRunner extends AbstractRunner<'codex'> {
-    private readonly client;
-    private readonly profileClientFactory;
-    readonly name: "codex";
-    readonly discoveryScope: "ALL_WORKSPACES";
-    readonly execution: CodexExecutionState;
-    private fastEnabled;
-    private environmentFingerprint;
-    private readonly environmentRuns;
-    private readonly profileCache;
-    private readonly profileCacheTimers;
-    private readonly profileRefreshes;
-    private readonly profileClients;
-    private readonly profileKeyByEnvironment;
-    private latestProfileCache;
-    private selectedProfileKey;
-    constructor(client?: CodexAppServerClient, profileClientFactory?: () => CodexAppServerClient);
-    profile(capabilities: NodeCapabilities): RunnerProfile;
-    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
-    private refreshCodexProfile;
-    private selectCachedProfile;
-    private cacheProfile;
-    private fetchCodexProfile;
-    available(capabilities: NodeCapabilities): boolean;
-    executeGlobalCommand(commandId: string, input: string): unknown;
-    serviceTier(): 'fast' | undefined;
-    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
-    usesRunnerTitleForRename(): boolean;
-    renameNative(session: NodeAgentSession, input: {
-        readonly title?: string | null;
-        readonly pinned?: boolean;
-    }, database: NodeDatabase): Promise<void>;
-    projectedRunnerTitle(metadata: ReturnType<NodeDatabase['getNativeSessionMetadata']>, input: RunnerProjectionTitleInput, database: NodeDatabase | undefined): string | null;
-    readOfficialConversation(session: NodeAgentSession, input: {
-        readonly cursor?: string;
-        readonly limit?: number;
-    }, managedTurn: (nativeTurnId: string) => import('../database.js').NodeConversationTurn | undefined): Promise<{
-        readonly turns: readonly import("../database.js").NodeConversationTurn[];
-        readonly nextCursor: string | null;
-    } | undefined>;
-    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
-    readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "MANAGED_ACTIVE" | "EXTERNAL_ACTIVE" | "IDLE" | undefined>;
-    acceptsTruncatedNativeHistory(): boolean;
-    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
-    nativeImageRoots(session: NodeAgentSession): readonly string[];
-    managedRunForNativeTurn(nativeTurnId: string): string | undefined;
-    protected profileForValidation(): RunnerProfile;
-    defaultConfiguration(_workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, _workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
-    private profileCacheForEnvironment;
-    resumeExternal(external: NodeAgentSession, context: ExternalResumeContext, force?: boolean): Promise<ExternalResumeResult>;
-    discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
-    readContextUsage(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeCodexContextUsage | undefined>;
-    presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
-    onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
-    start(): Promise<void>;
-    recoverMissingRollout(runId: string, error: unknown): Promise<boolean>;
-    prepareEnvironment(environment: Readonly<Record<string, string>>, runId: string): void;
-    releaseEnvironment(runId: string): void;
-    stop(): void;
-    request(method: string, params: unknown): Promise<unknown>;
-    respond(requestId: string | number, result: unknown): void;
-    listThreads(): Promise<unknown>;
-    readThread(threadId: string, includeTurns?: boolean): Promise<unknown>;
-    startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
-    forkThread(threadId: string, cwd: string, lastTurnId: string, configuration?: CodexRunConfiguration): Promise<unknown>;
-    forkNative(session: NodeAgentSession, boundary: string | null, title: string): Promise<string>;
-    resumeThread(threadId: string, cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
-    startTurn(threadId: string, text: string, cwd: string, configuration?: CodexRunConfiguration, attachments?: readonly Extract<CodexComposerInput, {
-        readonly type: 'localImage';
-    }>[]): Promise<unknown>;
-    interruptTurn(threadId: string, turnId: string): Promise<unknown>;
-    setThreadName(threadId: string, name: string): Promise<unknown>;
-    listCollaborationModes(): Promise<unknown>;
-}
-export declare class CodexExecutionState {
-    readonly runs: Map<string, {
-        sessionId: string;
-        threadId: string;
-        turnId?: string;
-        cwd: string;
-        refreshTitle?: boolean;
-    }>;
-    readonly managedTurns: Map<string, {
-        sessionId: string;
-        runId: string;
-    }>;
-    readonly approvals: Map<string, string | number>;
-    readonly userInputs: Map<string, {
-        readonly runId: string;
-        readonly requestId: string | number;
-        readonly questions: readonly {
-            readonly id: string;
-            readonly options: readonly string[];
-            readonly allowOther: boolean;
-        }[];
-    }>;
-}

package/dist/runner/fake-test-runner.d.ts

@@ -1,26 +0,0 @@
-import { FakeRunner, type FakeRunnerCallbacks, type FakeRunnerStep } from '../fake-runner.js';
-import { AbstractRunner } from './abstract-runner.js';
-import type { RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
-import type { NodeAgentSession } from '../database.js';
-import type { ExternalResumeResult } from './abstract-runner.js';
-/** Registered only by tests; never contributes a production Runner Profile. */
-export declare class FakeTestRunner extends AbstractRunner<'fake'> {
-    private readonly runner;
-    readonly name: "fake";
-    readonly discoveryScope: "WORKSPACE_REQUIRED";
-    readonly advertised = false;
-    readonly interceptsRuns = true;
-    constructor(runner: FakeRunner);
-    stop(): void;
-    profile(): undefined;
-    available(): boolean;
-    protected profileForValidation(): RunnerProfile;
-    defaultConfiguration(): RunnerDefaultConfiguration;
-    resumeExternal(): Promise<ExternalResumeResult>;
-    discoverSessions(): Promise<readonly NodeAgentSession[]>;
-    readContextUsage(): Promise<undefined>;
-    start(runId: string, script: readonly FakeRunnerStep[], callbacks: FakeRunnerCallbacks): Promise<void>;
-    decide(runId: string, approvalId: string, decision: 'APPROVED' | 'REJECTED'): boolean;
-    interrupt(runId: string): boolean;
-    cancel(runId: string): boolean;
-}

package/dist/runner/opencode/conversation-parser.d.ts

@@ -1,31 +0,0 @@
-import type { NodeAgentSession, NodeConversationTurn } from '../../database.js';
-export declare function openCodeConversationPage(session: NodeAgentSession, messages: readonly unknown[], input: {
-    readonly cursor?: string;
-    readonly limit?: number;
-}, managedTurn: (nativeTurnId: string) => NodeConversationTurn | undefined): {
-    readonly turns: readonly NodeConversationTurn[];
-    readonly nextCursor: string | null;
-} | undefined;
-export declare function openCodeQuestions(value: unknown): {
-    id: string;
-    prompt: string;
-    input: string;
-    options: {
-        value: string;
-        label: string;
-        description: string | null;
-    }[];
-    allowOther: boolean;
-    multiSelect: boolean;
-}[];
-export declare function openCodePatchToolPayload(): {
-    namespace: string;
-    toolName: string;
-    title: string;
-    inputSummary: null;
-    outputSummary: string;
-    outputSummaryCode: string;
-    progressLabel: null;
-    errorCode: null;
-    truncated: boolean;
-};