@myagentroam/node 0.1.3 → 0.1.6

package/dist/runner/opencode-runner.js

@@ -0,0 +1,330 @@
+import { OpenCodeServerClient } from '../opencode-server.js';
+import { openCodeContextLimits, openCodeProfileModels } from '../opencode-runtime.js';
+import { declaredRunnerProfiles } from '../runner-profiles.js';
+import { AbstractRunner } from './abstract-runner.js';
+import { isWithinWorkspace } from './codex/conversation-parser.js';
+import { createHash } from 'node:crypto';
+import { openCodeConversationPage } from './opencode/conversation-parser.js';
+export class OpenCodeRunner extends AbstractRunner {
+    client;
+    clientFactory;
+    name = 'opencode';
+    discoveryScope = 'WORKSPACE_REQUIRED';
+    modelsByWorkspace = new Map();
+    contextLimitsByWorkspace = new Map();
+    execution = new Map();
+    managedTurns = new Map();
+    environmentClients = new Map();
+    stoppingClients = new Set();
+    constructor(client = new OpenCodeServerClient(), clientFactory = () => new OpenCodeServerClient()) {
+        super();
+        this.client = client;
+        this.clientFactory = clientFactory;
+    }
+    profile(capabilities) {
+        const base = declaredRunnerProfiles({
+            codexAvailable: capabilities.codex.available,
+            claudeCodeAvailable: capabilities.claudeCode.available,
+            openCodeAvailable: capabilities.openCode?.available === true
+        }).find((profile) => profile.runner === this.name);
+        return { ...base, models: [] };
+    }
+    async refreshProfile(capabilities, workspace, environment = {}) {
+        if (capabilities.openCode?.available !== true || workspace === undefined) {
+            return this.profile(capabilities);
+        }
+        const client = this.managedClient(environment);
+        try {
+            const catalog = await client.providers(workspace.path);
+            const models = openCodeProfileModels(catalog);
+            this.modelsByWorkspace.set(workspace.path, models);
+            this.contextLimitsByWorkspace.set(workspace.path, openCodeContextLimits(catalog));
+            return { ...this.profile(capabilities), models };
+        }
+        catch {
+            this.modelsByWorkspace.delete(workspace.path);
+            this.contextLimitsByWorkspace.delete(workspace.path);
+        }
+        finally {
+            this.releaseManagedClient(client);
+        }
+        return this.profile(capabilities);
+    }
+    available(capabilities) {
+        return capabilities.openCode?.available === true;
+    }
+    profileForValidation() {
+        return this.profile({
+            platform: 'linux',
+            architecture: 'validation',
+            nodeAppVersion: 'validation',
+            nodeVersion: 'validation',
+            codex: { available: false },
+            claudeCode: { available: false },
+            openCode: { available: true }
+        });
+    }
+    supportsConfiguration(configuration, workspace) {
+        if (configuration.runner !== this.name)
+            return false;
+        const models = workspace === undefined
+            ? [...this.modelsByWorkspace.values()].flat()
+            : (this.modelsByWorkspace.get(workspace.path) ?? []);
+        const model = models.find((candidate) => candidate.id === configuration.model);
+        return (model !== undefined &&
+            (model.supportedEfforts.length === 0 ||
+                model.supportedEfforts.includes(configuration.effort)) &&
+            this.profileForValidation().accessOptions.some((candidate) => candidate.id === configuration.access));
+    }
+    defaultConfiguration(workspace) {
+        const model = workspace === undefined
+            ? this.modelsByWorkspace.values().next().value?.[0]
+            : this.modelsByWorkspace.get(workspace.path)?.[0];
+        return {
+            runner: this.name,
+            model: model?.id ?? '',
+            effort: model?.supportedEfforts[0] ?? '',
+            access: 'default'
+        };
+    }
+    async discoverSessions(context, workspace) {
+        const result = [];
+        for (const target of workspace === undefined ? context.workspaces : [workspace]) {
+            let sessions;
+            try {
+                sessions = await this.client.sessions(target.path);
+            }
+            catch {
+                continue;
+            }
+            for (const value of sessions) {
+                const session = openCodeSession(value);
+                if (session === undefined || !isWithinWorkspace(session.directory, target.path))
+                    continue;
+                result.push(context.createProjection({
+                    workspace: target,
+                    runner: this.name,
+                    externalSessionId: session.id,
+                    cwd: session.directory,
+                    title: session.title,
+                    titleOrigin: 'OFFICIAL',
+                    lastActivityAt: session.updatedAt
+                }));
+            }
+        }
+        return result;
+    }
+    async resumeExternal(external, context) {
+        if (external.runner !== this.name || external.externalSessionId === null || !context.available)
+            return { failureCode: 'RUNNER_UNAVAILABLE' };
+        const activity = await this.readExternalActivity(external);
+        if (activity !== 'IDLE')
+            return {
+                activity: activity ?? 'UNAVAILABLE',
+                failureCode: activity === 'EXTERNAL_ACTIVE' ? 'EXTERNAL_SESSION_ACTIVE' : 'RUNNER_RESUME_FAILED'
+            };
+        const projection = context.projectionFor(external);
+        const session = projection === undefined ? context.create(external) : context.promote(projection.id);
+        return session === undefined
+            ? { activity: 'UNAVAILABLE', failureCode: 'RUNNER_RESUME_FAILED' }
+            : { activity: 'IDLE', session: context.ensureConfiguration(session) };
+    }
+    async readExternalActivity(session) {
+        if (session.externalSessionId === null)
+            return 'UNAVAILABLE';
+        try {
+            const status = await this.client.sessionStatus(session.cwd);
+            const value = status[session.externalSessionId];
+            return value?.type === 'busy' || value?.type === 'retry'
+                ? 'EXTERNAL_ACTIVE'
+                : value?.type === 'idle' || value === undefined
+                    ? 'IDLE'
+                    : 'UNAVAILABLE';
+        }
+        catch {
+            return 'UNAVAILABLE';
+        }
+    }
+    async readOfficialConversation(session, input, managedTurn) {
+        if (session.externalSessionId === null)
+            return undefined;
+        try {
+            return openCodeConversationPage(session, await this.client.messages(session.cwd, session.externalSessionId, 500), input, managedTurn);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    managedRunForNativeTurn(nativeTurnId) {
+        return this.managedTurns.get(nativeTurnId);
+    }
+    presentSession(session, capabilities, context) {
+        const available = capabilities.openCode?.available === true;
+        const managed = session.nativeControl === 'MAR_MANAGED';
+        const activity = context.managedActive
+            ? 'MANAGED_ACTIVE'
+            : (context.externalActivity ?? (available ? 'IDLE' : 'UNAVAILABLE'));
+        if (!available)
+            return {
+                activity: 'UNAVAILABLE',
+                control: { level: 'UNAVAILABLE', capabilities: [] },
+                runtime: { level: 'UNAVAILABLE', capabilities: [], reasonCode: 'RUNNER_UNAVAILABLE' },
+                commandStates: context.commandStates
+            };
+        const runtimeCapabilities = [
+            'history.read',
+            'events.live',
+            'turn.start',
+            'turn.queue',
+            'turn.interrupt',
+            'run.cancel',
+            'approval.respond',
+            'user-input.respond',
+            'session.rename',
+            'session.remove',
+            'session.pin',
+            ...(session.externalSessionId === null ? [] : ['session.rewind'])
+        ];
+        return {
+            activity,
+            control: {
+                level: managed ? 'MANAGED' : activity === 'IDLE' ? 'RESUMABLE' : 'OBSERVE_ONLY',
+                capabilities: managed || activity === 'IDLE'
+                    ? ['history.read', 'events.live', 'turn.start', 'turn.interrupt']
+                    : ['history.read', 'events.live']
+            },
+            runtime: {
+                level: managed ? 'MANAGED' : activity === 'IDLE' ? 'RESUMABLE' : 'OBSERVE_ONLY',
+                capabilities: runtimeCapabilities,
+                reasonCode: activity === 'EXTERNAL_ACTIVE' ? 'EXTERNAL_SESSION_OBSERVE_ONLY' : null
+            },
+            commandStates: context.commandStates
+        };
+    }
+    async renameNative(session, input, database) {
+        if (session.externalSessionId !== null && input.title !== undefined)
+            await this.client.updateSession(session.cwd, session.externalSessionId, input.title ?? '');
+        await super.renameNative(session, input, database);
+    }
+    async removeNative(session, nativeSessionId) {
+        await this.client.deleteSession(session.cwd, nativeSessionId);
+        return true;
+    }
+    async forkNative(session, boundary, title) {
+        if (session.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        const result = boundary === null
+            ? await this.client.createSession(session.cwd, title)
+            : await this.client.forkSession(session.cwd, session.externalSessionId, boundary);
+        const value = object(result);
+        if (typeof value?.id !== 'string')
+            throw new Error('SESSION_REWIND_FAILED');
+        if (boundary !== null)
+            await this.client.updateSession(session.cwd, value.id, title);
+        return value.id;
+    }
+    async executeCompact(session, environment) {
+        if (session.externalSessionId === null || session.model === null)
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const client = this.managedClient(environment);
+        try {
+            return await client.summarize(session.cwd, session.externalSessionId, session.model);
+        }
+        finally {
+            this.releaseManagedClient(client);
+        }
+    }
+    async readContextUsage(session) {
+        if (session.externalSessionId === null)
+            return undefined;
+        const messages = await this.client.messages(session.cwd, session.externalSessionId, 100);
+        const assistants = messages.flatMap((value) => {
+            const entry = object(value);
+            const info = object(entry?.info);
+            return info?.role === 'assistant' ? [info] : [];
+        });
+        const latest = assistants.at(-1);
+        const provider = typeof latest?.providerID === 'string' ? latest.providerID : undefined;
+        const model = typeof latest?.modelID === 'string' ? latest.modelID : undefined;
+        const tokens = object(latest?.tokens);
+        const cache = object(tokens?.cache);
+        const usedTokens = positiveNumber(tokens?.input) + positiveNumber(cache?.read);
+        const modelId = provider !== undefined && model !== undefined ? `${provider}/${model}` : session.model;
+        const limits = [...this.contextLimitsByWorkspace].find(([workspacePath]) => isWithinWorkspace(session.cwd, workspacePath))?.[1];
+        const maxTokens = modelId === null ? undefined : limits?.get(modelId);
+        return maxTokens === undefined || usedTokens <= 0
+            ? undefined
+            : { model: modelId, usedTokens, maxTokens };
+    }
+    async stop() {
+        for (const execution of this.execution.values())
+            execution.abort.abort();
+        this.execution.clear();
+        this.managedTurns.clear();
+        const stopping = [
+            this.client.stop(),
+            ...[...this.environmentClients.values()].map(({ client }) => client.stop()),
+            ...this.stoppingClients
+        ];
+        this.environmentClients.clear();
+        await Promise.allSettled(stopping);
+        this.stoppingClients.clear();
+    }
+    managedClient(environment) {
+        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
+        if (entries.length === 0)
+            return this.client;
+        const fingerprint = createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+        const existing = this.environmentClients.get(fingerprint);
+        if (existing !== undefined) {
+            existing.leases += 1;
+            return existing.client;
+        }
+        const client = this.clientFactory();
+        client.configureEnvironment(environment);
+        this.environmentClients.set(fingerprint, { client, leases: 1 });
+        return client;
+    }
+    releaseManagedClient(client) {
+        if (client === this.client)
+            return;
+        for (const [fingerprint, entry] of this.environmentClients) {
+            if (entry.client !== client)
+                continue;
+            entry.leases -= 1;
+            if (entry.leases <= 0) {
+                const stopping = entry.client.stop();
+                this.stoppingClients.add(stopping);
+                void stopping.finally(() => this.stoppingClients.delete(stopping));
+                this.environmentClients.delete(fingerprint);
+            }
+            return;
+        }
+    }
+}
+function object(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function positiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function openCodeSession(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    const time = typeof record.time === 'object' && record.time !== null
+        ? record.time
+        : undefined;
+    if (typeof record.id !== 'string' ||
+        typeof record.directory !== 'string' ||
+        typeof record.title !== 'string')
+        return undefined;
+    return {
+        id: record.id,
+        directory: record.directory,
+        title: record.title,
+        updatedAt: typeof time?.updated === 'number' ? time.updated : 0
+    };
+}

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

@@ -0,0 +1,19 @@
+import { AbstractRunner, type RegisteredRunnerName, type RunnerApprovalDecision, type RunnerCancellationIntent } from './abstract-runner.js';
+import type { NodeCapabilities, RunnerDefaultConfiguration, NodeEnvelope, RunnerName, RunnerProfile } from '@myagentroam/protocol';
+export declare class RunnerRegistry {
+    private readonly runners;
+    constructor(runners?: readonly AbstractRunner[]);
+    register<T extends AbstractRunner>(runner: T): T;
+    optional<T extends AbstractRunner>(name: RegisteredRunnerName): T | undefined;
+    require<T extends AbstractRunner>(name: RegisteredRunnerName): T;
+    advertised(): readonly AbstractRunner[];
+    product(name: unknown): AbstractRunner<RunnerName> | undefined;
+    profiles(capabilities: NodeCapabilities): readonly RunnerProfile[];
+    refreshProfiles(capabilities: NodeCapabilities, workspace?: import('../database.js').NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<readonly RunnerProfile[]>;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: import('../database.js').NodeWorkspace): boolean;
+    startManagedRun(envelope: NodeEnvelope): boolean;
+    cancelManagedRun(runId: string, intent: RunnerCancellationIntent): boolean;
+    decideApproval(input: RunnerApprovalDecision): boolean;
+    respondUserInput(runId: string, requestId: string, answers: Record<string, unknown>): boolean;
+    stop(): Promise<void>;
+}

package/dist/runner/runner-registry.js

@@ -0,0 +1,75 @@
+export class RunnerRegistry {
+    runners = new Map();
+    constructor(runners = []) {
+        for (const runner of runners)
+            this.register(runner);
+    }
+    register(runner) {
+        if (this.runners.has(runner.name))
+            throw new Error(`RUNNER_ALREADY_REGISTERED:${runner.name}`);
+        this.runners.set(runner.name, runner);
+        return runner;
+    }
+    optional(name) {
+        return this.runners.get(name);
+    }
+    require(name) {
+        const runner = this.optional(name);
+        if (runner === undefined)
+            throw new Error(`RUNNER_NOT_REGISTERED:${name}`);
+        return runner;
+    }
+    advertised() {
+        return [...this.runners.values()].filter((runner) => runner.advertised);
+    }
+    product(name) {
+        if (typeof name !== 'string')
+            return undefined;
+        const runner = this.runners.get(name);
+        return runner?.advertised === true ? runner : undefined;
+    }
+    profiles(capabilities) {
+        return this.advertised().flatMap((runner) => {
+            const profile = runner.profile(capabilities);
+            return profile === undefined ? [] : [profile];
+        });
+    }
+    async refreshProfiles(capabilities, workspace, environment = {}) {
+        const profiles = await Promise.all(this.advertised().map((runner) => runner.refreshProfile(capabilities, workspace, environment)));
+        return profiles.flatMap((profile) => (profile === undefined ? [] : [profile]));
+    }
+    supportsConfiguration(configuration, workspace) {
+        return (this.product(configuration.runner)?.supportsConfiguration(configuration, workspace) === true);
+    }
+    startManagedRun(envelope) {
+        const runnerName = envelope.payload.runner;
+        const values = [...this.runners.values()];
+        const runner = values.find((candidate) => candidate.interceptsRuns && candidate.acceptsRun(runnerName)) ??
+            values.find((candidate) => candidate.acceptsRun(runnerName));
+        if (runner === undefined)
+            return false;
+        runner.startManagedRun(envelope);
+        return true;
+    }
+    cancelManagedRun(runId, intent) {
+        for (const runner of this.runners.values())
+            if (runner.cancelManagedRun(runId, intent))
+                return true;
+        return false;
+    }
+    decideApproval(input) {
+        let handled = false;
+        for (const runner of this.runners.values())
+            handled = runner.decideApproval(input) || handled;
+        return handled;
+    }
+    respondUserInput(runId, requestId, answers) {
+        for (const runner of this.runners.values())
+            if (runner.respondUserInput(runId, requestId, answers))
+                return true;
+        return false;
+    }
+    async stop() {
+        await Promise.allSettled([...this.runners.values()].map((runner) => runner.stop()));
+    }
+}

package/dist/runner-command-engine.js

@@ -68,4 +68,3 @@ export class CommandStateStore {
         return this.states.get(sessionId)?.get(commandId);
     }
 }
-//# sourceMappingURL=runner-command-engine.js.map

package/dist/runner-profiles.d.ts

@@ -2,10 +2,14 @@ import type { RunnerName, RunnerProfile } from '@myagentroam/protocol';
 export declare function declaredRunnerProfiles(input: {
     readonly codexAvailable: boolean;
     readonly claudeCodeAvailable: boolean;
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly openCodeAvailable?: boolean;
 }): readonly RunnerProfile[];
 export declare function supportsRunnerConfiguration(input: {
     readonly runner: RunnerName;
     readonly model: string;
     readonly effort: string;
     readonly access: string;
+    readonly environment?: NodeJS.ProcessEnv;
 }): boolean;
+export declare function claudeDefaultModel(environment?: NodeJS.ProcessEnv): string;

package/dist/runner-profiles.js

@@ -1,6 +1,11 @@
 // Codex reasoning efforts follow the official Codex model surface. Keep this
 // shared so an alias such as GPT-5.6 Luna cannot accidentally lose `high`.
 const CODEX_REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
+const CLAUDE_MODEL_ENVIRONMENT = {
+    opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
+    sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
+    haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL'
+};
 /**
  * The Runner APIs used by MAR do not expose a portable model-list endpoint.
  * Keep the supported, product-visible choices in one Node-owned definition so
@@ -123,21 +128,90 @@ const definitions = {
                 reasonCode: null
             }
         ]
+    },
+    opencode: {
+        runner: 'opencode',
+        models: [],
+        accessOptions: [
+            {
+                id: 'default',
+                label: 'Default',
+                description: '按 OpenCode 和当前 Workspace 配置确认权限。'
+            },
+            {
+                id: 'auto',
+                label: 'Auto approve',
+                description: '自动允许 OpenCode 请求的工具权限。'
+            }
+        ],
+        commands: [
+            {
+                id: 'compact',
+                runner: 'opencode',
+                label: '/compact',
+                description: '通过 OpenCode 压缩当前会话上下文。',
+                inputHint: '/compact',
+                source: 'OPENCODE_SERVER',
+                interaction: 'IMMEDIATE_ACTION',
+                available: true,
+                reasonCode: null
+            },
+            {
+                id: 'plan',
+                runner: 'opencode',
+                label: '/plan',
+                stateLabel: 'Plan Mode',
+                description: '开启或关闭 OpenCode 原生 Plan Agent。',
+                inputHint: '/plan',
+                source: 'OPENCODE_SERVER',
+                interaction: 'TOGGLE',
+                available: true,
+                reasonCode: null
+            }
+        ]
     }
 };
 export function declaredRunnerProfiles(input) {
     return [
         withCapabilities(definitions.codex, input.codexAvailable),
-        withCapabilities(definitions['claude-code'], input.claudeCodeAvailable)
+        withCapabilities(claudeProfile(input.environment ?? process.env), input.claudeCodeAvailable),
+        withCapabilities(definitions.opencode, input.openCodeAvailable === true)
     ];
 }
 export function supportsRunnerConfiguration(input) {
-    const profile = definitions[input.runner];
+    const profile = input.runner === 'claude-code'
+        ? claudeProfile(input.environment ?? process.env)
+        : definitions[input.runner];
     const model = profile.models.find((candidate) => candidate.id === input.model);
     return (model !== undefined &&
         model.supportedEfforts.includes(input.effort) &&
         profile.accessOptions.some((candidate) => candidate.id === input.access));
 }
+export function claudeDefaultModel(environment = process.env) {
+    return configuredClaudeModel('sonnet', environment) ?? 'sonnet';
+}
+function claudeProfile(environment) {
+    const profile = definitions['claude-code'];
+    const models = profile.models.map((model) => {
+        const configured = configuredClaudeModel(model.id, environment);
+        return configured === undefined ? model : { ...model, id: configured, label: configured };
+    });
+    return {
+        ...profile,
+        models: models.filter((model, index) => models.findIndex((candidate) => candidate.id === model.id) === index)
+    };
+}
+function configuredClaudeModel(alias, environment) {
+    const environmentName = CLAUDE_MODEL_ENVIRONMENT[alias];
+    return (validModelName(environmentName === undefined ? undefined : environment[environmentName]) ??
+        (alias === 'sonnet' ? validModelName(environment['ANTHROPIC_MODEL']) : undefined));
+}
+function validModelName(value) {
+    const normalized = value?.trim();
+    return normalized !== undefined && normalized.length > 0 && normalized.length <= 128
+        ? normalized
+        : undefined;
+}
 function withCapabilities(profile, available) {
     return {
         ...profile,
@@ -147,4 +221,3 @@ function withCapabilities(profile, available) {
             : []
     };
 }
-//# sourceMappingURL=runner-profiles.js.map

package/dist/runner-usage.d.ts

@@ -24,8 +24,8 @@ export declare class RunnerUsageReader {
     private readonly now;
     private readonly cache;
     constructor(fetcher?: FetchLike, homePath?: string, now?: () => number);
-    status(runner: RunnerName, runnerAvailable: boolean): Promise<RunnerUsageStatus>;
-    read(runner: RunnerName, runnerAvailable: boolean): Promise<RunnerUsage>;
+    status(runner: RunnerName): Promise<RunnerUsageStatus>;
+    read(runner: RunnerName): Promise<RunnerUsage>;
     private credentials;
     private readCodex;
     private readClaude;

package/dist/runner-usage.js

@@ -18,15 +18,13 @@ export class RunnerUsageReader {
         this.homePath = homePath;
         this.now = now;
     }
-    async status(runner, runnerAvailable) {
-        if (!runnerAvailable)
-            return unavailable(runner, 'RUNNER_UNAVAILABLE');
+    async status(runner) {
         return (await this.credentials(runner)) === undefined
             ? unavailable(runner, USAGE_OAUTH_REQUIRED)
             : { runner, available: true, reasonCode: null };
     }
-    async read(runner, runnerAvailable) {
-        const status = await this.status(runner, runnerAvailable);
+    async read(runner) {
+        const status = await this.status(runner);
         if (!status.available)
             throw new Error(status.reasonCode ?? 'USAGE_UNAVAILABLE');
         const cached = this.cache.get(runner);
@@ -190,4 +188,3 @@ function timestamp(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
 }
-//# sourceMappingURL=runner-usage.js.map