@myagentroam/node 0.1.3 → 0.1.6

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

@@ -0,0 +1,80 @@
+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';
+}>;
+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' | 'plan' | 'context_compaction' | 'file_change' | '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>[];
+    captureSnapshot(runId: string, cwd: string): Promise<void>;
+    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[];
+    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;
+}
+export {};

package/dist/runner/codex/managed-run-controller.js

@@ -0,0 +1,388 @@
+import { extractId } from '../../util/runner-native-session-parsers.js';
+import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { boundedConversationItemId, codexImageAttachments, codexLiveConversationItem, codexUserInputQuestions, compactRunnerText, isPlainRecord } from './conversation-parser.js';
+export class CodexManagedRunController {
+    runner;
+    host;
+    constructor(runner, host) {
+        this.runner = runner;
+        this.host = host;
+    }
+    async executeCommand(session, command, input, context) {
+        if (command.id === 'plan') {
+            const environmentLeaseId = crypto.randomUUID();
+            this.runner.prepareEnvironment(context.secretEnvironment, environmentLeaseId);
+            let modes;
+            try {
+                await this.runner.start();
+                modes = await this.runner.listCollaborationModes();
+            }
+            finally {
+                this.runner.releaseEnvironment(environmentLeaseId);
+            }
+            if (!isPlainRecord(modes) ||
+                !Array.isArray(modes.data) ||
+                !modes.data.some((mode) => isPlainRecord(mode) && mode.mode === 'plan'))
+                throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+            const current = this.host.commandState(session.id, 'plan');
+            if (current?.active)
+                this.host.clearCommandState(session.id, 'plan');
+            else
+                this.host.setCommandState(session.id, {
+                    commandId: 'plan',
+                    active: true,
+                    label: 'Plan Mode',
+                    detail: '后续消息将以协作规划模式运行。',
+                    closable: true,
+                    closeInput: '/plan',
+                    continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+                });
+            return { command: command.id, states: this.host.commandStates(session.id) };
+        }
+        const threadId = session.externalSessionId;
+        if (threadId === null || session.nativeControl !== 'MAR_MANAGED')
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        if (command.id === 'compact') {
+            const runId = crypto.randomUUID();
+            this.runner.prepareEnvironment(context.secretEnvironment, runId);
+            try {
+                await this.runner.start();
+                return await this.compact(session, threadId, runId);
+            }
+            catch (error) {
+                this.runner.releaseEnvironment(runId);
+                throw error;
+            }
+        }
+        if (command.id === 'fast')
+            return this.host.fast(input);
+        throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+    }
+    async compact(session, threadId, runId) {
+        this.host.adopt({
+            runId,
+            sessionId: session.id,
+            runner: 'codex',
+            cwd: session.cwd,
+            externalSessionId: threadId
+        });
+        this.host.addActive(runId);
+        this.runner.execution.runs.set(runId, {
+            sessionId: session.id,
+            threadId,
+            cwd: session.cwd,
+            refreshTitle: false
+        });
+        this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
+        try {
+            await this.runner.request('thread/compact/start', { threadId });
+            return {
+                command: 'compact',
+                run: this.host.run(runId),
+                states: this.host.commandStates(session.id)
+            };
+        }
+        catch (error) {
+            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_COMPACT_FAILED' }, 'FAILED');
+            this.runner.execution.runs.delete(runId);
+            this.runner.releaseEnvironment(runId);
+            this.host.removeActive(runId);
+            throw error;
+        }
+    }
+    handleNotification(notification) {
+        const params = isPlainRecord(notification.params) ? notification.params : {};
+        const turn = isPlainRecord(params.turn) ? params.turn : undefined;
+        const turnId = typeof params.turnId === 'string'
+            ? params.turnId
+            : typeof turn?.id === 'string'
+                ? turn.id
+                : undefined;
+        const threadId = typeof params.threadId === 'string' ? params.threadId : undefined;
+        if (turnId === undefined && threadId === undefined)
+            return;
+        const run = [...this.runner.execution.runs.entries()].find(([, value]) => (turnId !== undefined && value.turnId === turnId) ||
+            (threadId !== undefined && value.threadId === threadId));
+        if (run === undefined)
+            return;
+        const [runId] = run;
+        if (notification.method === 'turn/started' && turnId !== undefined) {
+            const active = this.runner.execution.runs.get(runId);
+            if (active !== undefined)
+                this.runner.execution.runs.set(runId, { ...active, turnId });
+            this.host.emit(runId, 'run.running', { threadId, turnId }, 'RUNNING');
+            return;
+        }
+        if (notification.requestId !== undefined &&
+            (notification.method === 'item/commandExecution/requestApproval' ||
+                notification.method === 'item/fileChange/requestApproval')) {
+            this.requestApproval(runId, {
+                ...notification,
+                requestId: notification.requestId
+            });
+            return;
+        }
+        if (notification.requestId !== undefined &&
+            notification.method === 'item/tool/requestUserInput') {
+            this.requestUserInput(runId, notification.requestId, params);
+            return;
+        }
+        if (notification.method === 'item/agentMessage/delta' && typeof params.delta === 'string') {
+            this.host.emit(runId, 'text.delta', { text: params.delta });
+            return;
+        }
+        if (notification.method === 'item/reasoning/summaryTextDelta' &&
+            typeof params.itemId === 'string' &&
+            typeof params.delta === 'string') {
+            const index = typeof params.summaryIndex === 'number' && Number.isInteger(params.summaryIndex)
+                ? params.summaryIndex
+                : 0;
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('codex', params.itemId),
+                kind: 'reasoning_summary',
+                status: 'IN_PROGRESS',
+                payload: { sections: [{ index, text: compactRunnerText(params.delta, 10_000) }] },
+                merge: true,
+                append: 'sections'
+            });
+            return;
+        }
+        if (notification.method === 'item/commandExecution/outputDelta' &&
+            typeof params.itemId === 'string' &&
+            typeof params.delta === 'string') {
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('codex', params.itemId),
+                kind: 'command_execution',
+                status: 'IN_PROGRESS',
+                payload: { outputPreview: compactRunnerText(params.delta, 10_000) },
+                merge: true,
+                append: 'outputPreview'
+            });
+            return;
+        }
+        if (notification.method === 'item/mcpToolCall/progress' &&
+            typeof params.itemId === 'string' &&
+            typeof params.message === 'string') {
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('codex', params.itemId),
+                kind: 'tool_call',
+                status: 'IN_PROGRESS',
+                payload: { progressLabel: compactRunnerText(params.message, 500) },
+                merge: true
+            });
+            return;
+        }
+        if ((notification.method === 'item/started' || notification.method === 'item/completed') &&
+            isPlainRecord(params.item)) {
+            const attachments = this.host.appendImages(runId, codexImageAttachments(params.item));
+            const item = codexLiveConversationItem(params.item, notification.method === 'item/completed', attachments);
+            if (item !== undefined)
+                this.host.emitItem(runId, item);
+            return;
+        }
+        if (notification.method === 'turn/completed') {
+            const status = turn?.status;
+            const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
+            this.host.emit(runId, 'run.completed', { status: status ?? 'unknown' }, terminal);
+            const active = this.runner.execution.runs.get(runId);
+            const titleRefresh = active === undefined ||
+                active.refreshTitle === false ||
+                this.host.session(active.sessionId)?.titleSource !== 'AUTO'
+                ? undefined
+                : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
+            if (active !== undefined) {
+                void this.host.captureSnapshot(runId, active.cwd);
+            }
+            this.runner.execution.runs.delete(runId);
+            if (titleRefresh === undefined)
+                this.runner.releaseEnvironment(runId);
+            else
+                void titleRefresh.finally(() => this.runner.releaseEnvironment(runId));
+            this.host.removeActive(runId);
+        }
+    }
+    requestApproval(runId, notification) {
+        const approvalId = `codex:${notification.requestId}`;
+        const expiresAt = Date.now() + 10 * 60_000;
+        this.runner.execution.approvals.set(approvalId, notification.requestId);
+        try {
+            this.host.createApproval({
+                runId,
+                approvalId,
+                payload: { method: notification.method, params: notification.params },
+                expiresAt
+            });
+        }
+        catch {
+            this.runner.execution.approvals.delete(approvalId);
+            return;
+        }
+        this.host.publishApproval({
+            runId,
+            approvalId,
+            payload: { method: notification.method, params: notification.params },
+            expiresAt
+        });
+    }
+    requestUserInput(runId, nativeRequestId, params) {
+        const questions = codexUserInputQuestions(params.questions);
+        if (questions.length === 0) {
+            try {
+                this.runner.respond(nativeRequestId, { answers: {} });
+            }
+            catch {
+                // A disconnected App Server cannot receive a malformed-request response.
+            }
+            return;
+        }
+        const requestId = String(nativeRequestId);
+        this.runner.execution.userInputs.set(requestId, {
+            runId,
+            requestId: nativeRequestId,
+            questions: questions.map((question) => ({
+                id: question.id,
+                options: question.options.map((option) => option.value),
+                allowOther: question.allowOther
+            }))
+        });
+        this.host.emitItem(runId, {
+            itemId: boundedConversationItemId('codex-input', requestId),
+            kind: 'user_input_request',
+            status: 'PENDING',
+            payload: {
+                requestId,
+                questions: questions.map((question) => ({
+                    id: question.id,
+                    prompt: question.prompt,
+                    input: question.options.length === 0 ? 'SHORT_TEXT' : 'SINGLE_SELECT',
+                    options: question.options.map((option) => ({
+                        value: option.value,
+                        label: option.label,
+                        description: option.description
+                    })),
+                    allowOther: question.allowOther
+                }))
+            }
+        });
+    }
+    start(envelope) {
+        const payload = envelope.payload;
+        if (payload.runner !== 'codex' ||
+            typeof payload.runId !== 'string' ||
+            typeof payload.sessionId !== 'string' ||
+            typeof payload.input !== 'string' ||
+            typeof payload.cwd !== 'string' ||
+            this.host.intercepted() ||
+            this.host.active.has(payload.runId))
+            return;
+        const { runId, sessionId, input, cwd } = payload;
+        let attachments;
+        let secretEnvironment;
+        try {
+            attachments = this.host.parseAttachments(payload.attachments);
+            secretEnvironment = parseSecretEnvironment(payload.secretEnvironment);
+        }
+        catch (error) {
+            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'MESSAGE_ATTACHMENTS_INVALID' }, 'FAILED');
+            return;
+        }
+        this.host.adopt({
+            runId,
+            sessionId,
+            runner: 'codex',
+            cwd,
+            ...(typeof payload.externalSessionId === 'string'
+                ? { externalSessionId: payload.externalSessionId }
+                : {})
+        });
+        if (this.host.completeCancelled(runId, cwd))
+            return;
+        const session = this.host.session(sessionId);
+        if (!this.host.available()) {
+            this.host.emit(runId, 'run.rejected', { code: 'CODEX_UNAVAILABLE' }, 'FAILED');
+            return;
+        }
+        if (typeof payload.externalSessionId === 'string' &&
+            (session === undefined || session.nativeControl !== 'MAR_MANAGED')) {
+            this.host.emit(runId, 'run.rejected', { code: 'EXTERNAL_THREAD_OBSERVE_ONLY' }, 'FAILED');
+            return;
+        }
+        try {
+            this.runner.prepareEnvironment(secretEnvironment, runId);
+        }
+        catch (error) {
+            this.host.emit(runId, 'run.rejected', { code: error instanceof Error ? error.message : 'SECRET_ENVIRONMENT_INVALID' }, 'FAILED');
+            return;
+        }
+        this.host.addActive(runId);
+        void this.run({
+            runId,
+            sessionId,
+            input,
+            cwd,
+            externalSessionId: payload.externalSessionId,
+            model: payload.model,
+            effort: payload.effort,
+            access: payload.access,
+            collaborationMode: payload.collaborationMode,
+            serviceTier: payload.serviceTier
+        }, attachments);
+    }
+    async run(payload, attachments) {
+        const { runId, sessionId, input, cwd } = payload;
+        try {
+            await this.runner.start();
+            if (this.host.completeCancelled(runId, cwd)) {
+                this.runner.releaseEnvironment(runId);
+                return;
+            }
+            this.host.emit(runId, 'run.started', {}, 'STARTING');
+            const configuration = {
+                ...(typeof payload.model === 'string' ? { model: payload.model } : {}),
+                ...(typeof payload.effort === 'string' ? { effort: payload.effort } : {}),
+                ...(typeof payload.access === 'string' ? { access: payload.access } : {})
+            };
+            const threadResult = typeof payload.externalSessionId === 'string'
+                ? await this.runner.resumeThread(payload.externalSessionId, cwd, configuration)
+                : await this.runner.startThread(cwd, configuration);
+            if (this.host.completeCancelled(runId, cwd)) {
+                this.runner.releaseEnvironment(runId);
+                return;
+            }
+            const threadId = extractId(threadResult, 'thread');
+            let publicSessionId = sessionId;
+            if (typeof payload.externalSessionId !== 'string') {
+                this.host.promoteSession(sessionId, threadId);
+                publicSessionId = threadId;
+                this.host.send('session.external-id', { sessionId, externalSessionId: threadId });
+            }
+            this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, cwd });
+            const turnResult = await this.runner.startTurn(threadId, input, cwd, {
+                ...configuration,
+                ...(payload.collaborationMode === 'plan' || payload.collaborationMode === 'default'
+                    ? { collaborationMode: payload.collaborationMode }
+                    : {}),
+                ...(payload.serviceTier === 'fast' ? { serviceTier: 'fast' } : {})
+            }, await this.host.materialize(runId, attachments));
+            const turnId = extractId(turnResult, 'turn');
+            this.runner.execution.runs.set(runId, { sessionId: publicSessionId, threadId, turnId, cwd });
+            this.runner.execution.managedTurns.set(turnId, { sessionId: publicSessionId, runId });
+            if (this.host.runStatus(runId) === 'CANCELLING') {
+                await this.host.cancel(runId, threadId, turnId, cwd, this.host.interrupted(runId) ? 'INTERRUPTED' : 'CANCELLED');
+                this.runner.releaseEnvironment(runId);
+                return;
+            }
+            this.host.emit(runId, 'run.running', { threadId, turnId }, 'RUNNING');
+        }
+        catch (error) {
+            if (this.host.completeCancelled(runId, cwd)) {
+                this.runner.releaseEnvironment(runId);
+                return;
+            }
+            this.host.emit(runId, 'run.failed', { code: error instanceof Error ? error.message : 'CODEX_RUN_FAILED' }, 'FAILED');
+            this.runner.execution.runs.delete(runId);
+            this.runner.releaseEnvironment(runId);
+            this.host.removeActive(runId);
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+import { CodexAppServerClient, type CodexComposerInput, type CodexRunConfiguration, type JsonRpcNotification } from '../codex-app-server.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, 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;
+    readonly name: "codex";
+    readonly discoveryScope: "ALL_WORKSPACES";
+    readonly execution: CodexExecutionState;
+    private fastEnabled;
+    private environmentFingerprint;
+    private readonly environmentRuns;
+    constructor(client?: CodexAppServerClient);
+    profile(capabilities: NodeCapabilities): RunnerProfile;
+    available(capabilities: NodeCapabilities): boolean;
+    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>;
+    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>;
+    readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "MANAGED_ACTIVE" | "EXTERNAL_ACTIVE" | "IDLE" | undefined>;
+    acceptsTruncatedNativeHistory(): boolean;
+    readManagedRunnerTitle(session: NodeAgentSession, nativeSessionId: string): Promise<string | undefined>;
+    nativeImageRoot(session: NodeAgentSession): string | undefined;
+    managedRunForNativeTurn(nativeTurnId: string): string | undefined;
+    protected profileForValidation(): RunnerProfile;
+    defaultConfiguration(): RunnerDefaultConfiguration;
+    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>;
+    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;
+        }[];
+    }>;
+}