@myagentroam/node 0.9.9 → 0.9.10

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
-    "dist",
+    "dist/**/*.js",
     "README.md"
   ],
   "bin": {
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.9.9"
+    "@myagentroam/protocol": "^0.9.10"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"

package/dist/capabilities.d.ts

@@ -1,12 +0,0 @@
-import type { NodeCapabilities } from '@myagentroam/protocol';
-export declare function unavailableCapabilities(): NodeCapabilities;
-export declare function detectCapabilities(commands?: {
-    readonly codex?: string;
-    readonly claudeCode?: string;
-    readonly openCode?: string;
-}): NodeCapabilities;
-export declare function detectCapabilitiesAsync(commands?: {
-    readonly codex?: string;
-    readonly claudeCode?: string;
-    readonly openCode?: string;
-}): Promise<NodeCapabilities>;

package/dist/claude-agent-sdk.d.ts

@@ -1,92 +0,0 @@
-import { forkSession, type CanUseTool, type Options, type PermissionResult, type Query, type SDKMessage, type SDKSessionInfo, type SDKUserMessage, type SessionMessage } from '@anthropic-ai/claude-agent-sdk';
-export interface ClaudeCodeProbe {
-    readonly available: boolean;
-    readonly compatible: boolean;
-    readonly version?: string;
-    readonly authenticated: boolean;
-    readonly channel: {
-        readonly researchPreview: true;
-        readonly requiresExplicitOptIn: true;
-        readonly organizationPolicy: 'UNKNOWN';
-    };
-}
-export interface ClaudeQueryInput {
-    readonly prompt: string;
-    readonly cwd: string;
-    readonly resumeSessionId?: string;
-    readonly model?: string | null;
-    readonly effort?: string | null;
-    readonly access?: string | null;
-    readonly attachments?: readonly ClaudeImageAttachment[];
-    readonly onPermission: CanUseTool;
-    readonly onMessage: (message: SDKMessage) => void;
-    readonly onChannelReply?: (content: string) => void;
-    readonly environment?: Readonly<Record<string, string>>;
-    readonly mcpServers?: NonNullable<Options['mcpServers']>;
-    readonly personalInstructions?: string;
-}
-/** Image blocks accepted by the Claude Agent SDK message input. */
-export interface ClaudeImageAttachment {
-    readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
-    readonly dataBase64: string;
-}
-export interface ClaudeRunHandle {
-    readonly completed: Promise<void>;
-    interrupt(): Promise<void>;
-    cancel(): void;
-}
-/** A live, SDK-owned session accepts input only after the SDK consumes it. */
-export interface ClaudeChannelRunHandle extends ClaudeRunHandle {
-    deliver(content: string): Promise<void>;
-}
-/** The small injectable surface prevents tests from depending on authentication. */
-export interface ClaudeSdkBindings {
-    readonly query: (input: {
-        readonly prompt: string | AsyncIterable<SDKUserMessage>;
-        readonly options: Options;
-    }) => Query;
-    readonly listSessions: (options: {
-        readonly dir?: string;
-        readonly includeWorktrees?: boolean;
-    }) => Promise<SDKSessionInfo[]>;
-    readonly getSessionInfo: (sessionId: string, options: {
-        readonly dir?: string;
-    }) => Promise<SDKSessionInfo | undefined>;
-    readonly getSessionMessages: (sessionId: string, options: {
-        readonly dir?: string;
-    }) => Promise<SessionMessage[]>;
-    readonly forkSession?: typeof forkSession;
-}
-/**
- * Adapter for the supported Agent SDK APIs only. It neither parses nor writes
- * Claude JSONL transcripts. A caller must serialize resume operations itself.
- */
-export declare class ClaudeAgentSdkAdapter {
-    private readonly sdk;
-    constructor(sdk?: ClaudeSdkBindings);
-    start(input: ClaudeQueryInput): ClaudeRunHandle;
-    /**
-     * Opens one managed SDK stream and leaves it alive for verified Channel
-     * input. This is never used for foreign CLI/VS Code sessions.
-     */
-    startChannel(input: ClaudeQueryInput): ClaudeChannelRunHandle;
-    private startWithPrompt;
-    listSessions(cwd: string): Promise<SDKSessionInfo[]>;
-    readSession(sessionId: string, cwd: string): Promise<SessionMessage[]>;
-    forkSession(sessionId: string, cwd: string, upToMessageId: string, title: string): Promise<string>;
-    sessionInfo(sessionId: string, cwd: string): Promise<SDKSessionInfo | undefined>;
-    /**
-     * The SDK publishes the authoritative, session-specific command list in its
-     * first system/init record.  Keep the input stream empty and stop as soon as
-     * that record arrives so discovery never submits a user prompt.
-     */
-    discoverSlashCommands(cwd: string): Promise<readonly string[]>;
-}
-/**
- * Channel availability deliberately remains conservative. The CLI does not
- * expose an API to read organization allowlists, so a successful executable
- * probe must never be interpreted as permission to activate a channel.
- */
-export declare function probeClaudeCode(command?: string): ClaudeCodeProbe;
-export declare function probeClaudeCodeAsync(command?: string): Promise<ClaudeCodeProbe>;
-export declare function denyPermission(message?: string): PermissionResult;

package/dist/claude-channel.d.ts

@@ -1,28 +0,0 @@
-export type ChannelDelivery = 'PENDING_RECEIPT' | 'STEERED' | 'QUEUED_NEXT_TURN' | 'REJECTED';
-export interface ClaudeChannelMessage {
-    readonly id: string;
-    readonly senderId: string;
-    readonly token: string;
-    readonly content: string;
-}
-export interface ClaudeChannelReceipt {
-    readonly messageId: string;
-    readonly result: Exclude<ChannelDelivery, 'PENDING_RECEIPT'>;
-}
-/**
- * Per-session authorization and receipt bookkeeping for a Channel MCP plugin.
- * A transport may acknowledge only that it wrote an event; callers must wait
- * for acknowledge() before displaying a steering success.
- */
-export declare class ClaudeChannelGate {
-    readonly sessionId: string;
-    readonly token: string;
-    private readonly expiresAt;
-    private readonly now;
-    private readonly allowedSenders;
-    private readonly deliveries;
-    constructor(sessionId: string, token?: string, senders?: readonly string[], expiresAt?: number, now?: () => number);
-    accept(message: ClaudeChannelMessage): ChannelDelivery;
-    acknowledge(receipt: ClaudeChannelReceipt): ChannelDelivery;
-    delivery(messageId: string): ChannelDelivery | undefined;
-}

package/dist/codex-app-server.d.ts

@@ -1,133 +0,0 @@
-import { type ChildProcessWithoutNullStreams } from 'node:child_process';
-export interface CodexProbe {
-    readonly available: boolean;
-    readonly version?: string;
-    readonly compatible: boolean;
-}
-/**
- * The visible control state of a Codex thread.  This deliberately models a
- * verified transport, not a guess based on a transcript file.
- */
-export type CodexSessionControlLevel = 'MANAGED' | 'SHARED_CONTROL' | 'OBSERVE_ONLY' | 'RESUMABLE' | 'UNAVAILABLE';
-export interface CodexSessionControl {
-    readonly level: CodexSessionControlLevel;
-    readonly capabilities: readonly ('history.read' | 'events.live' | 'turn.start' | 'turn.steer' | 'turn.interrupt')[];
-}
-/**
- * Maps the facts that the Node can actually establish to user-visible
- * controls.  In particular, seeing an external thread never implies that it
- * is safe to write to its active turn.
- */
-export declare function codexSessionControl(input: {
-    readonly available: boolean;
-    readonly nativeThreadId: string | null;
-    readonly nativeControl: 'MAR_MANAGED' | 'EXTERNAL';
-    readonly activeTurn: boolean;
-    readonly sharedControl?: boolean;
-}): CodexSessionControl;
-export interface JsonRpcNotification {
-    readonly method: string;
-    readonly params: unknown;
-    readonly requestId?: string | number;
-}
-export interface CodexAppServerOptions {
-    readonly command?: string;
-    readonly args?: readonly string[];
-    readonly cwd?: string;
-    readonly timeoutMs?: number;
-    /** `auto` uses a private Unix socket on Linux and stdio on Windows. */
-    readonly transport?: 'auto' | 'stdio' | 'unix';
-    readonly socketPath?: string;
-    readonly spawnProcess?: (command: string, args: readonly string[], options: {
-        readonly cwd?: string;
-        readonly env?: NodeJS.ProcessEnv;
-    }) => ChildProcessWithoutNullStreams;
-}
-export interface CodexRunConfiguration {
-    readonly model?: string | null;
-    readonly effort?: string | null;
-    readonly access?: string | null;
-    readonly serviceTier?: 'fast';
-    readonly collaborationMode?: 'default' | 'plan';
-    readonly mcpServers?: unknown;
-    readonly developerInstructions?: string;
-}
-interface CodexRpcErrorPayload {
-    readonly code?: unknown;
-    readonly message?: unknown;
-    readonly data?: unknown;
-}
-export declare class CodexAppServerRpcError extends Error {
-    readonly code: unknown;
-    readonly rpcMessage: string;
-    readonly data: unknown;
-    constructor(payload: CodexRpcErrorPayload);
-}
-export declare function isCodexRolloutMissingError(error: unknown): boolean;
-/** Public App Server turn inputs supported by the Workbench Composer. */
-export type CodexComposerInput = {
-    readonly type: 'text';
-    readonly text: string;
-} | {
-    readonly type: 'localImage';
-    readonly path: string;
-};
-/**
- * Local JSON-RPC client for a Node-supervised Codex App Server. Linux uses a
- * private Unix socket by default; Windows uses stdio. Neither is exposed to
- * MAR Server or the browser.
- */
-export declare class CodexAppServerClient {
-    private readonly options;
-    private child;
-    private transport;
-    private socketPath;
-    private nextId;
-    private readonly pending;
-    private readonly pendingDrainWaiters;
-    private readonly notifications;
-    private environment;
-    private starting;
-    private restarting;
-    private lifecycleRevision;
-    constructor(options?: CodexAppServerOptions);
-    configureEnvironment(environment: Readonly<Record<string, string>>): void;
-    clearEnvironment(): void;
-    start(): Promise<void>;
-    restart(): Promise<void>;
-    private startManaged;
-    private restartManaged;
-    stop(): void;
-    private stopManaged;
-    onNotification(listener: (notification: JsonRpcNotification) => void): () => void;
-    request(method: string, params: unknown): Promise<unknown>;
-    private requestDirect;
-    private waitForPendingRequests;
-    private resolvePendingDrain;
-    notify(method: string, params: unknown): void;
-    respond(requestId: string | number, result: unknown): void;
-    startThread(cwd: string, configuration?: CodexRunConfiguration): Promise<unknown>;
-    listThreads(): Promise<unknown>;
-    listCollaborationModes(): Promise<unknown>;
-    listModels(params: {
-        readonly cursor: string | null;
-        readonly limit: number;
-        readonly includeHidden: boolean;
-    }): Promise<unknown>;
-    readThread(threadId: string, includeTurns?: boolean): Promise<unknown>;
-    forkThread(threadId: string, cwd: string, lastTurnId: string, configuration?: CodexRunConfiguration): Promise<unknown>;
-    setThreadName(threadId: string, name: string): Promise<unknown>;
-    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>;
-    steerTurn(threadId: string, expectedTurnId: string, text: string): Promise<unknown>;
-    interruptTurn(threadId: string, turnId: string): Promise<unknown>;
-    private handleLine;
-    private failAll;
-    private transportMode;
-}
-export declare function probeCodex(command?: string): CodexProbe;
-export declare function probeCodexAsync(command?: string): Promise<CodexProbe>;
-export declare function isSupportedCodexVersion(version: string): boolean;
-export {};

package/dist/config.d.ts

@@ -1,18 +0,0 @@
-export interface NodeConfig {
-    readonly serverUrl: string;
-    /** Explicit roots or the platform default resolved while loading the config. */
-    readonly allowedRoots: readonly string[];
-    /** Absolute or config-relative root for SQLite, upgrades and other private Node data. */
-    readonly dataDirectory?: string;
-    readonly nodeId?: string;
-    readonly credential?: string;
-    readonly registrationToken?: string;
-}
-export declare function nodeConfigPath(): string;
-export declare function loadNodeConfig(path?: string): Promise<NodeConfig>;
-/** Uses the Node service account's scope when no Workspace roots are configured. */
-export declare function defaultAllowedRoots(platform?: NodeJS.Platform, homePath?: string, currentDirectory?: string): readonly string[];
-export declare function nodeDatabasePath(config: NodeConfig, configPath?: string): string;
-export declare function nodeDataDirectory(config: NodeConfig, configPath?: string): string;
-/** Credentials are always written with owner-only POSIX permissions where supported. */
-export declare function saveNodeConfig(config: NodeConfig, path?: string): Promise<void>;

package/dist/connector/node-connector-options.d.ts

@@ -1,27 +0,0 @@
-import type { NodeCapabilities } from '@myagentroam/protocol';
-import type { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
-import type { CodexAppServerClient } from '../codex-app-server.js';
-import type { NodeConfig } from '../config.js';
-import type { NodeDatabase } from '../database.js';
-import type { FakeRunner, FakeRunnerStep } from '../fake-runner.js';
-import type { RunnerUsageReader } from '../runner-usage.js';
-import type { TerminalManager } from '../terminal.js';
-import type { OpenCodeServerClient } from '../opencode-server.js';
-export interface NodeConnectorOptions {
-    readonly configPath?: string;
-    readonly config?: NodeConfig;
-    readonly capabilities?: NodeCapabilities;
-    readonly capabilityDetector?: () => NodeCapabilities | Promise<NodeCapabilities>;
-    readonly reconnect?: boolean;
-    readonly fakeRunner?: FakeRunner;
-    readonly fakeScript?: (input: unknown, runId: string) => readonly FakeRunnerStep[];
-    readonly codexClient?: CodexAppServerClient;
-    readonly codexProfileClientFactory?: () => CodexAppServerClient;
-    readonly claudeClient?: ClaudeAgentSdkAdapter;
-    readonly openCodeClient?: OpenCodeServerClient;
-    readonly database?: NodeDatabase;
-    readonly claudeApprovalTimeoutMs?: number;
-    readonly terminalManager?: TerminalManager;
-    readonly runnerUsageReader?: RunnerUsageReader;
-    readonly upgradeReady?: () => void;
-}

package/dist/connector/node-operation-router.d.ts

@@ -1,9 +0,0 @@
-export type NodeOperationHandler = (data: unknown) => Promise<unknown> | unknown;
-/** Exact allow-list dispatcher for protocol-defined Node operations. */
-export declare class NodeOperationRouter {
-    private readonly handlers;
-    register(operation: string, handler: NodeOperationHandler): void;
-    registerAll(handlers: Readonly<Record<string, NodeOperationHandler>>): void;
-    has(operation: string): boolean;
-    execute(operation: string, data: unknown): Promise<unknown>;
-}

package/dist/connector.d.ts

@@ -1,94 +0,0 @@
-import type { NodeConnectorOptions } from './connector/node-connector-options.js';
-export type { NodeConnectorOptions } from './connector/node-connector-options.js';
-export { nodeConnectEndpoint, validatedCapabilities } from './runner/codex/conversation-parser.js';
-export declare function nextReconnectDelay(attempt: number): number;
-export declare class NodeConnector {
-    private readonly nodeGeneration;
-    private readonly controlChannel;
-    private readonly controlMessages;
-    private readonly nodeRequests;
-    private readonly connectionLifecycle;
-    /** @internal Existing contract tests inject their socket through this boundary. */
-    private set socket(value);
-    private stopped;
-    private config;
-    private readonly capabilitiesProvided;
-    private capabilities;
-    private readonly capabilityDetector;
-    private readonly configPath;
-    private readonly reconnect;
-    private readonly claudeApprovalTimeoutMs;
-    private readonly workbenchEventService;
-    private readonly fakeRunner;
-    private readonly fakeScript;
-    private readonly runState;
-    private readonly runEventBridge;
-    private readonly workspaceCoordinator;
-    private readonly sessionState;
-    private readonly sessionIdentityService;
-    private readonly nativeSessionProjectionService;
-    private readonly conversationHistoryService;
-    private readonly conversationSegmentService;
-    private readonly runnerInteractionService;
-    private readonly runnerChannelMessages;
-    private readonly managedRunnerSessions;
-    private readonly sessionPresentationService;
-    private readonly sessionLifecycleService;
-    private readonly externalSessionResumeService;
-    private readonly sessionMessageService;
-    private readonly sessionCatalogService;
-    private readonly sessionCommandService;
-    private readonly runAttachmentService;
-    private readonly terminalChannel;
-    private readonly codexClient;
-    private readonly codexRunController;
-    private readonly claudeClient;
-    private readonly openCodeClient;
-    private readonly openCodeRunController;
-    private readonly claudeRunController;
-    private readonly runners;
-    private readonly sessionContextService;
-    private readonly runWorkbenchService;
-    private readonly sessionQueryService;
-    private readonly workspaceQueueWorkbenchService;
-    private readonly operationRouter;
-    private readonly runnerService;
-    private readonly workbenchManifestService;
-    private readonly terminalService;
-    private readonly workspaceService;
-    private readonly commandStates;
-    private readonly runnerUsageReader;
-    private readonly terminalManager;
-    private readonly upgradeCoordinator;
-    private readonly workspaceState;
-    private readonly workspaceWatchService;
-    private readonly workspaceSessionService;
-    private readonly workspaceFileService;
-    private readonly workspaceUploadService;
-    private readonly workspaceChangeService;
-    private readonly workspaceWorkbenchService;
-    private database;
-    private readonly recentRunProjectionService;
-    /** Runtime/session state is intentionally not persisted to Node SQLite. */
-    private readonly runtime;
-    private readonly metrics;
-    private readonly runEventService;
-    private readonly nativeSessionWatchService;
-    constructor(options?: NodeConnectorOptions);
-    start(): Promise<void>;
-    stop(): void;
-    /** @internal Thin compatibility delegates; all behavior remains in the extracted services. */
-    private readonly handleMessage;
-    private readonly emitRunEvent;
-    private readonly emitConversationItem;
-    private readonly emitConversationTurn;
-    private readonly emitWorkbenchEvent;
-    private readonly discoverWorkspaceSessions;
-    private readonly invalidateWorkspaceWatchTopics;
-    private readonly reconcilePersistedRuns;
-    private readonly startCapabilityRefresh;
-    private readonly refreshCapabilities;
-    private executeNodeOperation;
-    private send;
-    private sendEnvelope;
-}

package/dist/control-outbound-scheduler.d.ts

@@ -1,29 +0,0 @@
-import type { NodeEnvelope } from '@myagentroam/protocol';
-interface WritableControlSocket {
-    readonly readyState: number;
-    readonly bufferedAmount: number;
-    send(value: string): void;
-}
-/** Keeps control responses responsive while reliable Workbench events are busy. */
-export declare class ControlOutboundScheduler {
-    private readonly socket;
-    private readonly onExpired;
-    private readonly high;
-    private readonly normal;
-    private scheduled;
-    private retryTimer;
-    private expiryTimer;
-    private backpressureStartedAt;
-    private backpressureLogged;
-    private maximumHighDepth;
-    private maximumNormalDepth;
-    constructor(socket: () => WritableControlSocket | undefined, onExpired?: () => void);
-    enqueue(envelope: NodeEnvelope, priority: 'high' | 'normal'): void;
-    reset(): void;
-    private schedule;
-    private flush;
-    private waitForBackpressure;
-    private finishBackpressure;
-    private scheduleExpiry;
-}
-export {};