@myagentroam/node 0.1.4 → 0.1.6

package/dist/runner/codex-runner.js

@@ -8,6 +8,7 @@ import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
 import { codexActiveTurnId, codexOfficialConversationPage, codexThreadCwd, codexThreadActivity, deduplicateDirectSessions, externalResumeFailureDetail, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
 import { codexSessionControl } from '../codex-app-server.js';
+import { extractId } from '../util/runner-native-session-parsers.js';
 export class CodexRunner extends AbstractRunner {
     client;
     name = 'codex';
@@ -23,7 +24,8 @@ export class CodexRunner extends AbstractRunner {
     profile(capabilities) {
         return declaredRunnerProfiles({
             codexAvailable: capabilities.codex.available,
-            claudeCodeAvailable: capabilities.claudeCode.available
+            claudeCodeAvailable: capabilities.claudeCode.available,
+            openCodeAvailable: capabilities.openCode?.available === true
         }).find((profile) => profile.runner === this.name);
     }
     available(capabilities) {
@@ -105,6 +107,11 @@ export class CodexRunner extends AbstractRunner {
     acceptsTruncatedNativeHistory() {
         return false;
     }
+    async readManagedRunnerTitle(session, nativeSessionId) {
+        void session;
+        await this.start();
+        return extractCodexThreads(await this.listThreads()).find((thread) => thread.id === nativeSessionId)?.title;
+    }
     nativeImageRoot(session) {
         return session.externalSessionId === null
             ? undefined
@@ -120,7 +127,8 @@ export class CodexRunner extends AbstractRunner {
             nodeAppVersion: 'validation',
             nodeVersion: 'validation',
             codex: { available: true },
-            claudeCode: { available: false }
+            claudeCode: { available: false },
+            openCode: { available: false }
         });
     }
     defaultConfiguration() {
@@ -256,7 +264,8 @@ export class CodexRunner extends AbstractRunner {
                     ...(control.level === 'MANAGED' ? ['turn.queue', 'run.cancel', 'approval.respond'] : []),
                     'session.rename',
                     'session.remove',
-                    'session.pin'
+                    'session.pin',
+                    ...(session.externalSessionId === null ? [] : ['session.rewind'])
                 ],
                 reasonCode: control.level === 'UNAVAILABLE' ? 'RUNNER_UNAVAILABLE' : null
             }
@@ -317,6 +326,21 @@ export class CodexRunner extends AbstractRunner {
     startThread(cwd, configuration) {
         return this.client.startThread(cwd, configuration);
     }
+    forkThread(threadId, cwd, lastTurnId, configuration) {
+        return this.client.forkThread(threadId, cwd, lastTurnId, configuration);
+    }
+    async forkNative(session, boundary, title) {
+        if (session.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        await this.start();
+        const configuration = { model: session.model, effort: session.effort, access: session.access };
+        const result = boundary === null
+            ? await this.startThread(session.cwd, configuration)
+            : await this.forkThread(session.externalSessionId, session.cwd, boundary, configuration);
+        const threadId = extractId(result, 'thread');
+        await this.setThreadName(threadId, title);
+        return threadId;
+    }
     resumeThread(threadId, cwd, configuration) {
         return this.client.resumeThread(threadId, cwd, configuration);
     }
@@ -339,4 +363,3 @@ export class CodexExecutionState {
     approvals = new Map();
     userInputs = new Map();
 }
-//# sourceMappingURL=codex-runner.js.map

package/dist/runner/fake-test-runner.js

@@ -45,4 +45,3 @@ export class FakeTestRunner extends AbstractRunner {
         return this.runner.cancel(runId);
     }
 }
-//# sourceMappingURL=fake-test-runner.js.map

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

@@ -0,0 +1,27 @@
+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 openCodePatchChanges(value: unknown): {
+    path: string;
+    change: string;
+    additions: null;
+    deletions: null;
+    diffAvailable: boolean;
+}[];

package/dist/runner/opencode/conversation-parser.js

@@ -0,0 +1,217 @@
+import { basename } from 'node:path';
+import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
+export function openCodeConversationPage(session, messages, input, managedTurn) {
+    const records = messages.flatMap((value) => {
+        const entry = record(value);
+        const info = record(entry?.info);
+        return info === undefined || typeof info.id !== 'string'
+            ? []
+            : [{ info, parts: array(entry?.parts) }];
+    });
+    const parsedTurns = records
+        .filter(({ info }) => info.role === 'user')
+        .flatMap(({ info, parts }, sequence) => {
+        const assistants = records.filter((candidate) => candidate.info.role === 'assistant' && candidate.info.parentID === info.id);
+        const existing = managedTurn(info.id);
+        const turn = openCodeTurn(session, info, parts, assistants, sequence, existing);
+        const after = assistants.at(-1)?.info.id ?? info.id;
+        return turn === undefined || typeof after !== 'string' ? [] : [{ after, turn }];
+    });
+    const turns = parsedTurns.map(({ after, turn }, index) => ({
+        ...turn,
+        rewind: { before: parsedTurns[index - 1]?.after ?? null, after }
+    }));
+    if (turns.length === 0)
+        return undefined;
+    const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+    const end = pageEnd(input.cursor, session.id, turns.length);
+    const start = Math.max(0, end - limit);
+    return {
+        turns: turns.slice(start, end),
+        nextCursor: start === 0
+            ? null
+            : Buffer.from(JSON.stringify({ sessionId: session.id, end: start })).toString('base64url')
+    };
+}
+function openCodeTurn(session, user, userParts, assistants, sequence, managed) {
+    const nativeTurnId = user.id;
+    const startedAt = number(record(user.time)?.created);
+    const items = [];
+    const userText = userParts
+        .flatMap((part) => {
+        const value = record(part);
+        return value?.type === 'text' && typeof value.text === 'string' ? [value.text] : [];
+    })
+        .join('\n');
+    const localUser = managed?.items.find((item) => item.kind === 'user_message');
+    if (localUser !== undefined)
+        items.push({ ...localUser, turnId: managed.id });
+    else if (userText.length > 0)
+        items.push(item(session, nativeTurnId, `user-${nativeTurnId}`, 'user_message', 'COMPLETED', {
+            text: compactRunnerText(userText, 20_000),
+            attachments: []
+        }, startedAt, startedAt, sequence));
+    for (const assistant of assistants) {
+        const completedAt = number(record(assistant.info.time)?.completed);
+        for (const part of assistant.parts) {
+            const projected = partItem(session, nativeTurnId, part, assistant.info.mode === 'plan', startedAt, completedAt, sequence);
+            if (projected !== undefined)
+                items.push(projected);
+        }
+    }
+    if (items.length === 0)
+        return undefined;
+    const completedAt = Math.max(startedAt ?? 0, ...assistants.map(({ info }) => number(record(info.time)?.completed) ?? 0)) || startedAt;
+    const id = managed?.id ?? `${session.id}:official:${nativeTurnId}`;
+    const runId = managed?.runId ?? null;
+    return {
+        id,
+        sessionId: session.id,
+        runId,
+        userItemId: items.find((value) => value.kind === 'user_message')?.id ?? null,
+        status: assistants.some(({ info }) => info.error !== undefined) ? 'FAILED' : 'SUCCEEDED',
+        model: assistants.find(({ info }) => typeof info.modelID === 'string')?.info.modelID ?? null,
+        effort: managed?.effort ?? null,
+        access: managed?.access ?? null,
+        items: items.map((value) => ({ ...value, turnId: id, runId })),
+        startedAt,
+        completedAt
+    };
+}
+function partItem(session, turnId, raw, planMode, startedAt, completedAt, sequence) {
+    const part = record(raw);
+    if (typeof part?.id !== 'string' || typeof part.type !== 'string')
+        return undefined;
+    if ((part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string')
+        return item(session, turnId, part.id, part.type === 'text' ? (planMode ? 'plan' : 'assistant_message') : 'reasoning_summary', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', part.type === 'text'
+            ? planMode
+                ? { explanation: compactRunnerText(part.text, 20_000), steps: [] }
+                : { text: compactRunnerText(part.text, 20_000), format: 'markdown', model: null }
+            : { sections: [{ index: 0, text: compactRunnerText(part.text, 10_000) }] }, startedAt, completedAt, sequence);
+    if (part.type === 'tool' && typeof part.tool === 'string') {
+        const state = record(part.state);
+        if (part.tool === 'question' && typeof part.callID === 'string') {
+            const questions = openCodeQuestions(record(state?.input)?.questions);
+            if (questions.length > 0)
+                return item(session, turnId, part.id, 'user_input_request', 'COMPLETED', { requestId: `native:${part.callID}`, questions }, startedAt, completedAt, sequence);
+        }
+        const status = state?.status === 'completed'
+            ? 'COMPLETED'
+            : state?.status === 'error'
+                ? 'FAILED'
+                : 'IN_PROGRESS';
+        return item(session, turnId, part.id, 'tool_call', status, {
+            namespace: 'opencode',
+            toolName: compactRunnerText(part.tool, 128),
+            title: compactRunnerText(typeof state?.title === 'string' ? state.title : part.tool, 500),
+            inputSummary: compactRunnerValue(state?.input, 10_000).text || null,
+            outputSummary: typeof state?.output === 'string' ? compactRunnerText(state.output, 10_000) : null,
+            progressLabel: null,
+            errorCode: status === 'FAILED' ? 'OPENCODE_TOOL_FAILED' : null,
+            truncated: false
+        }, startedAt, completedAt, sequence);
+    }
+    if (part.type === 'compaction')
+        return item(session, turnId, part.id, 'context_compaction', 'COMPLETED', {
+            phase: 'COMPLETED',
+            summary: '上下文已整理'
+        }, startedAt, completedAt, sequence);
+    if (part.type === 'patch')
+        return item(session, turnId, part.id, 'file_change', 'COMPLETED', { changes: openCodePatchChanges(part.files) }, startedAt, completedAt, sequence);
+    if (part.type === 'step-start' || part.type === 'step-finish')
+        return undefined;
+    if (part.type === 'text' || part.type === 'reasoning')
+        return undefined;
+    return item(session, turnId, part.id, 'unknown', completedAt === null ? 'IN_PROGRESS' : 'COMPLETED', {
+        sourceEventType: `opencode:${part.type}`,
+        label: `OpenCode ${compactRunnerText(part.type, 128)}`
+    }, startedAt, completedAt, sequence);
+}
+export function openCodeQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 4)
+        return [];
+    return value.flatMap((value, index) => {
+        const question = record(value);
+        if (typeof question?.question !== 'string')
+            return [];
+        const options = (Array.isArray(question.options) ? question.options : []).flatMap((value) => {
+            const option = record(value);
+            const label = typeof option?.label === 'string' ? compactRunnerText(option.label, 500) : '';
+            return label.length === 0
+                ? []
+                : [
+                    {
+                        value: label,
+                        label,
+                        description: typeof option?.description === 'string'
+                            ? compactRunnerText(option.description, 1_000)
+                            : null
+                    }
+                ];
+        });
+        const multiSelect = question.multiple === true;
+        return [
+            {
+                id: `question-${index + 1}`,
+                prompt: compactRunnerText(question.question, 5_000),
+                input: options.length === 0 ? 'SHORT_TEXT' : multiSelect ? 'MULTI_SELECT' : 'SINGLE_SELECT',
+                options,
+                allowOther: true,
+                multiSelect
+            }
+        ];
+    });
+}
+export function openCodePatchChanges(value) {
+    return (Array.isArray(value) ? value : []).flatMap((path) => typeof path === 'string' && path.length > 0
+        ? [
+            {
+                path: basename(path),
+                change: 'MODIFIED',
+                additions: null,
+                deletions: null,
+                diffAvailable: false
+            }
+        ]
+        : []);
+}
+function item(session, turnId, nativeId, kind, status, payload, startedAt, completedAt, sequence) {
+    return {
+        id: boundedConversationItemId(`${session.id}:official:${turnId}`, nativeId),
+        sessionId: session.id,
+        turnId: `${session.id}:official:${turnId}`,
+        runId: null,
+        parentItemId: null,
+        sourceSequence: sequence,
+        revision: 1,
+        kind,
+        status,
+        payload,
+        startedAt,
+        completedAt
+    };
+}
+function pageEnd(cursor, sessionId, fallback) {
+    if (cursor === undefined)
+        return fallback;
+    try {
+        const parsed = record(JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')));
+        return parsed?.sessionId === sessionId && Number.isInteger(parsed.end)
+            ? Math.min(Math.max(Number(parsed.end), 0), fallback)
+            : fallback;
+    }
+    catch {
+        return fallback;
+    }
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}

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

@@ -0,0 +1,76 @@
+import type { NodeEnvelope, RunnerCommandDescriptor, RunnerCommandState } from '@myagentroam/protocol';
+import type { NodeAgentSession } from '../../database.js';
+import type { FakeRunnerStatus } from '../../fake-runner.js';
+import type { RunnerImageAttachment } from '../../service/run-attachment-service.js';
+import { OpenCodeRunner } from '../opencode-runner.js';
+interface OpenCodeManagedRunHost {
+    intercepted(): boolean;
+    readonly active: Set<string>;
+    parseAttachments(value: unknown): readonly RunnerImageAttachment[];
+    emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
+    emitItem(runId: string, item: OpenCodePublicItem): void;
+    adopt(input: {
+        runId: string;
+        sessionId: string;
+        runner: 'opencode';
+        cwd: string;
+        externalSessionId?: string;
+    }): void;
+    promote(sessionId: string, nativeSessionId: string): void;
+    rememberNative(nativeSessionId: string, sessionId: string): void;
+    send(type: string, payload: unknown): void;
+    captureSnapshot(runId: string, cwd: string): Promise<void>;
+    createApproval(input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly payload: unknown;
+        readonly expiresAt: number;
+    }): void;
+    publishApproval(input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly payload: unknown;
+        readonly expiresAt: number;
+    }): void;
+    expireApproval(approvalId: 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[];
+}
+type OpenCodePublicItem = {
+    readonly itemId: string;
+    readonly kind: 'assistant_message' | 'plan' | 'reasoning_summary' | 'tool_call' | 'user_input_request' | 'context_compaction' | 'file_change' | 'unknown';
+    readonly status: 'PENDING' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED';
+    readonly payload: Record<string, unknown>;
+    readonly merge?: boolean;
+};
+export declare class OpenCodeManagedRunController {
+    private readonly runner;
+    private readonly host;
+    private readonly interactionTimeoutMs;
+    private readonly permissions;
+    private readonly questions;
+    private readonly startingCwds;
+    private readonly promptAdmitted;
+    private readonly pendingIdle;
+    private readonly startingClients;
+    constructor(runner: OpenCodeRunner, host: OpenCodeManagedRunHost, interactionTimeoutMs?: number);
+    executeCommand(session: NodeAgentSession, command: RunnerCommandDescriptor, context: {
+        readonly secretEnvironment: Readonly<Record<string, string>>;
+    }): Promise<unknown>;
+    start(envelope: NodeEnvelope): void;
+    cancel(runId: string, intent: 'CANCEL' | 'INTERRUPT'): boolean;
+    decideApproval(input: {
+        readonly runId: string;
+        readonly approvalId: string;
+        readonly decision: 'APPROVED' | 'REJECTED';
+    }): boolean;
+    respondUserInput(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
+    private run;
+    private event;
+    private requestPermission;
+    private requestQuestion;
+    private finish;
+}
+export {};