@myagentroam/node 0.1.3 → 0.1.6

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 {};

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

@@ -0,0 +1,451 @@
+import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { boundedConversationItemId, compactRunnerText, compactRunnerValue } from '../codex/conversation-parser.js';
+import { openCodePatchChanges, openCodeQuestions } from './conversation-parser.js';
+export class OpenCodeManagedRunController {
+    runner;
+    host;
+    interactionTimeoutMs;
+    permissions = new Map();
+    questions = new Map();
+    startingCwds = new Map();
+    promptAdmitted = new Set();
+    pendingIdle = new Set();
+    startingClients = new Map();
+    constructor(runner, host, interactionTimeoutMs = 10 * 60_000) {
+        this.runner = runner;
+        this.host = host;
+        this.interactionTimeoutMs = interactionTimeoutMs;
+    }
+    async executeCommand(session, command, context) {
+        if (command.id === 'compact')
+            return this.runner.executeCompact(session, context.secretEnvironment);
+        if (command.id !== '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: '后续消息将由 OpenCode 原生 Plan Agent 只读分析并制定计划。',
+                closable: true,
+                closeInput: '/plan',
+                continuation: { label: 'Implement', prompt: '请根据上述计划开始实施。' }
+            });
+        return { command: command.id, states: this.host.commandStates(session.id) };
+    }
+    start(envelope) {
+        const payload = envelope.payload;
+        if (payload.runner !== 'opencode' ||
+            typeof payload.runId !== 'string' ||
+            typeof payload.sessionId !== 'string' ||
+            typeof payload.input !== 'string' ||
+            typeof payload.cwd !== 'string' ||
+            typeof payload.model !== 'string' ||
+            this.host.intercepted() ||
+            this.host.active.has(payload.runId))
+            return;
+        let environment;
+        let attachments;
+        try {
+            environment = parseSecretEnvironment(payload.secretEnvironment);
+            attachments = this.host.parseAttachments(payload.attachments);
+        }
+        catch (error) {
+            this.host.emit(payload.runId, 'run.rejected', { code: error instanceof Error ? error.message : 'RUNNER_INPUT_INVALID' }, 'FAILED');
+            return;
+        }
+        void this.run({
+            runId: payload.runId,
+            sessionId: payload.sessionId,
+            input: payload.input,
+            cwd: payload.cwd,
+            model: payload.model,
+            effort: typeof payload.effort === 'string' ? payload.effort : '',
+            ...(typeof payload.externalSessionId === 'string'
+                ? { externalSessionId: payload.externalSessionId }
+                : {}),
+            environment,
+            attachments,
+            access: typeof payload.access === 'string' ? payload.access : 'default',
+            agent: payload.collaborationMode === 'plan' ? 'plan' : 'build'
+        });
+    }
+    cancel(runId, intent) {
+        const execution = this.runner.execution.get(runId);
+        if (execution === undefined)
+            return false;
+        void execution.client.abort(execution.cwd, execution.nativeSessionId).finally(() => {
+            this.finish(runId, intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED', 'run.completed', {
+                status: intent === 'INTERRUPT' ? 'INTERRUPTED' : 'CANCELLED'
+            });
+        });
+        return true;
+    }
+    decideApproval(input) {
+        const pending = this.permissions.get(input.approvalId);
+        if (pending === undefined || pending.runId !== input.runId)
+            return false;
+        clearTimeout(pending.timer);
+        this.permissions.delete(input.approvalId);
+        void pending.client.replyPermission(pending.cwd, pending.requestId, input.decision);
+        return true;
+    }
+    respondUserInput(runId, requestId, answers) {
+        const pending = this.questions.get(requestId);
+        if (pending === undefined || pending.runId !== runId)
+            return false;
+        const normalized = pending.questionIds.map((id) => {
+            const value = answers[id];
+            const values = Array.isArray(value) ? value : typeof value === 'string' ? [value] : [];
+            if (values.length === 0 ||
+                values.length > 8 ||
+                values.some((item) => typeof item !== 'string' || item.length === 0 || item.length > 500))
+                throw new Error('USER_INPUT_INVALID');
+            return values;
+        });
+        clearTimeout(pending.timer);
+        this.questions.delete(requestId);
+        void pending.client.replyQuestion(pending.cwd, pending.requestId, normalized);
+        this.host.emitItem(runId, {
+            itemId: boundedConversationItemId('opencode-input', requestId),
+            kind: 'user_input_request',
+            status: 'COMPLETED',
+            payload: {},
+            merge: true
+        });
+        return true;
+    }
+    async run(input) {
+        const client = this.runner.managedClient(input.environment);
+        this.startingClients.set(input.runId, client);
+        this.startingCwds.set(input.runId, input.cwd);
+        this.host.active.add(input.runId);
+        this.host.emit(input.runId, 'run.started', {}, 'STARTING');
+        try {
+            const nativeSessionId = input.externalSessionId ?? openCodeSessionId(await client.createSession(input.cwd));
+            if (nativeSessionId === undefined)
+                throw new Error('OPENCODE_SESSION_INVALID');
+            this.host.adopt({
+                runId: input.runId,
+                sessionId: input.sessionId,
+                runner: 'opencode',
+                cwd: input.cwd,
+                externalSessionId: nativeSessionId
+            });
+            this.host.rememberNative(nativeSessionId, input.sessionId);
+            if (input.externalSessionId === undefined) {
+                this.host.promote(input.sessionId, nativeSessionId);
+                this.host.send('session.external-id', {
+                    sessionId: input.sessionId,
+                    externalSessionId: nativeSessionId
+                });
+            }
+            const abort = new AbortController();
+            this.runner.execution.set(input.runId, {
+                runId: input.runId,
+                sessionId: input.sessionId,
+                nativeSessionId,
+                cwd: input.cwd,
+                client,
+                abort,
+                access: input.access,
+                agent: input.agent
+            });
+            let subscriptionStarted = false;
+            let ready;
+            let rejectReady;
+            const subscriptionReady = new Promise((resolve, reject) => {
+                ready = () => {
+                    subscriptionStarted = true;
+                    resolve();
+                };
+                rejectReady = reject;
+            });
+            void client
+                .subscribe(input.cwd, abort.signal, (event) => this.event(input.runId, nativeSessionId, event), ready)
+                .catch((error) => {
+                if (abort.signal.aborted)
+                    return;
+                if (!subscriptionStarted) {
+                    rejectReady(error);
+                    return;
+                }
+                this.finish(input.runId, 'FAILED', 'run.failed', {
+                    code: error instanceof Error ? error.message : 'OPENCODE_EVENT_FAILED'
+                });
+            });
+            await subscriptionReady;
+            this.host.emit(input.runId, 'run.running', {}, 'RUNNING');
+            // The initial SSE snapshot can contain an idle event from before this prompt.
+            this.pendingIdle.delete(input.runId);
+            await client.prompt({
+                directory: input.cwd,
+                sessionID: nativeSessionId,
+                text: input.input,
+                model: input.model,
+                variant: input.effort,
+                agent: input.agent,
+                attachments: input.attachments
+            });
+            this.promptAdmitted.add(input.runId);
+            if (this.pendingIdle.delete(input.runId))
+                this.finish(input.runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
+        }
+        catch (error) {
+            this.finish(input.runId, 'FAILED', 'run.failed', {
+                code: error instanceof Error ? error.message : 'OPENCODE_RUN_START_FAILED'
+            });
+        }
+    }
+    event(runId, nativeSessionId, value) {
+        const event = record(value);
+        const properties = record(event?.properties);
+        const nested = record(properties?.part) ?? record(properties?.info);
+        const sessionID = typeof properties?.sessionID === 'string'
+            ? properties.sessionID
+            : typeof nested?.sessionID === 'string'
+                ? nested.sessionID
+                : undefined;
+        if (sessionID !== nativeSessionId)
+            return;
+        if (event?.type === 'session.idle') {
+            if (!this.promptAdmitted.has(runId)) {
+                this.pendingIdle.add(runId);
+                return;
+            }
+            this.finish(runId, 'SUCCEEDED', 'run.completed', { status: 'SUCCEEDED' });
+            return;
+        }
+        if (event?.type === 'session.error') {
+            this.finish(runId, 'FAILED', 'run.failed', { code: 'OPENCODE_SESSION_ERROR' });
+            return;
+        }
+        if (event?.type === 'message.part.updated') {
+            const part = record(properties?.part);
+            const item = openCodePart(part, this.runner.execution.get(runId)?.agent === 'plan');
+            if (item !== undefined)
+                this.host.emitItem(runId, item);
+            return;
+        }
+        if (event?.type === 'message.updated') {
+            const info = record(properties?.info);
+            if (info?.role === 'assistant' && typeof info.parentID === 'string')
+                this.runner.managedTurns.set(info.parentID, runId);
+            return;
+        }
+        if (event?.type === 'permission.asked')
+            this.requestPermission(runId, properties);
+        if (event?.type === 'question.asked')
+            this.requestQuestion(runId, properties);
+    }
+    requestPermission(runId, properties) {
+        const execution = this.runner.execution.get(runId);
+        const requestId = typeof properties?.id === 'string' ? properties.id : undefined;
+        if (execution === undefined || requestId === undefined)
+            return;
+        if (execution.access === 'auto') {
+            void execution.client.replyPermission(execution.cwd, requestId, 'APPROVED');
+            return;
+        }
+        const approvalId = `opencode:${requestId}`;
+        const expiresAt = Date.now() + this.interactionTimeoutMs;
+        const payload = {
+            toolName: typeof properties?.permission === 'string' ? properties.permission : 'OpenCode permission',
+            input: { patterns: Array.isArray(properties?.patterns) ? properties.patterns : [] }
+        };
+        try {
+            this.host.createApproval({ runId, approvalId, payload, expiresAt });
+        }
+        catch {
+            void execution.client.replyPermission(execution.cwd, requestId, 'REJECTED');
+            return;
+        }
+        const expire = () => {
+            const pending = this.permissions.get(approvalId);
+            if (pending === undefined)
+                return;
+            try {
+                this.host.expireApproval(approvalId);
+            }
+            catch (error) {
+                if (error instanceof Error && error.message === 'APPROVAL_NOT_EXPIRED') {
+                    const timer = setTimeout(expire, Math.max(1, expiresAt - Date.now()));
+                    this.permissions.set(approvalId, { ...pending, timer });
+                    return;
+                }
+            }
+            this.permissions.delete(approvalId);
+            this.host.emit(runId, 'approval.expired', { approvalId });
+            void execution.client.replyPermission(execution.cwd, requestId, 'REJECTED');
+        };
+        const timer = setTimeout(expire, this.interactionTimeoutMs);
+        this.permissions.set(approvalId, {
+            runId,
+            requestId,
+            client: execution.client,
+            cwd: execution.cwd,
+            timer
+        });
+        this.host.publishApproval({ runId, approvalId, payload, expiresAt });
+    }
+    requestQuestion(runId, properties) {
+        const execution = this.runner.execution.get(runId);
+        const requestId = typeof properties?.id === 'string' ? properties.id : undefined;
+        const rawQuestions = properties?.questions;
+        if (execution === undefined || requestId === undefined)
+            return;
+        const questions = openCodeQuestions(rawQuestions);
+        if (questions.length === 0 || questions.length > 4 || this.questions.has(requestId))
+            return;
+        const timer = setTimeout(() => {
+            const pending = this.questions.get(requestId);
+            if (pending === undefined)
+                return;
+            this.questions.delete(requestId);
+            void pending.client.rejectQuestion(pending.cwd, pending.requestId);
+            this.host.emitItem(runId, {
+                itemId: boundedConversationItemId('opencode-input', requestId),
+                kind: 'user_input_request',
+                status: 'FAILED',
+                payload: { requestId, questions, errorCode: 'USER_INPUT_EXPIRED' },
+                merge: true
+            });
+        }, this.interactionTimeoutMs);
+        this.questions.set(requestId, {
+            runId,
+            requestId,
+            client: execution.client,
+            cwd: execution.cwd,
+            questionIds: questions.map((question) => question.id),
+            timer
+        });
+        this.host.emitItem(runId, {
+            itemId: boundedConversationItemId('opencode-input', requestId),
+            kind: 'user_input_request',
+            status: 'PENDING',
+            payload: { requestId, questions }
+        });
+    }
+    finish(runId, status, eventType, payload) {
+        const execution = this.runner.execution.get(runId);
+        const cwd = execution?.cwd ?? this.startingCwds.get(runId);
+        const client = execution?.client ?? this.startingClients.get(runId);
+        if (execution === undefined && cwd === undefined && client === undefined)
+            return;
+        execution?.abort.abort();
+        this.runner.execution.delete(runId);
+        this.startingCwds.delete(runId);
+        this.startingClients.delete(runId);
+        this.promptAdmitted.delete(runId);
+        this.pendingIdle.delete(runId);
+        this.host.active.delete(runId);
+        for (const [id, pending] of this.permissions)
+            if (pending.runId === runId) {
+                clearTimeout(pending.timer);
+                this.permissions.delete(id);
+            }
+        for (const [id, pending] of this.questions)
+            if (pending.runId === runId) {
+                clearTimeout(pending.timer);
+                this.questions.delete(id);
+            }
+        this.host.emit(runId, eventType, payload, status);
+        if (client !== undefined)
+            this.runner.releaseManagedClient(client);
+        if (cwd !== undefined)
+            void this.host.captureSnapshot(runId, cwd);
+    }
+}
+function openCodePart(part, planMode = false) {
+    const id = typeof part?.id === 'string' ? part.id : undefined;
+    if (id === undefined || typeof part?.type !== 'string')
+        return undefined;
+    const itemId = boundedConversationItemId('opencode', id);
+    if (part.type === 'text' && typeof part.text === 'string')
+        return {
+            itemId,
+            kind: planMode ? 'plan' : 'assistant_message',
+            status: record(part.time)?.end === undefined ? 'IN_PROGRESS' : 'COMPLETED',
+            payload: planMode
+                ? { explanation: compactRunnerText(part.text, 20_000), steps: [] }
+                : { text: part.text, format: 'markdown', model: null },
+            merge: true
+        };
+    if (part.type === 'reasoning' && typeof part.text === 'string')
+        return {
+            itemId,
+            kind: 'reasoning_summary',
+            status: record(part.time)?.end === undefined ? 'IN_PROGRESS' : 'COMPLETED',
+            payload: { sections: [{ index: 0, text: part.text }] },
+            merge: true
+        };
+    if (part.type === 'tool' && typeof part.tool === 'string') {
+        // `question.asked` carries the canonical request ID required for reply;
+        // the mirrored tool Part is presentation/history metadata only.
+        if (part.tool === 'question')
+            return undefined;
+        const state = record(part.state);
+        const status = state?.status === 'completed'
+            ? 'COMPLETED'
+            : state?.status === 'error'
+                ? 'FAILED'
+                : 'IN_PROGRESS';
+        return {
+            itemId,
+            kind: 'tool_call',
+            status,
+            payload: {
+                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
+            },
+            merge: true
+        };
+    }
+    if (part.type === 'compaction')
+        return {
+            itemId,
+            kind: 'context_compaction',
+            status: 'COMPLETED',
+            payload: { phase: 'COMPLETED', summary: '上下文已整理' }
+        };
+    if (part.type === 'patch')
+        return {
+            itemId,
+            kind: 'file_change',
+            status: 'COMPLETED',
+            payload: { changes: openCodePatchChanges(part.files) },
+            merge: true
+        };
+    if (part.type === 'step-start' || part.type === 'step-finish')
+        return undefined;
+    if (part.type === 'text' || part.type === 'reasoning')
+        return undefined;
+    return {
+        itemId,
+        kind: 'unknown',
+        status: record(part.time)?.end === undefined ? 'IN_PROGRESS' : 'COMPLETED',
+        payload: {
+            sourceEventType: `opencode:${part.type}`,
+            label: `OpenCode ${compactRunnerText(part.type, 128)}`
+        },
+        merge: true
+    };
+}
+function openCodeSessionId(value) {
+    const session = record(value);
+    return typeof session?.id === 'string' ? session.id : undefined;
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}

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

@@ -0,0 +1,60 @@
+import type { NodeCapabilities, RunnerDefaultConfiguration, RunnerProfile } from '@myagentroam/protocol';
+import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
+import { OpenCodeServerClient } from '../opencode-server.js';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerSessionPresentation, type RunnerSessionPresentationContext } from './abstract-runner.js';
+export interface OpenCodeManagedExecution {
+    readonly runId: string;
+    readonly sessionId: string;
+    readonly nativeSessionId: string;
+    readonly cwd: string;
+    readonly client: OpenCodeServerClient;
+    readonly abort: AbortController;
+    readonly access: string;
+    readonly agent: 'plan' | 'build';
+}
+export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
+    private readonly client;
+    private readonly clientFactory;
+    readonly name: "opencode";
+    readonly discoveryScope: "WORKSPACE_REQUIRED";
+    private readonly modelsByWorkspace;
+    private readonly contextLimitsByWorkspace;
+    readonly execution: Map<string, OpenCodeManagedExecution>;
+    readonly managedTurns: Map<string, string>;
+    private readonly environmentClients;
+    private readonly stoppingClients;
+    constructor(client?: OpenCodeServerClient, clientFactory?: () => OpenCodeServerClient);
+    profile(capabilities: NodeCapabilities): RunnerProfile;
+    refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
+    available(capabilities: NodeCapabilities): boolean;
+    protected profileForValidation(): RunnerProfile;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
+    defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
+    resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
+    readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "EXTERNAL_ACTIVE" | "IDLE">;
+    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>;
+    managedRunForNativeTurn(nativeTurnId: string): string | undefined;
+    presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
+    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>;
+    executeCompact(session: NodeAgentSession, environment: Readonly<Record<string, string>>): Promise<unknown>;
+    readContextUsage(session: NodeAgentSession): Promise<{
+        model: string | null;
+        usedTokens: number;
+        maxTokens: number;
+    } | undefined>;
+    stop(): Promise<void>;
+    managedClient(environment: Readonly<Record<string, string>>): OpenCodeServerClient;
+    releaseManagedClient(client: OpenCodeServerClient): void;
+}