@myagentroam/node 0.1.4 → 0.1.7

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

@@ -9,9 +9,11 @@ export declare class RunnerRegistry {
     advertised(): readonly AbstractRunner[];
     product(name: unknown): AbstractRunner<RunnerName> | undefined;
     profiles(capabilities: NodeCapabilities): readonly RunnerProfile[];
-    supportsConfiguration(configuration: RunnerDefaultConfiguration): boolean;
+    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

@@ -34,8 +34,12 @@ export class RunnerRegistry {
             return profile === undefined ? [] : [profile];
         });
     }
-    supportsConfiguration(configuration) {
-        return this.product(configuration.runner)?.supportsConfiguration(configuration) === true;
+    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;
@@ -59,8 +63,13 @@ export class RunnerRegistry {
             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()));
     }
 }
-//# sourceMappingURL=runner-registry.js.map

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.js

@@ -188,4 +188,3 @@ function timestamp(value) {
     const parsed = Date.parse(value);
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : null;
 }
-//# sourceMappingURL=runner-usage.js.map

package/dist/runtime-state.js

@@ -754,15 +754,18 @@ export class NodeRuntimeState {
             if (event.eventType === 'text.delta' &&
                 isRecord(event.payload) &&
                 typeof event.payload.text === 'string') {
-                const existing = turn.items.find((item) => item.id === `${event.runId}:assistant`);
+                const lastItem = turn.items.at(-1);
+                const existing = lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
+                    ? lastItem
+                    : undefined;
                 const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
                 const item = {
-                    id: `${event.runId}:assistant`,
+                    id: existing?.id ?? `${event.runId}:assistant:${event.sequence}`,
                     sessionId: run.sessionId,
                     turnId: turn.id,
                     runId: event.runId,
                     parentItemId: null,
-                    sourceSequence: event.sequence,
+                    sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: event.sequence,
                     kind: 'assistant_message',
                     status: 'IN_PROGRESS',
@@ -774,12 +777,20 @@ export class NodeRuntimeState {
                     ...turn,
                     status: 'RUNNING',
                     startedAt: turn.startedAt ?? event.createdAt,
-                    items: [...turn.items.filter((value) => value.id !== item.id), item]
+                    items: existing === undefined
+                        ? [...turn.items, item]
+                        : turn.items.map((value) => (value.id === item.id ? item : value))
                 };
             }
             const projected = conversationItemFromEvent(event);
             if (projected !== undefined) {
-                const existing = turn.items.find((item) => item.id === `${event.runId}:${projected.itemId}`);
+                const trailingItem = turn.items.at(-1);
+                const orderedItems = trailingItem?.kind === 'assistant_message' && activeConversationItem(trailingItem.status)
+                    ? turn.items.map((item) => item.id === trailingItem.id
+                        ? { ...item, status: 'COMPLETED', completedAt: event.createdAt }
+                        : item)
+                    : turn.items;
+                const existing = orderedItems.find((item) => item.id === `${event.runId}:${projected.itemId}`);
                 const status = projected.status;
                 const item = {
                     id: `${event.runId}:${projected.itemId}`,
@@ -787,7 +798,7 @@ export class NodeRuntimeState {
                     turnId: turn.id,
                     runId: event.runId,
                     parentItemId: null,
-                    sourceSequence: event.sequence,
+                    sourceSequence: existing?.sourceSequence ?? event.sequence,
                     revision: (existing?.revision ?? -1) + 1,
                     kind: projected.kind,
                     status,
@@ -800,8 +811,8 @@ export class NodeRuntimeState {
                     status: terminal(run.status) ? run.status : 'RUNNING',
                     startedAt: turn.startedAt ?? event.createdAt,
                     items: existing === undefined
-                        ? [...turn.items, item]
-                        : turn.items.map((value) => (value.id === item.id ? item : value))
+                        ? [...orderedItems, item]
+                        : orderedItems.map((value) => (value.id === item.id ? item : value))
                 };
             }
             if (event.eventType === 'run.started' || event.eventType === 'run.running')
@@ -874,6 +885,7 @@ function projectableConversationKind(value) {
         value === 'plan' ||
         value === 'file_change' ||
         value === 'context_compaction' ||
+        value === 'unknown' ||
         value === 'warning' ||
         value === 'error');
 }
@@ -955,4 +967,3 @@ function decodeCursor(cursor, scope) {
         return 0;
     }
 }
-//# sourceMappingURL=runtime-state.js.map

package/dist/service/attachment-domain-state.js

@@ -3,4 +3,3 @@ export class AttachmentDomainState {
     runImages = new Map();
     nativeHistoryImages = new Map();
 }
-//# sourceMappingURL=attachment-domain-state.js.map

package/dist/service/conversation-history-service.js

@@ -156,4 +156,3 @@ export class ConversationHistoryService {
         };
     }
 }
-//# sourceMappingURL=conversation-history-service.js.map

package/dist/service/external-session-resume-service.js

@@ -96,4 +96,3 @@ export class ExternalSessionResumeService {
             this.options.state.resumeFailureDetails.set(sessionId, detail);
     }
 }
-//# sourceMappingURL=external-session-resume-service.js.map

package/dist/service/fake-managed-run-service.js

@@ -60,4 +60,3 @@ export class FakeManagedRunService {
             .finally(() => this.options.state.active.delete(runId));
     }
 }
-//# sourceMappingURL=fake-managed-run-service.js.map

package/dist/service/managed-runner-session-service.d.ts

@@ -1,10 +1,12 @@
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { NodeAgentSession } from '../database.js';
 /** Owns managed native-session identity and best-effort native title refresh. */
 export declare class ManagedRunnerSessionService {
     private readonly runtime;
     private readonly runners;
-    constructor(runtime: NodeRuntimeState, runners: RunnerRegistry);
+    private readonly emitSession;
+    constructor(runtime: NodeRuntimeState, runners: RunnerRegistry, emitSession: (session: NodeAgentSession) => void);
     remember(nativeSessionId: string, sessionId: string): void;
     refreshTitle(sessionId: string, externalSessionId: string, cwd: string): Promise<void>;
 }

package/dist/service/managed-runner-session-service.js

@@ -2,9 +2,11 @@
 export class ManagedRunnerSessionService {
     runtime;
     runners;
-    constructor(runtime, runners) {
+    emitSession;
+    constructor(runtime, runners, emitSession) {
         this.runtime = runtime;
         this.runners = runners;
+        this.emitSession = emitSession;
     }
     remember(nativeSessionId, sessionId) {
         const session = this.runtime.getAgentSession(sessionId);
@@ -20,12 +22,14 @@ export class ManagedRunnerSessionService {
             const title = await this.runners
                 .require(session.runner)
                 .readManagedRunnerTitle({ ...session, cwd }, externalSessionId);
-            if (title !== undefined)
-                this.runtime.setRunnerTitleFromNative(session.id, title);
+            if (title === undefined)
+                return;
+            const updated = this.runtime.setRunnerTitleFromNative(session.id, title);
+            if (updated.runnerTitle !== session.runnerTitle)
+                this.emitSession(updated);
         }
         catch {
             // Native history is a best-effort source and cannot alter the completed Run result.
         }
     }
 }
-//# sourceMappingURL=managed-runner-session-service.js.map