@myagentroam/node 0.11.36 → 0.11.38

package/dist/hosting/hosted-conversation-watch.js

@@ -0,0 +1,194 @@
+import { safeErrorCode } from '../util/safe-error.js';
+const WATCH_TTL_MS = 45_000;
+/** Owns hosted Watch leases, initialization ordering and pending realtime events. */
+export class HostedConversationWatch {
+    options;
+    leases = new Map();
+    snapshotSequence = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    watch(input, sessionHash, userId, templateId, models) {
+        const ownerKey = `${sessionHash}:${input.workbenchConnectionId}`;
+        const existing = this.leases.get(ownerKey);
+        if (input.mode === 'renew') {
+            if (!existing ||
+                !this.options.slots.owns(ownerKey, existing.slotToken) ||
+                existing.watchId !== input.watchId ||
+                existing.conversationId !== input.conversationId ||
+                existing.userId !== userId)
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            if (existing.expiresAt <= Date.now()) {
+                this.remove(ownerKey);
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            }
+            return this.renew(existing);
+        }
+        const resolvedModels = models();
+        if (existing &&
+            this.options.slots.owns(ownerKey, existing.slotToken) &&
+            existing.watchId === input.watchId &&
+            existing.conversationId === input.conversationId &&
+            existing.userId === userId &&
+            existing.expiresAt > Date.now())
+            return this.renew(existing);
+        this.remove(ownerKey);
+        const slotToken = this.options.slots.replace(ownerKey, 'hosted-conversation', () => this.remove(ownerKey));
+        const lease = {
+            ownerKey,
+            slotToken,
+            sessionHash,
+            workbenchConnectionId: input.workbenchConnectionId,
+            watchId: input.watchId,
+            conversationId: input.conversationId,
+            templateId,
+            userId,
+            models: resolvedModels,
+            nodeGeneration: this.options.nodeGeneration?.() ?? 'local-test-generation',
+            pendingEvents: [],
+            expiresAt: Date.now() + WATCH_TTL_MS,
+            ready: false,
+            timer: undefined
+        };
+        lease.timer = this.timer(ownerKey);
+        this.leases.set(ownerKey, lease);
+        void this.initialize(lease);
+        return this.accepted(lease);
+    }
+    unwatch(input, sessionHash, userId) {
+        const key = `${sessionHash}:${input.workbenchConnectionId}`;
+        const lease = this.leases.get(key);
+        if (lease?.watchId === input.watchId &&
+            lease.conversationId === input.conversationId &&
+            lease.userId === userId)
+            this.remove(key);
+        return { unwatched: true };
+    }
+    hasConversation(id) {
+        return [...this.leases.values()].some((lease) => lease.conversationId === id);
+    }
+    removeConversation(id) {
+        for (const lease of [...this.leases.values()])
+            if (lease.conversationId === id)
+                this.remove(lease.ownerKey);
+    }
+    close() {
+        for (const key of [...this.leases.keys()])
+            this.remove(key);
+    }
+    publishEvent(conversationId, payload) {
+        const leases = [...this.leases.values()].filter((lease) => lease.conversationId === conversationId);
+        if (leases.length === 0)
+            return false;
+        const event = this.options.nextEvent(payload);
+        if (event === undefined)
+            return false;
+        for (const lease of leases) {
+            if (!lease.ready)
+                lease.pendingEvents.push(event);
+            else
+                this.emitEvent(lease, event);
+        }
+        return true;
+    }
+    publishSnapshot(conversationId, snapshot) {
+        for (const lease of this.leases.values())
+            if (lease.conversationId === conversationId && lease.ready)
+                this.emitSnapshot(lease, snapshot);
+    }
+    async refreshReadySnapshots(conversationId, completedRunId) {
+        const leases = [...this.leases.values()].filter((lease) => lease.conversationId === conversationId && lease.ready);
+        await Promise.allSettled(leases.map(async (lease) => {
+            const snapshot = await this.options.snapshot(lease.userId, conversationId, lease.models);
+            if (this.leases.get(lease.ownerKey) !== lease ||
+                !lease.ready ||
+                !this.options.mayRefresh(conversationId, completedRunId))
+                return;
+            this.emitSnapshot(lease, { ...snapshot, run: null });
+        }));
+    }
+    async initialize(lease) {
+        try {
+            const snapshot = await this.options.initial(lease);
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.emitSnapshot(lease, snapshot);
+            lease.ready = true;
+            for (const event of lease.pendingEvents)
+                this.emitEvent(lease, event);
+            lease.pendingEvents.length = 0;
+        }
+        catch (error) {
+            if (this.leases.get(lease.ownerKey) !== lease)
+                return;
+            this.options.emit?.({
+                type: 'watch.failed',
+                workbenchConnectionId: lease.workbenchConnectionId,
+                watchType: 'hosted-conversation',
+                watchId: lease.watchId,
+                nodeGeneration: lease.nodeGeneration,
+                nodeId: this.options.nodeId(),
+                templateId: lease.templateId,
+                conversationId: lease.conversationId,
+                code: safeErrorCode(error, 'HOSTED_CONVERSATION_WATCH_FAILED'),
+                message: 'Hosted conversation watch snapshot failed.'
+            });
+            this.remove(lease.ownerKey);
+        }
+    }
+    emitSnapshot(lease, payload) {
+        this.options.emit?.({
+            type: 'watch.hosted-conversation.snapshot',
+            workbenchConnectionId: lease.workbenchConnectionId,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            nodeId: this.options.nodeId(),
+            templateId: lease.templateId,
+            conversationId: lease.conversationId,
+            revision: 1,
+            snapshotSequence: ++this.snapshotSequence,
+            expiresAt: lease.expiresAt,
+            payload
+        });
+    }
+    emitEvent(lease, event) {
+        this.options.emit?.({
+            type: 'watch.hosted-conversation.event',
+            workbenchConnectionId: lease.workbenchConnectionId,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            nodeId: this.options.nodeId(),
+            templateId: lease.templateId,
+            conversationId: lease.conversationId,
+            expiresAt: lease.expiresAt,
+            event
+        });
+    }
+    accepted(lease) {
+        return {
+            accepted: true,
+            watchId: lease.watchId,
+            nodeGeneration: lease.nodeGeneration,
+            expiresAt: lease.expiresAt
+        };
+    }
+    renew(lease) {
+        lease.expiresAt = Date.now() + WATCH_TTL_MS;
+        clearTimeout(lease.timer);
+        lease.timer = this.timer(lease.ownerKey);
+        return this.accepted(lease);
+    }
+    remove(key) {
+        const lease = this.leases.get(key);
+        if (!lease)
+            return;
+        clearTimeout(lease.timer);
+        this.leases.delete(key);
+        this.options.slots.release(key, lease.slotToken);
+    }
+    timer(key) {
+        const timer = setTimeout(() => this.remove(key), WATCH_TTL_MS);
+        timer.unref();
+        return timer;
+    }
+}

package/dist/hosting/runtime-contracts.js

@@ -0,0 +1 @@
+export {};

package/dist/runner/abstract-runner.js

@@ -65,16 +65,8 @@ export class AbstractRunner {
     usesRunnerTitleForRename() {
         return false;
     }
-    async renameNative(session, input, database) {
-        if (session.externalSessionId === null)
-            return;
-        database.saveNativeSessionMetadata({
-            runner: session.runner,
-            externalSessionId: session.externalSessionId,
-            workspaceId: session.workspaceId,
-            ...(input.title === undefined ? {} : { customTitle: input.title }),
-            ...(input.pinned === undefined ? {} : { pinned: input.pinned })
-        });
+    async renameNative(session, input) {
+        void [session, input];
     }
     async removeNative(session, nativeSessionId) {
         void [session, nativeSessionId];
@@ -96,9 +88,8 @@ export class AbstractRunner {
         void session;
         throw new RunnerCapabilityError(this.name, 'session.clear');
     }
-    projectedRunnerTitle(metadata, input, database) {
-        void database;
-        return input.title ?? metadata?.runnerTitle ?? null;
+    projectedRunnerTitle(metadata, input) {
+        return { title: input.title ?? metadata?.runnerTitle ?? null, clearPending: false };
     }
     managedAliasId(nativeSessionId) {
         void nativeSessionId;

package/dist/{claude-agent-sdk.js → runner/claude/claude-agent-sdk.js}

@@ -1,9 +1,9 @@
-import { NODE_MCP, NODE_MCP_VERSION } from './mcp/naming.js';
+import { NODE_MCP, NODE_MCP_VERSION } from '../../mcp/naming.js';
 import { spawnSync } from 'node:child_process';
 import { createSdkMcpServer, forkSession, getSessionInfo, getSessionMessages, listSessions, query } from '@anthropic-ai/claude-agent-sdk';
 import { tool } from '@anthropic-ai/claude-agent-sdk';
 import { z } from 'zod';
-import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from './operational.js';
+import { minimalRunnerEnvironment, platformCliInvocation, runRunnerProbe } from '../../operational.js';
 const nativeBindings = {
     query,
     listSessions,

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

@@ -1,4 +1,5 @@
-import { boundedConversationItemId, isPlainRecord, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 import { claudeContentBlocks } from './message-parsers.js';
 export function extractClaudeThinkingText(record) {
     return claudeContentBlocks(record).flatMap((block) => {

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

@@ -1,16 +1,16 @@
 import { claudeAssistantBlocks, extractClaudeThinkingText } from './conversation-parser.js';
 import { ClaudeUsageNormalizer } from './tool-normalizer.js';
 import { createEnvelope } from '@myagentroam/protocol';
-import { ClaudeChannelGate } from '../../claude-channel.js';
+import { ClaudeChannelGate } from './claude-channel.js';
 import { nodeExecutionEnvironment } from '../../node-execution-environment.js';
-import { boundedConversationItemId, compactRunnerText } from '../../util/node-operation-parsers.js';
+import { boundedConversationItemId, compactRunnerText } from '../normalization.js';
 import { extractClaudeText, extractClaudeToolUses } from './message-parsers.js';
 import { claudePlanText } from './conversation-parser.js';
 import { normalizeClaudeTool, extractClaudeToolResults } from './tool-normalizer.js';
 import { claudeContentBlocks } from './message-parsers.js';
-import { parseSecretEnvironment } from '../../util/secret-environment.js';
+import { parseSecretEnvironment } from '../../mcp/secret-environment.js';
 import { safeErrorCode } from '../../util/safe-error.js';
-import { runnerErrorProjection } from '../../util/runner-error.js';
+import { runnerErrorProjection } from '../runner-error.js';
 import { ResponseLatencyTracker } from '../../service/response-latency-tracker.js';
 import { GenerationTimingTracker } from '../../service/generation-timing-tracker.js';
 export class ClaudeManagedRunController {
@@ -81,7 +81,7 @@ export class ClaudeManagedRunController {
             typeof payload.input !== 'string' ||
             typeof payload.cwd !== 'string' ||
             this.host.intercepted() ||
-            this.host.active.has(payload.runId))
+            this.host.isExecutionActive(payload.runId))
             return;
         const runId = payload.runId;
         const sessionId = payload.sessionId;
@@ -123,7 +123,7 @@ export class ClaudeManagedRunController {
             this.host.emit(runId, 'run.rejected', { code: 'SESSION_ACTIVATION_REQUIRED' }, 'FAILED');
             return;
         }
-        this.host.active.add(runId);
+        this.host.executionAccepted(runId);
         this.host.emit(runId, 'run.started', {}, 'STARTING');
         if (contextCompactionItemId !== undefined)
             this.host.emitItem(runId, {
@@ -166,7 +166,6 @@ export class ClaudeManagedRunController {
             this.host.emit(runId, eventType, projected ?? eventPayload, status);
             this.runner.execution.runs.delete(runId);
             handle?.cancel();
-            this.host.active.delete(runId);
         };
         try {
             const gate = new ClaudeChannelGate(sessionId);

package/dist/runner/claude/message-parsers.js

@@ -1,4 +1,5 @@
-import { compactRunnerText, compactRunnerValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 export function extractClaudeText(message) {
     return claudeContentBlocks(message)
         .flatMap((block) => block.type === 'text' && typeof block.text === 'string' ? [block.text] : [])

package/dist/runner/claude/native-transcript.js

@@ -1,7 +1,8 @@
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { forEachJsonlRecord } from '../../native-jsonl-reader.js';
-import { compactRunnerValue as compactValue, isPlainRecord } from '../../util/node-operation-parsers.js';
+import { compactRunnerValue as compactValue } from '../normalization.js';
+import { isPlainRecord } from '../../util/records.js';
 import { stripGoalStartPrompt, publicGoalHistoryText } from '../../service/goal-runtime.js';
 import { readdir } from 'node:fs/promises';
 import { stripClaudePlanTag } from '../../runner-command-engine.js';

package/dist/runner/claude/tool-normalizer.js

@@ -1,5 +1,5 @@
 import { claudeContentBlocks } from './message-parsers.js';
-import { compactRunnerText, compactRunnerValue } from '../../util/node-operation-parsers.js';
+import { compactRunnerText, compactRunnerValue } from '../normalization.js';
 import { RunnerUsageTracker, usageToken, usageTokenSum } from '../../service/runner-usage-tracker.js';
 export class ClaudeUsageNormalizer {
     tracker;

package/dist/runner/claude-code-runner.js

@@ -1,12 +1,12 @@
 import { withMarctlGuide } from '../mcp/marctl-guide.js';
-import { ClaudeAgentSdkAdapter } from '../claude-agent-sdk.js';
+import { ClaudeAgentSdkAdapter } from './claude/claude-agent-sdk.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { claudeDefaultModel, declaredRunnerProfiles } from '../runner-profiles.js';
 import { withClaudePlanTag } from '../runner-command-engine.js';
 import { discoverNativeSessions, readNativeSession } from '../native-session-history.js';
 import { readClaudeNativeContextUsage } from './claude/native-context-usage.js';
 import { claudeDiscoveredSession } from './claude/conversation-parser.js';
-import { deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from '../util/runner-native-session-parsers.js';
+import { deduplicateDirectSessions, isNativeHistory, isWithinWorkspace, latestNativeActivity } from '../session/runner-native-session-parsers.js';
 export class ClaudeCodeRunner extends AbstractRunner {
     client;
     environment;