@myagentroam/node 0.1.3 → 0.1.6

package/dist/runner/claude-code-runner.js

@@ -0,0 +1,286 @@
+import { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
+import { AbstractRunner } from './abstract-runner.js';
+import { claudeDefaultModel, declaredRunnerProfiles } from '../runner-profiles.js';
+import { withClaudePlanTag } from '../runner-command-engine.js';
+import { discoverNativeSessions, readNativeSession, readClaudeNativeContextUsage } from '../native-session-history.js';
+import { claudeDiscoveredSession, deduplicateDirectSessions, externalResumeFailureDetail, isNativeHistory, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+export class ClaudeCodeRunner extends AbstractRunner {
+    client;
+    environment;
+    name = 'claude-code';
+    discoveryScope = 'WORKSPACE_REQUIRED';
+    execution = new ClaudeExecutionState();
+    constructor(client = new ClaudeAgentSdkAdapter(), environment = process.env) {
+        super();
+        this.client = client;
+        this.environment = environment;
+    }
+    profile(capabilities) {
+        return declaredRunnerProfiles({
+            codexAvailable: capabilities.codex.available,
+            claudeCodeAvailable: capabilities.claudeCode.available,
+            environment: this.environment,
+            openCodeAvailable: capabilities.openCode?.available === true
+        }).find((profile) => profile.runner === this.name);
+    }
+    available(capabilities) {
+        return capabilities.claudeCode.available;
+    }
+    profileForValidation() {
+        return this.profile({
+            platform: 'linux',
+            architecture: 'validation',
+            nodeAppVersion: 'validation',
+            nodeVersion: 'validation',
+            codex: { available: false },
+            claudeCode: { available: true },
+            openCode: { available: false }
+        });
+    }
+    defaultConfiguration() {
+        return {
+            runner: this.name,
+            model: claudeDefaultModel(this.environment),
+            effort: 'medium',
+            access: 'default'
+        };
+    }
+    async resumeExternal(external, context) {
+        if (external.runner !== this.name ||
+            external.nativeControl !== 'EXTERNAL' ||
+            external.externalSessionId === null ||
+            !context.available)
+            return {
+                failureCode: 'RUNNER_UNAVAILABLE',
+                messageFailureCode: 'SESSION_RESUME_REJECTED'
+            };
+        const nativeAlias = context.managedAliasFor(external);
+        if (nativeAlias !== undefined)
+            return { session: context.ensureConfiguration(nativeAlias), activity: 'IDLE' };
+        const existing = context.currentResumed(external.id);
+        if (existing !== undefined)
+            return { session: context.ensureConfiguration(existing), activity: 'IDLE' };
+        try {
+            const sessionInfo = await this.sessionInfo(external.externalSessionId, external.cwd);
+            if (sessionInfo === undefined)
+                return {
+                    failureCode: 'RUNNER_SESSION_NOT_FOUND',
+                    messageFailureCode: 'SESSION_RESUME_REJECTED'
+                };
+            const workspacePath = context.workspacePath(external.workspaceId);
+            if (workspacePath === undefined ||
+                (typeof sessionInfo.cwd === 'string' && !isWithinWorkspace(sessionInfo.cwd, workspacePath)))
+                return {
+                    failureCode: 'RUNNER_SESSION_WORKSPACE_MISMATCH',
+                    messageFailureCode: 'SESSION_RESUME_REJECTED'
+                };
+            const resumed = context.currentResumed(external.id);
+            if (resumed !== undefined)
+                return { session: context.ensureConfiguration(resumed), activity: 'IDLE' };
+            const projection = context.projectionFor(external);
+            const session = projection === undefined ? context.create(external) : context.promote(projection.id);
+            if (session === undefined)
+                return {
+                    failureCode: 'RUNNER_RESUME_FAILED',
+                    messageFailureCode: 'SESSION_RESUME_REJECTED'
+                };
+            const configured = context.ensureConfiguration(session);
+            context.rememberManagedNative(external.externalSessionId, configured.id);
+            return { session: configured, activity: 'IDLE' };
+        }
+        catch (error) {
+            return {
+                failureCode: 'RUNNER_RESUME_FAILED',
+                messageFailureCode: 'SESSION_RESUME_REJECTED',
+                failureDetail: externalResumeFailureDetail(error)
+            };
+        }
+    }
+    async discoverSessions(context, workspace) {
+        const sessions = [];
+        for (const target of workspace === undefined ? context.workspaces : [workspace]) {
+            let official = [];
+            try {
+                official = await this.listSessions(target.path);
+            }
+            catch {
+                // Native transcripts remain authoritative when SDK listing is unavailable.
+            }
+            const native = await discoverNativeSessions(this.name, target.path);
+            sessions.push(...this.projectDiscoveredSessions(context, target, [
+                ...official.flatMap((value) => {
+                    const parsed = claudeDiscoveredSession(value, target.path);
+                    return parsed === undefined ? [] : [parsed];
+                }),
+                ...native
+            ]));
+        }
+        return deduplicateDirectSessions(sessions);
+    }
+    readContextUsage(session) {
+        return session.externalSessionId === null
+            ? Promise.resolve(undefined)
+            : readClaudeNativeContextUsage(session.cwd, session.externalSessionId);
+    }
+    forkNative(session, boundary, title) {
+        if (session.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        return boundary === null
+            ? Promise.resolve(null)
+            : this.client.forkSession(session.externalSessionId, session.cwd, boundary, title);
+    }
+    presentSession(session, capabilities, context) {
+        if (capabilities.claudeCode.available && session.nativeControl === 'MAR_MANAGED') {
+            const runtimeCapabilities = [
+                'history.read',
+                'events.live',
+                'turn.start',
+                'turn.queue',
+                'turn.interrupt',
+                'run.cancel',
+                'approval.respond',
+                'session.rename',
+                'session.remove',
+                'session.pin',
+                ...(session.externalSessionId === null ? [] : ['session.rewind'])
+            ];
+            return {
+                activity: context.managedActive ? 'MANAGED_ACTIVE' : 'IDLE',
+                control: {
+                    level: 'MANAGED',
+                    capabilities: ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
+                },
+                commandStates: context.commandStates,
+                runtime: { level: 'MANAGED', capabilities: runtimeCapabilities, reasonCode: null }
+            };
+        }
+        if (capabilities.claudeCode.available && session.externalSessionId !== null) {
+            const runtimeCapabilities = [
+                'history.read',
+                'turn.start',
+                'session.rename',
+                'session.remove',
+                'session.pin',
+                'session.rewind'
+            ];
+            return {
+                activity: 'IDLE',
+                control: { level: 'RESUMABLE', capabilities: ['history.read', 'turn.start'] },
+                commandStates: context.commandStates,
+                runtime: { level: 'RESUMABLE', capabilities: runtimeCapabilities, reasonCode: null }
+            };
+        }
+        const runtimeCapabilities = [
+            'history.read',
+            'events.live',
+            'session.rename',
+            'session.remove',
+            'session.pin'
+        ];
+        return {
+            activity: 'UNAVAILABLE',
+            control: { level: 'OBSERVE_ONLY', capabilities: ['history.read', 'events.live'] },
+            commandStates: context.commandStates,
+            runtime: {
+                level: 'OBSERVE_ONLY',
+                capabilities: runtimeCapabilities,
+                reasonCode: 'EXTERNAL_SESSION_OBSERVE_ONLY'
+            }
+        };
+    }
+    prepareMessageInput(input, collaborationMode) {
+        return collaborationMode === 'plan' ? withClaudePlanTag(input) : input;
+    }
+    channelToken(sessionId) {
+        return [...this.execution.runs.values()].find((run) => run.marSessionId === sessionId)?.gate
+            .token;
+    }
+    deliverChannel(sessionId, messageId, senderId, token, content, notify) {
+        const found = [...this.execution.runs.entries()].find(([, value]) => value.marSessionId === sessionId);
+        if (found === undefined)
+            return 'REJECTED';
+        const [runId, active] = found;
+        const prior = active.gate.delivery(messageId);
+        const accepted = active.gate.accept({ id: messageId, senderId, token, content });
+        if (accepted === 'REJECTED') {
+            if (prior === undefined)
+                notify(runId, messageId, 'REJECTED');
+            return 'REJECTED';
+        }
+        if (prior === undefined && accepted === 'PENDING_RECEIPT') {
+            void active.handle.deliver(content).then(() => notify(runId, messageId, active.gate.acknowledge({ messageId, result: 'STEERED' })), () => notify(runId, messageId, active.gate.acknowledge({ messageId, result: 'REJECTED' })));
+        }
+        return accepted;
+    }
+    managedAliasId(nativeSessionId) {
+        return this.execution.managedSessionByNativeId.get(nativeSessionId);
+    }
+    nativeAliasesFor(managedSessionId) {
+        return [...this.execution.managedSessionByNativeId]
+            .filter(([, sessionId]) => sessionId === managedSessionId)
+            .map(([nativeSessionId]) => nativeSessionId);
+    }
+    forgetNativeAlias(nativeSessionId) {
+        this.execution.managedSessionByNativeId.delete(nativeSessionId);
+        this.execution.managedNativeIds.delete(nativeSessionId);
+    }
+    rememberManagedNative(session, nativeSessionId) {
+        this.execution.managedNativeIds.add(nativeSessionId);
+        this.execution.managedSessionByNativeId.set(nativeSessionId, session.id);
+    }
+    async readManagedRunnerTitle(session, nativeSessionId) {
+        let history = await readNativeSession(this.name, session.cwd, nativeSessionId);
+        if (history === undefined) {
+            const discovered = await discoverNativeSessions(this.name, session.cwd);
+            history = discovered.find((candidate) => candidate.externalSessionId === nativeSessionId);
+        }
+        return history?.title;
+    }
+    projectDiscoveredSessions(context, workspace, discovered) {
+        const sessions = [];
+        for (const item of discovered) {
+            if (!isWithinWorkspace(item.cwd, workspace.path))
+                continue;
+            const session = context.createProjection({
+                workspace,
+                runner: this.name,
+                externalSessionId: item.externalSessionId,
+                cwd: item.cwd,
+                ...(item.title === undefined ? {} : { title: item.title }),
+                ...(isNativeHistory(item) ? { lastActivityAt: latestNativeActivity(item) } : {})
+            });
+            const index = sessions.findIndex((candidate) => candidate.id === session.id);
+            if (index < 0)
+                sessions.push(session);
+            else if (session.lastActivityAt >= sessions[index].lastActivityAt) {
+                const existing = sessions[index];
+                sessions[index] = {
+                    ...session,
+                    runnerTitle: session.runnerTitle ?? existing.runnerTitle,
+                    titleSource: session.runnerTitle === null ? existing.titleSource : session.titleSource
+                };
+            }
+        }
+        return deduplicateDirectSessions(sessions);
+    }
+    stop() { }
+    start(input) {
+        return this.client.start(input);
+    }
+    startChannel(input) {
+        return this.client.startChannel(input);
+    }
+    listSessions(cwd) {
+        return this.client.listSessions(cwd);
+    }
+    sessionInfo(sessionId, cwd) {
+        return this.client.sessionInfo(sessionId, cwd);
+    }
+}
+export class ClaudeExecutionState {
+    runs = new Map();
+    managedNativeIds = new Set();
+    managedSessionByNativeId = new Map();
+    approvals = new Map();
+    userInputs = new Map();
+}

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

@@ -0,0 +1,59 @@
+import type { NodeAgentSession, NodeConversationItem, NodeConversationTurn, NodeMessageAttachmentInput } from '../../database.js';
+export type PublicConversationItem = {
+    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';
+};
+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;
+/**
+ * Claude 标签式 Plan Mode 的最终计划以 `<proposed_plan>` 完整包裹输出；
+ * 未闭合或缺失标签的文本保持普通 assistant 消息。
+ */
+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';