@myagentroam/node 0.10.61 → 0.10.63

package/dist/service/conversation-hosting-lifecycle-service.js

@@ -0,0 +1,195 @@
+import { hostedConversationStorePath, nodeDataDirectory } from '../config.js';
+import { HostedConversationStore } from './hosted-conversation-store.js';
+import { ConversationTemplateNodeService } from './conversation-template-node-service.js';
+import { HostedConversationNodeService } from './hosted-conversation-node-service.js';
+import { ConversationHostingMaintenanceService } from './conversation-hosting-maintenance-service.js';
+import { MarAgentHostedConversationRuntime } from '../runner/mar-agent/hosted-conversation-runtime.js';
+import { BubblewrapSandboxExecutor } from '@myagentroam/agent/sandbox/linux';
+import { hostedConversationSandboxProfile } from './hosted-conversation-sandbox-profile.js';
+import { conversationHostingCapability } from './conversation-hosting-capability-service.js';
+import { nodeLog } from '../operational.js';
+import { safeErrorCode } from '../util/safe-error.js';
+/** Owns the hosting resource lifetime, including partial initialization and hot reconfiguration. */
+export class ConversationHostingLifecycleService {
+    options;
+    resources;
+    failureCode;
+    initializing;
+    closing;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    handler(operation) {
+        return this.resources?.operations[operation];
+    }
+    prepareForDisable() {
+        return this.resources?.service.prepareForDisable() ?? (this.resources ? undefined : () => { });
+    }
+    initialize() {
+        if (this.closed)
+            return Promise.resolve();
+        const work = (this.initializing ?? Promise.resolve()).then(() => this.rebuild());
+        this.initializing = work;
+        return work.finally(() => {
+            if (this.initializing === work)
+                this.initializing = undefined;
+        });
+    }
+    dispose() {
+        if (this.closing)
+            return this.closing;
+        this.closed = true;
+        const current = this.resources;
+        this.resources = undefined;
+        this.closing = (async () => {
+            try {
+                await this.initializing;
+            }
+            finally {
+                await this.release(current);
+            }
+        })();
+        return this.closing;
+    }
+    async release(resources) {
+        if (!resources)
+            return;
+        try {
+            await resources.maintenance.dispose();
+        }
+        finally {
+            resources.service.dispose();
+            await resources.runtime.dispose().catch(() => undefined);
+        }
+    }
+    async rebuild() {
+        if (this.closed)
+            return;
+        const previous = this.resources;
+        this.resources = undefined;
+        this.failureCode = undefined;
+        await this.release(previous);
+        if (this.closed)
+            return;
+        const config = this.options.config();
+        const database = this.options.database();
+        if (config?.conversationHosting?.enabled === true &&
+            this.options.capabilities().platform === 'linux') {
+            if (config.nodeId === undefined) {
+                this.failureCode = 'NODE_UNAUTHENTICATED';
+            }
+            else {
+                let runtime;
+                let hostedService;
+                let maintenanceService;
+                try {
+                    if (database === undefined)
+                        throw new Error('NODE_DATABASE_UNAVAILABLE');
+                    const rootDirectory = hostedConversationStorePath(config, this.options.configPath);
+                    if (rootDirectory === undefined)
+                        throw new Error('CONVERSATION_HOSTING_STORAGE_UNAVAILABLE');
+                    const store = new HostedConversationStore({
+                        dataDirectory: nodeDataDirectory(config, this.options.configPath),
+                        rootDirectory,
+                        nodeId: config.nodeId,
+                        database: database
+                    });
+                    await store.initialize();
+                    const templateService = new ConversationTemplateNodeService({
+                        database: database,
+                        store,
+                        nodeId: () => this.options.config()?.nodeId ?? 'unregistered'
+                    });
+                    await templateService.recoverInterruptedPublications();
+                    await store.rebuildConversationIndex();
+                    runtime = new MarAgentHostedConversationRuntime({
+                        ...this.options.runtime
+                    });
+                    hostedService = new HostedConversationNodeService({
+                        ...this.options.host,
+                        database: database,
+                        store,
+                        runtime,
+                        nodeId: () => this.options.config()?.nodeId ?? 'unregistered',
+                        nodeAppVersion: () => this.options.capabilities().nodeAppVersion ?? 'unknown',
+                        processExecutorFactory: (input) => new BubblewrapSandboxExecutor({
+                            profile: hostedConversationSandboxProfile(input)
+                        }),
+                        assertCanCreate: () => {
+                            if (maintenanceService === undefined)
+                                throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
+                            return maintenanceService.assertCanCreate();
+                        }
+                    });
+                    maintenanceService = new ConversationHostingMaintenanceService({
+                        store,
+                        inactiveRetentionDays: config.conversationHosting.inactiveRetentionDays ?? 60,
+                        isConversationInUse: (conversationId) => hostedService?.isConversationInUse(conversationId) ?? true,
+                        beginConversationCleanup: (conversationId) => hostedService?.beginConversationCleanup(conversationId),
+                        releaseConversation: (conversation) => {
+                            if (hostedService === undefined)
+                                throw new Error('CONVERSATION_HOSTING_UNAVAILABLE');
+                            return hostedService.releaseConversationForCleanup(conversation);
+                        },
+                        onAutomaticCleanupError: (error) => nodeLog('conversation.hosting.cleanup.failed', {
+                            nodeId: config.nodeId,
+                            code: safeErrorCode(error, 'CONVERSATION_HOSTING_CLEANUP_FAILED')
+                        })
+                    });
+                    await maintenanceService.start();
+                    if (this.closed) {
+                        await this.release({
+                            runtime,
+                            service: hostedService,
+                            maintenance: maintenanceService,
+                            operations: {}
+                        });
+                        return;
+                    }
+                    this.resources = {
+                        runtime,
+                        service: hostedService,
+                        maintenance: maintenanceService,
+                        operations: {
+                            ...templateService.operations(),
+                            ...hostedService.operations(),
+                            ...maintenanceService.operations()
+                        }
+                    };
+                }
+                catch (error) {
+                    await maintenanceService?.dispose();
+                    hostedService?.dispose();
+                    await runtime?.dispose().catch(() => undefined);
+                    if (this.closed)
+                        return;
+                    this.failureCode = safeErrorCode(error, 'CONVERSATION_HOSTING_RECOVERY_FAILED');
+                    nodeLog('conversation.hosting.initialization.failed', {
+                        nodeId: config.nodeId,
+                        code: this.failureCode
+                    });
+                }
+            }
+        }
+    }
+    async project(capabilities) {
+        const current = this.resources;
+        let ready = current !== undefined;
+        let failureCode = this.failureCode;
+        let capacity = 'AVAILABLE';
+        if (current) {
+            try {
+                capacity = (await current.maintenance.storageCapacity()).capacity;
+            }
+            catch (error) {
+                ready = false;
+                failureCode = safeErrorCode(error, 'CONVERSATION_HOSTING_STORAGE_UNAVAILABLE');
+            }
+        }
+        const conversationHosting = await conversationHostingCapability(capabilities, this.options.config(), ready, failureCode, this.options.probe, capacity);
+        if (current !== this.resources)
+            return this.project(capabilities);
+        return { ...capabilities, conversationHosting };
+    }
+}

package/dist/service/conversation-observation.js

@@ -0,0 +1,240 @@
+import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { composeConversationRuntimePage, convergeConversationWatchPage } from './conversation-history-service.js';
+const INITIAL_TURN_LIMIT = 30;
+const EMITTED_TURN_LIMIT = 10;
+/** Conversation state shared by a Session's leases; no timers or transport ownership. */
+export class ConversationObservation {
+    session;
+    options;
+    mode;
+    page;
+    observedPage;
+    authority;
+    signature;
+    runtimePage;
+    runtimeRevision;
+    runtimeRead;
+    historyRead;
+    refreshRead;
+    refreshMode;
+    eventRevision = 0;
+    transitionGeneration = 0;
+    closed = false;
+    pendingRuntimeSnapshot = false;
+    stage = 'read_page';
+    constructor(session, options) {
+        this.session = session;
+        this.options = options;
+        this.mode = options.managedActive(session) ? 'RUNNING' : 'HISTORY';
+    }
+    get snapshotPending() {
+        return this.mode === 'RUNNING' && this.pendingRuntimeSnapshot;
+    }
+    close() {
+        this.closed = true;
+        this.page = this.observedPage = this.runtimePage = undefined;
+    }
+    async initial() {
+        if (this.closed)
+            return undefined;
+        if (this.options.managedActive(this.session)) {
+            this.mode = 'RUNNING';
+            return { page: await this.runningWindow(), changed: false, handoff: false, snapshot: false };
+        }
+        // A fresh initial must not join an older observation's smaller or stale window.
+        if (this.refreshRead !== undefined &&
+            (this.page !== undefined || this.refreshMode === 'observation'))
+            await this.refreshRead.catch(() => undefined);
+        if (this.closed)
+            return undefined;
+        const joinedInitial = this.refreshRead !== undefined;
+        const update = await this.refresh('initial', INITIAL_TURN_LIMIT);
+        if (this.closed || update === undefined)
+            return undefined;
+        if (this.options.managedActive(this.session)) {
+            this.mode = 'RUNNING';
+            return { ...update, page: await this.runningWindow(update.page) };
+        }
+        return joinedInitial ? { ...update, changed: false, handoff: false, snapshot: false } : update;
+    }
+    refresh(mode = 'observation', limit = EMITTED_TURN_LIMIT) {
+        if (this.refreshRead !== undefined)
+            return this.refreshRead;
+        const read = this.performRefresh(mode, limit).finally(() => {
+            if (this.refreshRead === read) {
+                this.refreshRead = undefined;
+                this.refreshMode = undefined;
+            }
+        });
+        this.refreshRead = read;
+        this.refreshMode = mode;
+        return read;
+    }
+    async performRefresh(mode, limit) {
+        if (this.closed || this.options.suspended?.(this.session.id) === true)
+            return undefined;
+        if (mode === 'observation' && this.options.managedActive(this.session))
+            return undefined;
+        const historical = this.mode === 'HISTORY' && this.options.readHistoryPage !== undefined;
+        this.stage = 'refresh_activity';
+        await this.options.refreshActivity(this.session);
+        if (this.closed || this.options.suspended?.(this.session.id) === true)
+            return undefined;
+        this.stage = 'read_page';
+        const revision = this.eventRevision;
+        const page = await (historical
+            ? this.options.readHistoryPage(this.session, limit)
+            : this.options.readPage(this.session, limit));
+        if (this.closed)
+            return undefined;
+        if (revision !== this.eventRevision) {
+            if (mode !== 'initial')
+                return undefined;
+            const initial = convergeConversationWatchPage(this.page, this.observedPage, page, this.authority).page;
+            if (this.page === undefined && this.signature === undefined)
+                this.signature = JSON.stringify({
+                    source: initial.source,
+                    turns: initial.turns.slice(-EMITTED_TURN_LIMIT)
+                });
+            return { page: initial, changed: false, handoff: false, snapshot: false };
+        }
+        this.stage = 'converge_page';
+        const convergence = convergeConversationWatchPage(this.page, this.observedPage, page, this.authority);
+        this.observedPage = { ...page, turns: page.turns.slice(-EMITTED_TURN_LIMIT) };
+        this.authority = convergence.authority;
+        const accepted = {
+            ...convergence.page,
+            turns: convergence.page.turns.slice(-(EMITTED_TURN_LIMIT + 1))
+        };
+        const handoff = this.mode === 'CONVERGING' && !this.options.managedActive(this.session);
+        if (handoff) {
+            this.mode = 'HISTORY';
+            this.runtimePage = undefined;
+            this.runtimeRevision = undefined;
+        }
+        const signature = JSON.stringify({
+            source: accepted.source,
+            turns: accepted.turns.slice(-EMITTED_TURN_LIMIT)
+        });
+        const changed = signature !== this.signature;
+        this.signature = signature;
+        // Keep coverage metadata current even when the visible content did not change.
+        this.page = accepted;
+        return {
+            page: mode === 'initial' ? convergence.page : accepted,
+            changed,
+            handoff,
+            snapshot: handoff && (changed || accepted.source !== 'runtime')
+        };
+    }
+    /** Return work only for a domain transition; the Watch pauses delivery, not the Run. */
+    observe(event) {
+        this.eventRevision = event.sequence;
+        const activity = sessionActivity(event);
+        if (activity === 'RUNNING' && this.mode !== 'RUNNING') {
+            this.mode = 'RUNNING';
+            const generation = ++this.transitionGeneration;
+            return this.runtimeSnapshot(generation);
+        }
+        if (activity === 'IDLE' && this.mode === 'RUNNING') {
+            this.mode = 'CONVERGING';
+            const generation = ++this.transitionGeneration;
+            return this.convergeHistory(generation);
+        }
+        return undefined;
+    }
+    hydrate() {
+        if (this.closed ||
+            this.mode !== 'RUNNING' ||
+            this.page !== undefined ||
+            this.options.readHistoryPage === undefined)
+            return undefined;
+        if (this.historyRead !== undefined)
+            return undefined;
+        const read = this.hydrateHistory().finally(() => {
+            if (this.historyRead === read)
+                this.historyRead = undefined;
+        });
+        this.historyRead = read;
+        return read;
+    }
+    async hydrateHistory() {
+        const generation = this.transitionGeneration;
+        try {
+            const page = await this.options.readHistoryPage(this.session, INITIAL_TURN_LIMIT);
+            if (this.closed || this.mode !== 'RUNNING' || this.transitionGeneration !== generation)
+                return undefined;
+            this.page = page;
+            this.authority = page.source;
+            return await this.runtimeSnapshot(generation);
+        }
+        catch (error) {
+            if (this.closed || this.transitionGeneration !== generation)
+                return undefined;
+            throw error;
+        }
+    }
+    async convergeHistory(generation) {
+        await this.historyRead?.catch(() => undefined);
+        // Let the current event enter each lease's buffer before completing a handoff.
+        if (this.closed || this.mode !== 'CONVERGING' || this.transitionGeneration !== generation)
+            return undefined;
+        return this.refresh('observation', INITIAL_TURN_LIMIT);
+    }
+    async runningWindow(history = this.page) {
+        return composeConversationRuntimePage(history, await this.readRuntime());
+    }
+    async runtimeSnapshot(generation) {
+        this.pendingRuntimeSnapshot = true;
+        try {
+            const page = await this.runningWindow();
+            if (this.closed || this.mode !== 'RUNNING' || this.transitionGeneration !== generation)
+                return undefined;
+            return { page, changed: true, handoff: true, snapshot: true };
+        }
+        finally {
+            if (this.transitionGeneration === generation)
+                this.pendingRuntimeSnapshot = false;
+        }
+    }
+    readRuntime() {
+        if (this.runtimePage !== undefined && this.runtimeRevision === this.eventRevision)
+            return Promise.resolve(this.runtimePage);
+        if (this.runtimeRead?.revision === this.eventRevision)
+            return this.runtimeRead.read;
+        const revision = this.eventRevision;
+        const read = this.options
+            .readPage(this.session, INITIAL_TURN_LIMIT)
+            .then((page) => {
+            if (!this.closed && this.runtimeRead?.read === read) {
+                this.runtimePage = page;
+                this.runtimeRevision = revision;
+            }
+            return page;
+        })
+            .finally(() => {
+            if (this.runtimeRead?.read === read)
+                this.runtimeRead = undefined;
+        });
+        this.runtimeRead = { revision, read };
+        return read;
+    }
+}
+function sessionActivity(event) {
+    if (!isPlainRecord(event.payload))
+        return undefined;
+    if (event.category === 'run' && isPlainRecord(event.payload.run)) {
+        const status = event.payload.run.status;
+        return status === 'STARTING' || status === 'RUNNING' || status === 'CANCELLING'
+            ? 'RUNNING'
+            : undefined;
+    }
+    if (event.category !== 'session' || !isPlainRecord(event.payload.session))
+        return undefined;
+    const activity = event.payload.session.activity;
+    return typeof activity === 'string'
+        ? activity === 'MANAGED_ACTIVE'
+            ? 'RUNNING'
+            : 'IDLE'
+        : undefined;
+}