@myagentroam/node 0.9.3 → 0.9.5

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

@@ -1,7 +1,7 @@
 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';
+import { AbstractRunner, type ExternalResumeContext, type ExternalResumeResult, type RunnerDiscoveryContext, type RunnerConversationHistoryPage, type RunnerConversationHistoryReaders, type RunnerSessionPresentation, type RunnerSessionPresentationContext } from './abstract-runner.js';
 export interface OpenCodeManagedExecution {
     readonly runId: string;
     readonly sessionId: string;
@@ -20,6 +20,8 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     private readonly modelsByWorkspace;
     private readonly contextLimitsByWorkspace;
     private readonly profileTimersByWorkspace;
+    private readonly profileCache;
+    private readonly profileRefreshes;
     readonly execution: Map<string, OpenCodeManagedExecution>;
     readonly managedTurns: Map<string, string>;
     private readonly environmentClients;
@@ -27,10 +29,14 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     constructor(client?: OpenCodeServerClient, clientFactory?: () => OpenCodeServerClient);
     profile(capabilities: NodeCapabilities): RunnerProfile;
     refreshProfile(capabilities: NodeCapabilities, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<RunnerProfile>;
+    private fetchProfile;
+    private profileCacheKey;
+    private environmentFingerprint;
     available(capabilities: NodeCapabilities): boolean;
     protected profileForValidation(): RunnerProfile;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
-    defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
+    defaultConfiguration(workspace?: NodeWorkspace, environment?: Readonly<Record<string, string>>): RunnerDefaultConfiguration;
+    private cachedModels;
     mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
@@ -42,6 +48,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         readonly turns: readonly import("../database.js").NodeConversationTurn[];
         readonly nextCursor: string | null;
     } | undefined>;
+    readConversationHistory(readers: RunnerConversationHistoryReaders): Promise<RunnerConversationHistoryPage | undefined>;
     managedRunForNativeTurn(nativeTurnId: string): string | undefined;
     presentSession(session: NodeAgentSession, capabilities: NodeCapabilities, context: RunnerSessionPresentationContext): RunnerSessionPresentation;
     renameNative(session: NodeAgentSession, input: {

package/dist/runner/opencode-runner.js

@@ -5,6 +5,7 @@ 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';
+import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
 export class OpenCodeRunner extends AbstractRunner {
     client;
@@ -14,6 +15,8 @@ export class OpenCodeRunner extends AbstractRunner {
     modelsByWorkspace = new Map();
     contextLimitsByWorkspace = new Map();
     profileTimersByWorkspace = new Map();
+    profileCache = new Map();
+    profileRefreshes = new Map();
     execution = new Map();
     managedTurns = new Map();
     environmentClients = new Map();
@@ -35,25 +38,79 @@ export class OpenCodeRunner extends AbstractRunner {
         if (capabilities.openCode?.available !== true || workspace === undefined) {
             return this.profile(capabilities);
         }
+        const cacheKey = this.profileCacheKey(workspace.path, environment);
+        const now = Date.now();
+        for (const [key, entry] of this.profileCache)
+            if (entry.expiresAt <= now)
+                this.profileCache.delete(key);
+        const cached = this.profileCache.get(cacheKey);
+        if (cached !== undefined) {
+            nodeLog('runner.opencode.profile.cache-hit', {
+                workspaceId: workspace.id,
+                models: cached.models.length,
+                remainingTtlMs: cached.expiresAt - now
+            });
+            this.modelsByWorkspace.set(workspace.path, cached.models);
+            this.contextLimitsByWorkspace.set(workspace.path, cached.contextLimits);
+            this.scheduleProfileExpiry(workspace.path);
+            return { ...this.profile(capabilities), models: cached.models };
+        }
+        const current = this.profileRefreshes.get(cacheKey);
+        if (current !== undefined) {
+            nodeLog('runner.opencode.profile.single-flight-joined', { workspaceId: workspace.id });
+            return current;
+        }
+        const refresh = this.fetchProfile(capabilities, workspace, environment, cacheKey).finally(() => {
+            if (this.profileRefreshes.get(cacheKey) === refresh)
+                this.profileRefreshes.delete(cacheKey);
+        });
+        this.profileRefreshes.set(cacheKey, refresh);
+        return refresh;
+    }
+    async fetchProfile(capabilities, workspace, environment, cacheKey) {
         const client = this.managedClient(environment);
+        const startedAt = performance.now();
         try {
             const catalog = await client.providers(workspace.path);
             const models = openCodeProfileModels(catalog);
+            const contextLimits = openCodeContextLimits(catalog);
             this.modelsByWorkspace.set(workspace.path, models);
-            this.contextLimitsByWorkspace.set(workspace.path, openCodeContextLimits(catalog));
+            this.contextLimitsByWorkspace.set(workspace.path, contextLimits);
+            this.profileCache.set(cacheKey, {
+                expiresAt: Date.now() + PROFILE_ENTRY_TTL_MS,
+                workspacePath: workspace.path,
+                environmentFingerprint: this.environmentFingerprint(environment),
+                models,
+                contextLimits
+            });
             this.scheduleProfileExpiry(workspace.path);
+            nodeLog('runner.opencode.profile.providers.completed', {
+                workspaceId: workspace.id,
+                models: models.length,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
             return { ...this.profile(capabilities), models };
         }
         catch {
-            this.modelsByWorkspace.delete(workspace.path);
-            this.contextLimitsByWorkspace.delete(workspace.path);
-            this.clearProfileTimer(workspace.path);
+            nodeLog('runner.opencode.profile.providers.failed', {
+                workspaceId: workspace.id,
+                durationMs: Math.round(performance.now() - startedAt)
+            });
         }
         finally {
             this.releaseManagedClient(client);
         }
         return this.profile(capabilities);
     }
+    profileCacheKey(workspacePath, environment) {
+        return createHash('sha256')
+            .update(JSON.stringify({ workspacePath, environment: this.environmentFingerprint(environment) }))
+            .digest('hex');
+    }
+    environmentFingerprint(environment) {
+        const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
+        return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+    }
     available(capabilities) {
         return capabilities.openCode?.available === true;
     }
@@ -68,22 +125,18 @@ export class OpenCodeRunner extends AbstractRunner {
             openCode: { available: true }
         });
     }
-    supportsConfiguration(configuration, workspace) {
+    supportsConfiguration(configuration, workspace, environment = {}) {
         if (configuration.runner !== this.name)
             return false;
-        const models = workspace === undefined
-            ? [...this.modelsByWorkspace.values()].flat()
-            : (this.modelsByWorkspace.get(workspace.path) ?? []);
+        const models = this.cachedModels(workspace, environment);
         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];
+    defaultConfiguration(workspace, environment = {}) {
+        const model = this.cachedModels(workspace, environment)[0];
         return {
             runner: this.name,
             model: model?.id ?? '',
@@ -91,6 +144,15 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    cachedModels(workspace, environment) {
+        const fingerprint = this.environmentFingerprint(environment);
+        const now = Date.now();
+        return [...this.profileCache.values()]
+            .filter((entry) => entry.expiresAt > now &&
+            entry.environmentFingerprint === fingerprint &&
+            (workspace === undefined || entry.workspacePath === workspace.path))
+            .flatMap((entry) => entry.models);
+    }
     mcpConfiguration(raw, secrets) {
         const servers = super.mcpConfiguration(raw, secrets);
         return Object.fromEntries(servers.map((server) => [
@@ -121,7 +183,9 @@ export class OpenCodeRunner extends AbstractRunner {
             }
             for (const value of sessions) {
                 const session = openCodeSession(value);
-                if (session === undefined || !isWithinWorkspace(session.directory, target.path))
+                if (session === undefined ||
+                    session.parentId !== undefined ||
+                    !isWithinWorkspace(session.directory, target.path))
                     continue;
                 result.push(context.createProjection({
                     workspace: target,
@@ -177,6 +241,10 @@ export class OpenCodeRunner extends AbstractRunner {
             return undefined;
         }
     }
+    async readConversationHistory(readers) {
+        const official = await readers.official();
+        return official === undefined ? undefined : { ...official, source: 'official' };
+    }
     managedRunForNativeTurn(nativeTurnId) {
         return this.managedTurns.get(nativeTurnId);
     }
@@ -286,6 +354,8 @@ export class OpenCodeRunner extends AbstractRunner {
         for (const timer of this.profileTimersByWorkspace.values())
             clearTimeout(timer);
         this.profileTimersByWorkspace.clear();
+        this.profileCache.clear();
+        this.profileRefreshes.clear();
         this.modelsByWorkspace.clear();
         this.contextLimitsByWorkspace.clear();
         const stopping = [
@@ -370,6 +440,9 @@ function openCodeSession(value) {
         id: record.id,
         directory: record.directory,
         title: record.title,
-        updatedAt: typeof time?.updated === 'number' ? time.updated : 0
+        updatedAt: typeof time?.updated === 'number' ? time.updated : 0,
+        ...(typeof record.parentID === 'string' && record.parentID.length > 0
+            ? { parentId: record.parentID }
+            : {})
     };
 }

package/dist/runner/runner-registry.js

@@ -1,3 +1,4 @@
+import { nodeLog } from '../operational.js';
 export class RunnerRegistry {
     runners = new Map();
     constructor(runners = []) {
@@ -35,7 +36,21 @@ export class RunnerRegistry {
         });
     }
     async refreshProfiles(capabilities, workspace, environment = {}) {
-        const profiles = await Promise.all(this.advertised().map((runner) => runner.refreshProfile(capabilities, workspace, environment)));
+        const profiles = await Promise.all(this.advertised().map(async (runner) => {
+            const startedAt = performance.now();
+            try {
+                return await runner.refreshProfile(capabilities, workspace, environment);
+            }
+            finally {
+                const durationMs = Math.round(performance.now() - startedAt);
+                if (durationMs >= 100)
+                    nodeLog('runner.profile.refresh.completed', {
+                        runner: runner.name,
+                        workspaceId: workspace?.id,
+                        durationMs
+                    });
+            }
+        }));
         return profiles.flatMap((profile) => (profile === undefined ? [] : [profile]));
     }
     supportsConfiguration(configuration, workspace, environment) {

package/dist/runtime-command-detector.js

@@ -50,18 +50,13 @@ export function normalizeVersion(id, value) {
 }
 async function executeVersion(command, args) {
     const executable = process.platform === 'win32' ? process.env['ComSpec'] || 'cmd.exe' : command;
-    const commandArgs = process.platform === 'win32'
-        ? ['/d', '/s', '/c', [command, ...args].map(quoteWindowsArgument).join(' ')]
-        : [...args];
+    const commandArgs = process.platform === 'win32' ? ['/d', '/s', '/c', [command, ...args].join(' ')] : [...args];
     return execFileAsync(executable, commandArgs, {
         timeout: 5_000,
         maxBuffer: 64 * 1024,
         windowsHide: true
     });
 }
-function quoteWindowsArgument(value) {
-    return `"${value.replaceAll('"', '""')}"`;
-}
 async function resolveCommandPath(command) {
     try {
         const resolver = process.platform === 'win32' ? 'where.exe' : 'which';

package/dist/runtime-state.d.ts

@@ -86,9 +86,11 @@ export declare class NodeRuntimeState {
      */
     setRunnerTitleFromNative(id: string, title: string): NodeAgentSession;
     createMessageRun(input: {
+        readonly runId?: string;
         readonly sessionId: string;
         readonly clientMessageId: string;
         readonly content: string;
+        readonly initiatedByUserId?: number;
         readonly attachments?: readonly NodeMessageAttachmentInput[];
     }): {
         readonly run: NodeAgentRun;

package/dist/runtime-state.js

@@ -255,7 +255,7 @@ export class NodeRuntimeState {
         const session = this.requireSession(input.sessionId);
         const now = this.now();
         const run = {
-            id: randomUUID(),
+            id: input.runId ?? randomUUID(),
             sessionId: session.id,
             nodeId: this.nodeId(),
             workspaceId: session.workspaceId,
@@ -264,6 +264,9 @@ export class NodeRuntimeState {
             recoveryState: 'ACTIVE',
             version: 0,
             clientMessageId: input.clientMessageId,
+            ...(input.initiatedByUserId === undefined
+                ? {}
+                : { initiatedByUserId: input.initiatedByUserId }),
             createdAt: now,
             updatedAt: now
         };
@@ -388,6 +391,7 @@ export class NodeRuntimeState {
                 ? { ...item, payload: { ...item.payload, text: content } }
                 : item)
         }));
+        this.bumpQueueVersion(run.sessionId);
         return run;
     }
     deleteQueuedRun(runId) {
@@ -471,15 +475,16 @@ export class NodeRuntimeState {
     }
     listConversationTurns(input) {
         this.requireSession(input.sessionId);
-        // Queued turns have not received `run.started` yet. Their user item still
-        // has the acceptance timestamp, so use it rather than sorting every
-        // queued turn as time zero. The insertion index makes same-millisecond
-        // sends deterministic; callers receive every page from oldest to newest.
+        // A managed Turn keeps the user's acceptance time as its stable timeline
+        // position. Runner start/completion timestamps must not move it behind a
+        // message that was accepted later. Native Turns without a user timestamp
+        // fall back to their own lifecycle time.
         const all = [...(this.turns.get(input.sessionId) ?? [])]
             .map((turn, index) => ({ turn, index }))
             .sort((a, b) => {
-            const timestamp = (value) => value.startedAt ??
-                value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+            const timestamp = (value) => value.items.find((item) => item.id === value.userItemId)?.startedAt ??
+                value.startedAt ??
+                value.completedAt ??
                 0;
             return timestamp(a.turn) - timestamp(b.turn) || a.index - b.index;
         })

package/dist/service/conversation-history-service.d.ts

@@ -5,6 +5,10 @@ import type { RunnerRegistry } from '../runner/runner-registry.js';
 import { type ConversationHistoryPage } from '../util/runner-native-session-parsers.js';
 import type { RunAttachmentService } from './run-attachment-service.js';
 export declare function hasManagedActiveRun(runtime: NodeRuntimeState, session: NodeAgentSession): boolean;
+export declare function convergeConversationWatchPage(previous: ConversationHistoryPage | undefined, previousObserved: ConversationHistoryPage | undefined, next: ConversationHistoryPage, previousAuthority: unknown): {
+    readonly page: ConversationHistoryPage;
+    readonly authority: ConversationHistoryPage['source'];
+};
 interface ConversationHistoryServiceOptions {
     readonly runtime: NodeRuntimeState;
     readonly runners: RunnerRegistry;
@@ -16,18 +20,23 @@ interface ConversationHistoryServiceOptions {
 }
 export declare class ConversationHistoryService {
     private readonly options;
+    private readonly activeHistoryReads;
     constructor(options: ConversationHistoryServiceOptions);
     read(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
     }): Promise<ConversationHistoryPage>;
+    private readRunnerHistory;
+    private readManagedActive;
+    private prefetchActiveHistory;
+    private takeActiveHistoryRead;
     refreshExternalActivity(session: NodeAgentSession): Promise<void>;
     readNative(session: NodeAgentSession): Promise<import("../native-session-history.js").NativeSessionHistory | undefined>;
     private attachNativeImages;
     readOfficial(session: NodeAgentSession, input: {
         readonly cursor?: string;
         readonly limit?: number;
-    }): Promise<import("../runner/abstract-runner.js").RunnerOfficialConversationPage | undefined>;
+    }): Promise<import("../runner/abstract-runner.js").RunnerConversationPage | undefined>;
     private managedRunnerTurn;
     private page;
 }