@myagentroam/node 0.11.36 → 0.11.38

package/dist/application/execution-lifecycle.js

@@ -0,0 +1,54 @@
+/** Coordinates the execution-specific cross-domain terminal and release sequence. */
+export class ExecutionLifecycle {
+    databaseAvailable;
+    scheduled;
+    continuous;
+    goal;
+    usage;
+    goalMcp;
+    scheduleMcp;
+    notificationMcp;
+    events;
+    upgrade;
+    constructor(databaseAvailable, scheduled, continuous, goal, usage, goalMcp, scheduleMcp, notificationMcp, events, upgrade) {
+        this.databaseAvailable = databaseAvailable;
+        this.scheduled = scheduled;
+        this.continuous = continuous;
+        this.goal = goal;
+        this.usage = usage;
+        this.goalMcp = goalMcp;
+        this.scheduleMcp = scheduleMcp;
+        this.notificationMcp = notificationMcp;
+        this.events = events;
+        this.upgrade = upgrade;
+    }
+    terminal(run, status) {
+        if (this.databaseAvailable())
+            this.scheduled.executionTerminated(run, status);
+        this.continuous.runTerminated(run.sessionId);
+    }
+    revokeMcps(executionId) {
+        this.goalMcp.revoke(executionId);
+        this.scheduleMcp.revoke(executionId);
+        this.notificationMcp.revoke(executionId);
+    }
+    release(executionId) {
+        this.usage.release(executionId);
+        this.goal.releaseExecution(executionId);
+        this.revokeMcps(executionId);
+        this.continuous.remove(executionId);
+    }
+    emitItem(runId, item) {
+        this.goal.executionProgress(runId, item);
+        this.events.emitConversationItem(runId, item);
+    }
+    async dispatchQueue(sessionId, delayMs = 0) {
+        if (this.upgrade.pending())
+            return;
+        if (delayMs > 0) {
+            this.continuous.schedule(sessionId, delayMs);
+            return;
+        }
+        await this.continuous.dispatch(sessionId);
+    }
+}

package/dist/application/node-lifecycle.js

@@ -0,0 +1,104 @@
+/** Owns application start/stop serialization; domain resources remain owned by their services. */
+export class NodeLifecycle {
+    startResources;
+    freeze;
+    shutdown;
+    starting;
+    stopping;
+    stoppedValue = false;
+    stopVersion = 0;
+    constructor(startResources, freeze, shutdown) {
+        this.startResources = startResources;
+        this.freeze = freeze;
+        this.shutdown = shutdown;
+    }
+    get stopped() {
+        return this.stoppedValue;
+    }
+    start() {
+        if (this.starting !== undefined)
+            return this.starting;
+        const version = this.stopVersion;
+        const operation = (async () => {
+            if (this.stopping !== undefined)
+                await this.stopping;
+            if (version !== this.stopVersion)
+                throw new Error('NODE_STOPPED');
+            this.stopping = undefined;
+            this.stoppedValue = false;
+            try {
+                await this.startResources();
+            }
+            catch (error) {
+                this.freeze();
+                this.stoppedValue = true;
+                try {
+                    await this.stopResources(false);
+                }
+                catch {
+                    // Preserve the startup failure after attempting cleanup.
+                }
+                throw error;
+            }
+        })();
+        this.starting = operation;
+        void operation
+            .finally(() => {
+            if (this.starting === operation)
+                this.starting = undefined;
+        })
+            .catch(() => { });
+        return operation;
+    }
+    stop(handoff = false) {
+        this.stopVersion += 1;
+        if (this.stopping !== undefined)
+            return this.stopping;
+        this.stoppedValue = true;
+        this.freeze();
+        const starting = this.starting;
+        const operation = (async () => {
+            if (starting !== undefined) {
+                try {
+                    await starting;
+                }
+                catch {
+                    // Failed startup already performed its own cleanup.
+                    return;
+                }
+            }
+            await this.stopResources(handoff);
+        })();
+        this.stopping = operation;
+        return operation;
+    }
+    async stopResources(handoff) {
+        let snapshot;
+        let failure;
+        try {
+            await this.shutdown.waitForRecovery();
+            await this.shutdown.drainInput();
+        }
+        catch (error) {
+            failure = error;
+        }
+        try {
+            await this.shutdown.closeResume();
+            if (failure === undefined && handoff)
+                snapshot = this.shutdown.capture();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        try {
+            await this.shutdown.dispose();
+        }
+        catch (error) {
+            failure ??= error;
+        }
+        if (failure !== undefined)
+            throw failure;
+        if (snapshot !== undefined)
+            await this.shutdown.publish(snapshot);
+    }
+}

package/dist/application/node-operation-admission.js

@@ -0,0 +1,51 @@
+import { nodeLog } from '../operational.js';
+import { isPlainRecord } from '../util/records.js';
+/** Owns operation admission and the in-flight work joined during shutdown. */
+export class NodeOperationAdmission {
+    stopped;
+    databaseAvailable;
+    nodeId;
+    restart;
+    upgrade;
+    git;
+    router;
+    inFlight = new Set();
+    constructor(stopped, databaseAvailable, nodeId, restart, upgrade, git, router) {
+        this.stopped = stopped;
+        this.databaseAvailable = databaseAvailable;
+        this.nodeId = nodeId;
+        this.restart = restart;
+        this.upgrade = upgrade;
+        this.git = git;
+        this.router = router;
+    }
+    async execute(operation, data) {
+        if (this.stopped())
+            throw new Error('NODE_STOPPED');
+        const input = isPlainRecord(data) ? data : {};
+        const sessionId = typeof input.sessionId === 'string' ? input.sessionId : undefined;
+        if (this.restart.blocksOperation(operation, input))
+            throw new Error('SESSION_RESTART_PENDING');
+        if (!this.databaseAvailable())
+            throw new Error('NODE_DATABASE_UNAVAILABLE');
+        if (this.upgrade.blocks(operation))
+            throw new Error('NODE_UPGRADE_PENDING');
+        nodeLog('node.operation', { nodeId: this.nodeId(), operation });
+        const task = this.git.execute(operation, data, (value) => this.router.execute(operation, value));
+        this.inFlight.add(task);
+        try {
+            const result = await task;
+            if ((operation === 'session.command.execute' || operation === 'session.message') &&
+                sessionId !== undefined &&
+                Number.isSafeInteger(input.__requestUserId))
+                this.restart.rememberUser(sessionId, input.__requestUserId);
+            return result;
+        }
+        finally {
+            this.inFlight.delete(task);
+        }
+    }
+    async drain() {
+        await Promise.allSettled([...this.inFlight]);
+    }
+}

package/dist/application/node-operation-contracts.js

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

package/dist/application/runner-composition.js

@@ -0,0 +1,22 @@
+import { CodexRunner } from '../runner/codex-runner.js';
+import { ClaudeCodeRunner } from '../runner/claude-code-runner.js';
+import { OpenCodeRunner } from '../runner/opencode-runner.js';
+import { MarAgentRunner } from '../runner/mar-agent-runner.js';
+import { FakeTestRunner } from '../runner/fake-test-runner.js';
+import { RunnerRegistry } from '../runner/runner-registry.js';
+/** Builds the runner registry from the same concrete instances used by controllers. */
+export function composeRunners(options) {
+    const fake = options.fakeRunner === undefined ? undefined : new FakeTestRunner(options.fakeRunner);
+    const codex = new CodexRunner(options.codexClient, options.codexProfileClientFactory, options.codexRunClientFactory);
+    const claude = new ClaudeCodeRunner(options.claudeClient);
+    const openCode = new OpenCodeRunner(options.openCodeClient);
+    const marAgent = new MarAgentRunner();
+    const registry = new RunnerRegistry([
+        openCode,
+        marAgent,
+        codex,
+        claude,
+        ...(fake === undefined ? [] : [fake])
+    ]);
+    return { codex, claude, openCode, marAgent, fake, registry };
+}

package/dist/application/session-projection-composition.js

@@ -0,0 +1,26 @@
+import { hasManagedActiveRun } from '../service/conversation-history-service.js';
+import { SessionPresentationService } from '../session/session-presentation-service.js';
+import { NativeSessionProjectionService } from '../session/native-session-projection-service.js';
+/** Joins native projection and presentation around their shared Session identity. */
+export function composeSessionProjection(input) {
+    const presentation = new SessionPresentationService({
+        database: input.database,
+        runtime: input.runtime,
+        commands: input.commands,
+        runners: input.runners,
+        capabilities: input.capabilities,
+        hasManagedActiveRun: (session) => hasManagedActiveRun(input.runtime, session),
+        projectionForNative: (session) => native.projectionForNative(session)
+    });
+    const native = new NativeSessionProjectionService({
+        database: input.database,
+        nodeId: input.nodeId,
+        runtime: input.runtime,
+        runners: input.runners,
+        capabilities: input.capabilities,
+        commands: input.commands,
+        releaseResumeState: input.releaseResumeState,
+        present: (session) => presentation.present(session)
+    });
+    return { presentation, native };
+}

package/dist/application/workspace-application.js

@@ -0,0 +1,61 @@
+import { NodeWorkspaceCoordinator } from '../service/node-workspace-coordinator.js';
+import { WorkspaceService } from '../service/workspace-service.js';
+import { WorkspaceWorkbenchService } from '../workspace/workspace-workbench-service.js';
+import { isPlainRecord } from '../util/records.js';
+/** Owns the cross-service workspace removal and observation wiring. */
+export function composeWorkspaceApplication(input) {
+    const resources = input.resources;
+    const coordinator = new NodeWorkspaceCoordinator({
+        config: input.config,
+        database: input.database,
+        watches: resources.watch,
+        sessions: resources.sessions,
+        changes: input.changes,
+        emit: (workspaceId, topic) => void workbench?.invalidateTopic(workspaceId, topic),
+        send: input.send
+    });
+    const workbench = new WorkspaceWorkbenchService({
+        requireWorkspace: (id) => coordinator.require(id),
+        inspectWorkspace: (workspace) => coordinator.inspectMetadata(workspace),
+        commitWorkspace: (workspace, inspection) => coordinator.commitMetadata(workspace, inspection),
+        watch: resources.watch,
+        files: resources.files,
+        uploads: resources.uploads,
+        changes: input.changes,
+        listSessions: input.listSessions,
+        invalidate: resources.invalidateFiles,
+        nodeId: input.nodeId,
+        nodeGeneration: input.nodeGeneration,
+        emitWatchEvent: input.emitWatchEvent
+    });
+    const workspace = new WorkspaceService(() => {
+        const database = input.database();
+        if (database === undefined)
+            throw new Error('NODE_DATABASE_UNAVAILABLE');
+        return database;
+    }, () => {
+        const config = input.config();
+        if (config === undefined)
+            throw new Error('NODE_CONFIG_UNAVAILABLE');
+        return config;
+    }, input.runtime, (id) => {
+        input.terminals.removeWorkspaceAssociation(id);
+        resources.files.dispose(id);
+        coordinator.invalidateChanges(id);
+        resources.sessions.invalidate(id);
+        coordinator.clearWatches(id);
+        workbench.clearWorkspace(id);
+        input.invalidatePrompt(id);
+    }, (id) => coordinator.gitPolicyChanged(id));
+    const publishSession = (payload) => {
+        if (isPlainRecord(payload) && isPlainRecord(payload.session)) {
+            const workspaceId = payload.session.workspaceId;
+            if (typeof workspaceId === 'string') {
+                resources.sessions.markCacheStale(workspaceId);
+                void workbench.invalidateTopic(workspaceId, 'sessions');
+            }
+        }
+        input.publishSession(payload);
+    };
+    return { coordinator, workbench, workspace, publishSession };
+}

package/dist/application/workspace-composition.js

@@ -0,0 +1,21 @@
+import { WorkspaceSessionService } from '../workspace/workspace-session-service.js';
+import { WorkspaceWatchService } from '../workspace/workspace-watch-service.js';
+import { WorkspaceFileService } from '../workspace/workspace-file-service.js';
+import { WorkspaceUploadService } from '../workspace/workspace-upload-service.js';
+/** Composes the mutually dependent workspace resource and observation owners. */
+export function composeWorkspaceResources(input) {
+    const watch = new WorkspaceWatchService((id) => sessions.ensureWatch(id), (id) => sessions.stopWatch(id), input.releaseWatch, input.removeWatch);
+    const sessions = new WorkspaceSessionService({
+        discover: input.discover,
+        listPage: input.listPage,
+        active: (id) => watch.topicActive(id, 'sessions'),
+        invalidate: input.invalidateSessions
+    });
+    const invalidateFiles = (id) => {
+        files.dispose(id);
+        input.invalidateFiles(id);
+    };
+    const uploads = new WorkspaceUploadService(invalidateFiles, input.temporaryRoot);
+    const files = new WorkspaceFileService(invalidateFiles, {}, (id, path) => uploads.fileResource(id, path) ?? input.attachmentResource(id, path));
+    return { watch, sessions, files, uploads, invalidateFiles };
+}

package/dist/capabilities.js

@@ -1,14 +1,13 @@
 import { release, version } from 'node:os';
 import nodePackage from '../package.json' with { type: 'json' };
-import { probeClaudeCode, probeClaudeCodeAsync } from './claude-agent-sdk.js';
-import { probeCodex, probeCodexAsync } from './codex-app-server.js';
+import { probeClaudeCode, probeClaudeCodeAsync } from './runner/claude/claude-agent-sdk.js';
+import { probeCodex, probeCodexAsync } from './runner/codex/codex-app-server.js';
 import { probeOpenCode, probeOpenCodeAsync } from './opencode-runtime.js';
 import { detectRuntimeCommands } from './runtime-command-detector.js';
 const nodeAppVersion = typeof nodePackage.version === 'string' ? nodePackage.version : 'unknown';
 const runtimeCredentialCapability = () => ({
     apiVersion: 1,
     websocket: true,
-    fastMode: true,
     serviceTiers: ['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'],
     namespacedTools: true,
     responsesOptionalParameters: true,