@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/native-session-projection-service.js

@@ -0,0 +1,271 @@
+import { deduplicateDirectSessions } from '../util/runner-native-session-parsers.js';
+export class NativeSessionProjectionService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async discover(runnerName, workspaceId) {
+        const database = this.requireDatabase();
+        const workspace = workspaceId === undefined ? undefined : database.getWorkspace(workspaceId);
+        if (workspaceId !== undefined && workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const runner = this.options.runners.product(runnerName);
+        if (runner === undefined || !runner.available(this.options.capabilities()))
+            throw new Error('RUNNER_UNAVAILABLE');
+        const sessions = await runner.discoverSessions({
+            workspaces: database.listWorkspaces(),
+            createProjection: (input) => this.project(input)
+        }, workspace);
+        const ordered = deduplicateDirectSessions(sessions);
+        this.remember(ordered);
+        return ordered;
+    }
+    async discoverCodex(workspaceId) {
+        const sessions = await this.discover('codex', workspaceId);
+        return { sessions: sessions.map(this.options.present) };
+    }
+    async list() {
+        const discovered = await Promise.all(this.options.runners
+            .advertised()
+            .filter((runner) => runner.available(this.options.capabilities()))
+            .map((runner) => this.discover(runner.name)));
+        const sessions = deduplicateDirectSessions(discovered.flat());
+        this.remember(sessions);
+        return sessions.map(this.options.present);
+    }
+    async discoverWorkspace(workspaceId) {
+        const discovered = await Promise.all(this.options.runners
+            .advertised()
+            .filter((runner) => runner.available(this.options.capabilities()))
+            .map((runner) => this.discover(runner.name, workspaceId)));
+        const sessions = deduplicateDirectSessions(discovered.flat());
+        this.remember(sessions);
+        return sessions;
+    }
+    async resolve(sessionId) {
+        const cached = this.options.state.directNative.get(sessionId);
+        if (cached !== undefined)
+            return cached;
+        const discovered = (await this.list()).find((session) => session.id === sessionId);
+        if (discovered !== undefined)
+            return discovered;
+        const database = this.options.database();
+        const record = database
+            ?.listWorkspaces()
+            .flatMap((workspace) => database.listSessionRecords(workspace.id))
+            .find((candidate) => candidate.id === sessionId);
+        if (record === undefined)
+            return undefined;
+        const workspace = database?.getWorkspace(record.workspaceId);
+        if (workspace === undefined)
+            return undefined;
+        return {
+            id: record.id,
+            nodeId: this.options.nodeId(),
+            workspaceId: record.workspaceId,
+            runner: record.runner,
+            externalSessionId: record.id,
+            nativeControl: 'EXTERNAL',
+            channelToken: null,
+            cwd: workspace.path,
+            model: record.metadata.model,
+            effort: record.metadata.effort,
+            access: record.metadata.access,
+            customTitle: record.metadata.customTitle,
+            runnerTitle: record.metadata.runnerTitle,
+            pinnedAt: record.pinOrder === null ? null : 1,
+            pinOrder: record.pinOrder,
+            externalDiscovered: false,
+            titleSource: record.metadata.customTitle === null ? 'RUNNER' : 'CUSTOM',
+            lastActivityAt: 0,
+            createdAt: 0
+        };
+    }
+    async createMetadataProjection(sessionId) {
+        const direct = await this.resolve(sessionId);
+        if (direct === undefined || direct.externalSessionId === null)
+            return undefined;
+        const existing = this.options.runtime.findAgentSessionByExternalSession(direct.runner, direct.externalSessionId);
+        if (existing !== undefined && existing.workspaceId === direct.workspaceId)
+            return existing;
+        return this.options.runtime.createAgentSession({
+            workspaceId: direct.workspaceId,
+            runner: direct.runner,
+            externalSessionId: direct.externalSessionId,
+            nativeControl: 'EXTERNAL',
+            cwd: direct.cwd,
+            ...(direct.runnerTitle === null ? {} : { title: direct.runnerTitle })
+        });
+    }
+    resumedConfiguration(session) {
+        const workspace = this.options.database()?.getWorkspace(session.workspaceId);
+        const current = {
+            runner: session.runner,
+            model: session.model,
+            effort: session.effort,
+            access: session.access
+        };
+        if (typeof current.model === 'string' &&
+            typeof current.effort === 'string' &&
+            typeof current.access === 'string' &&
+            this.options.runners.supportsConfiguration({
+                runner: current.runner,
+                model: current.model,
+                effort: current.effort,
+                access: current.access
+            }, workspace))
+            return current;
+        const saved = this.options
+            .database()
+            ?.getRunnerDefaults()
+            .find((value) => value.runner === session.runner &&
+            this.options.runners.supportsConfiguration(value, workspace));
+        return saved ?? this.options.runners.require(session.runner).defaultConfiguration(workspace);
+    }
+    ensureResumedConfiguration(session) {
+        const configuration = this.resumedConfiguration(session);
+        if (session.model === configuration.model &&
+            session.effort === configuration.effort &&
+            session.access === configuration.access)
+            return session;
+        return this.options.runtime.updateAgentSessionConfiguration({
+            sessionId: session.id,
+            model: configuration.model,
+            effort: configuration.effort,
+            access: configuration.access
+        });
+    }
+    async rename(session, input) {
+        if (session.externalSessionId === null)
+            return;
+        await this.options.runners
+            .require(session.runner)
+            .renameNative(session, input, this.requireDatabase());
+    }
+    project(input) {
+        const timestamp = input.lastActivityAt ?? 0;
+        const database = this.options.database();
+        const metadata = database?.getNativeSessionMetadata(input.runner, input.externalSessionId, input.workspace.id);
+        const runnerTitle = this.options.runners.require(input.runner).projectedRunnerTitle(metadata, {
+            externalSessionId: input.externalSessionId,
+            workspaceId: input.workspace.id,
+            ...(input.title === undefined ? {} : { title: input.title }),
+            ...(input.titleOrigin === undefined ? {} : { titleOrigin: input.titleOrigin })
+        }, database);
+        return {
+            id: input.externalSessionId,
+            nodeId: this.options.nodeId(),
+            workspaceId: input.workspace.id,
+            runner: input.runner,
+            externalSessionId: input.externalSessionId,
+            nativeControl: 'EXTERNAL',
+            channelToken: null,
+            cwd: input.cwd,
+            model: metadata?.model ?? null,
+            effort: metadata?.effort ?? null,
+            access: metadata?.access ?? null,
+            customTitle: metadata?.customTitle ?? null,
+            runnerTitle,
+            pinnedAt: metadata?.pinnedAt ?? null,
+            pinOrder: metadata?.pinOrder ?? null,
+            externalDiscovered: true,
+            titleSource: metadata?.customTitle === null || metadata?.customTitle === undefined
+                ? runnerTitle === null
+                    ? 'AUTO'
+                    : 'RUNNER'
+                : 'CUSTOM',
+            lastActivityAt: timestamp,
+            createdAt: timestamp
+        };
+    }
+    remember(sessions) {
+        for (const session of sessions)
+            this.options.state.directNative.set(session.id, session);
+    }
+    projectionForNative(native) {
+        if (native.externalSessionId === null)
+            return undefined;
+        const exact = this.options.runtime.findAgentSessionByExternalSession(native.runner, native.externalSessionId);
+        if (exact !== undefined &&
+            exact.runner === native.runner &&
+            exact.workspaceId === native.workspaceId &&
+            exact.externalSessionId === native.externalSessionId)
+            return exact;
+        return this.managedForNative(native);
+    }
+    managedForNative(native) {
+        if (native.externalSessionId === null)
+            return undefined;
+        const exact = this.options.runtime.findAgentSessionByExternalSession(native.runner, native.externalSessionId);
+        if (this.isManagedProjection(exact, native, false))
+            return exact;
+        const aliasId = this.options.runners
+            .require(native.runner)
+            .managedAliasId(native.externalSessionId);
+        const alias = aliasId === undefined ? undefined : this.options.runtime.getAgentSession(aliasId);
+        return this.isManagedProjection(alias, native, true) ? alias : undefined;
+    }
+    nativeIds(session) {
+        const ids = new Set();
+        if (session.externalSessionId !== null)
+            ids.add(session.externalSessionId);
+        for (const nativeId of this.options.runners
+            .require(session.runner)
+            .nativeAliasesFor(session.id))
+            ids.add(nativeId);
+        return ids;
+    }
+    forget(session, knownNativeIds) {
+        if (session.externalSessionId === null)
+            return;
+        const projectionIds = new Set([session.id]);
+        const nativeIds = new Set(knownNativeIds);
+        const runner = this.options.runners.require(session.runner);
+        for (const nativeId of runner.nativeAliasesFor(session.id)) {
+            const managedId = runner.managedAliasId(nativeId);
+            if (managedId !== undefined && (nativeIds.has(nativeId) || managedId === session.id)) {
+                projectionIds.add(managedId);
+                nativeIds.add(nativeId);
+                runner.forgetNativeAlias(nativeId);
+            }
+        }
+        for (const [directId, direct] of this.options.state.directNative) {
+            if (direct.runner === session.runner &&
+                direct.cwd === session.cwd &&
+                direct.externalSessionId !== null &&
+                nativeIds.has(direct.externalSessionId)) {
+                this.options.state.directNative.delete(directId);
+                this.options.state.externalActivity.delete(directId);
+                this.options.state.resumedByDirectId.delete(directId);
+                this.options.state.resumeFailures.delete(directId);
+                this.options.state.resumeFailureDetails.delete(directId);
+            }
+        }
+        for (const [directId, resumedId] of this.options.state.resumedByDirectId)
+            if (projectionIds.has(resumedId))
+                this.options.state.resumedByDirectId.delete(directId);
+        for (const projectionId of projectionIds) {
+            if (this.options.runtime.getAgentSession(projectionId) !== undefined)
+                this.options.runtime.removeAgentSession(projectionId);
+            this.options.commands.removeSession(projectionId);
+            this.options.state.externalActivity.delete(projectionId);
+        }
+    }
+    isManagedProjection(candidate, native, allowAlias) {
+        const exactNativeId = candidate?.externalSessionId === native.externalSessionId;
+        const verifiedAlias = allowAlias &&
+            this.options.runners.require(native.runner).managedAliasId(native.externalSessionId ?? '') ===
+                candidate?.id;
+        return (candidate !== undefined &&
+            candidate.nativeControl === 'MAR_MANAGED' &&
+            candidate.runner === native.runner &&
+            candidate.workspaceId === native.workspaceId &&
+            (exactNativeId || verifiedAlias));
+    }
+    requireDatabase() {
+        const database = this.options.database();
+        if (database === undefined)
+            throw new Error('NODE_DATABASE_UNAVAILABLE');
+        return database;
+    }
+}

package/dist/service/native-session-watch-service.d.ts

@@ -0,0 +1,37 @@
+import type { NodeAgentSession } from '../database.js';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+export interface NativeSessionWatchOptions<TPage extends {
+    readonly turns: readonly unknown[];
+}> {
+    readonly resolve: (sessionId: string) => Promise<NodeAgentSession | undefined>;
+    readonly managedActive: (session: NodeAgentSession) => boolean;
+    readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
+    readonly present: (session: NodeAgentSession) => unknown;
+    readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
+    readonly emitSession: (session: unknown) => void;
+    readonly emitTurn: (turn: unknown) => void;
+}
+export declare class NativeSessionWatchService<TPage extends {
+    readonly turns: readonly unknown[];
+}> {
+    private readonly options;
+    private readonly watches;
+    constructor(options: NativeSessionWatchOptions<TPage>);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private executeWatch;
+    watch(session: NodeAgentSession): {
+        readonly expiresAt: number;
+    } | undefined;
+    renew(session: NodeAgentSession): {
+        readonly expiresAt: number;
+    } | undefined;
+    stop(sessionId: string): void;
+    clear(): void;
+    has(sessionId: string): boolean;
+    entry(sessionId: string): {
+        readonly expiresAt: number;
+    } | undefined;
+    get size(): number;
+    refresh(sessionId: string, limit?: number): Promise<TPage | undefined>;
+    private performRefresh;
+}

package/dist/service/native-session-watch-service.js

@@ -0,0 +1,150 @@
+import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+const INTERVAL_MS = 2_000;
+const TTL_MS = 45_000;
+const MAX_FAILURES = 3;
+const INITIAL_TURN_LIMIT = 30;
+export class NativeSessionWatchService {
+    options;
+    watches = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'session.watch': (data) => this.executeWatch(isPlainRecord(data) ? data : {})
+        };
+    }
+    async executeWatch(input) {
+        if (typeof input.sessionId !== 'string' || (input.mode !== 'initial' && input.mode !== 'renew'))
+            throw new Error('SESSION_INVALID');
+        const session = await this.options.resolve(input.sessionId);
+        if (session === undefined || session.externalSessionId === null)
+            throw new Error('SESSION_NOT_FOUND');
+        if (input.mode === 'renew') {
+            const watch = this.renew(session);
+            if (watch === undefined)
+                throw new Error('SESSION_WATCH_NOT_FOUND');
+            return { renewed: true };
+        }
+        const watch = this.watch(session);
+        const snapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
+        if (watch !== undefined && snapshot === undefined)
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        return {
+            session: this.options.present(session),
+            watch: watch === undefined ? null : { expiresAt: watch.expiresAt },
+            ...(snapshot === undefined ? {} : { snapshot })
+        };
+    }
+    watch(session) {
+        if (this.options.managedActive(session)) {
+            this.stop(session.id);
+            return undefined;
+        }
+        const existing = this.watches.get(session.id);
+        if (existing !== undefined) {
+            existing.expiresAt = Date.now() + TTL_MS;
+            return { expiresAt: existing.expiresAt };
+        }
+        const watch = {
+            expiresAt: Date.now() + TTL_MS,
+            refresh: undefined,
+            sessionSignature: undefined,
+            signature: undefined,
+            failures: 0,
+            timer: undefined
+        };
+        watch.timer = setInterval(() => void this.refresh(session.id), INTERVAL_MS);
+        watch.timer.unref();
+        this.watches.set(session.id, watch);
+        return { expiresAt: watch.expiresAt };
+    }
+    renew(session) {
+        if (this.options.managedActive(session)) {
+            this.stop(session.id);
+            return undefined;
+        }
+        const watch = this.watches.get(session.id);
+        if (watch === undefined || watch.expiresAt <= Date.now()) {
+            this.stop(session.id);
+            return undefined;
+        }
+        watch.expiresAt = Date.now() + TTL_MS;
+        return { expiresAt: watch.expiresAt };
+    }
+    stop(sessionId) {
+        const watch = this.watches.get(sessionId);
+        if (watch === undefined)
+            return;
+        clearInterval(watch.timer);
+        this.watches.delete(sessionId);
+    }
+    clear() {
+        for (const watch of this.watches.values())
+            clearInterval(watch.timer);
+        this.watches.clear();
+    }
+    has(sessionId) {
+        return this.watches.has(sessionId);
+    }
+    entry(sessionId) {
+        return this.watches.get(sessionId);
+    }
+    get size() {
+        return this.watches.size;
+    }
+    async refresh(sessionId, limit = 10) {
+        const watch = this.watches.get(sessionId);
+        if (watch === undefined)
+            return undefined;
+        if (watch.refresh !== undefined)
+            return watch.refresh;
+        if (watch.expiresAt <= Date.now()) {
+            this.stop(sessionId);
+            return undefined;
+        }
+        const refresh = this.performRefresh(sessionId, watch, limit);
+        watch.refresh = refresh;
+        try {
+            return await refresh;
+        }
+        finally {
+            if (this.watches.get(sessionId) === watch)
+                watch.refresh = undefined;
+        }
+    }
+    async performRefresh(sessionId, watch, limit) {
+        try {
+            const session = await this.options.resolve(sessionId);
+            if (session === undefined ||
+                session.externalSessionId === null ||
+                this.options.managedActive(session)) {
+                this.stop(sessionId);
+                return undefined;
+            }
+            await this.options.refreshActivity(session);
+            const presented = this.options.present(session);
+            const sessionSignature = JSON.stringify(presented);
+            if (sessionSignature !== watch.sessionSignature) {
+                watch.sessionSignature = sessionSignature;
+                this.options.emitSession(presented);
+            }
+            const page = await this.options.readPage(session, limit);
+            watch.failures = 0;
+            const turns = page.turns.length <= 10 ? page.turns : page.turns.slice(0, 10);
+            const signature = JSON.stringify(turns);
+            if (signature === watch.signature)
+                return page;
+            watch.signature = signature;
+            for (const turn of turns)
+                this.options.emitTurn(turn);
+            return page;
+        }
+        catch {
+            watch.failures += 1;
+            if (watch.failures >= MAX_FAILURES)
+                this.stop(sessionId);
+            return undefined;
+        }
+    }
+}

package/dist/service/node-connection-lifecycle-service.d.ts

@@ -0,0 +1,37 @@
+import type { NodeCapabilities } from '@myagentroam/protocol';
+import { type NodeConfig } from '../config.js';
+import type { NodeMetrics } from '../operational.js';
+import type { NodeControlChannel } from './node-control-channel.js';
+import type { NodeTerminalChannel } from './node-terminal-channel.js';
+import type { WorkbenchEventService } from './workbench-event-service.js';
+interface NodeConnectionLifecycleServiceOptions {
+    readonly config: () => NodeConfig | undefined;
+    readonly setConfig: (config: NodeConfig) => void;
+    readonly configPath: string | undefined;
+    readonly capabilities: () => NodeCapabilities;
+    readonly detectCapabilities: () => NodeCapabilities | Promise<NodeCapabilities>;
+    readonly capabilitiesProvided: boolean;
+    readonly stopped: () => boolean;
+    readonly setCapabilities: (capabilities: NodeCapabilities) => void;
+    readonly control: NodeControlChannel;
+    readonly terminal: NodeTerminalChannel;
+    readonly events: WorkbenchEventService;
+    readonly metrics: NodeMetrics;
+    readonly heartbeatMs: number;
+    readonly refreshMs: number;
+}
+/** Owns registration completion, heartbeat and background capability refresh timers. */
+export declare class NodeConnectionLifecycleService {
+    private readonly options;
+    private heartbeat;
+    private refreshTimer;
+    private refreshing;
+    constructor(options: NodeConnectionLifecycleServiceOptions);
+    start(): void;
+    startCapabilityRefresh(): void;
+    stop(): void;
+    register(nodeId: string, credential: string): Promise<void>;
+    connected(): void;
+    refreshCapabilities(): Promise<void>;
+}
+export {};

package/dist/service/node-connection-lifecycle-service.js

@@ -0,0 +1,85 @@
+import { saveNodeConfig } from '../config.js';
+/** Owns registration completion, heartbeat and background capability refresh timers. */
+export class NodeConnectionLifecycleService {
+    options;
+    heartbeat;
+    refreshTimer;
+    refreshing = false;
+    constructor(options) {
+        this.options = options;
+    }
+    start() {
+        this.startCapabilityRefresh();
+    }
+    startCapabilityRefresh() {
+        if (this.refreshTimer !== undefined)
+            clearInterval(this.refreshTimer);
+        if (!this.options.capabilitiesProvided)
+            void this.refreshCapabilities();
+        this.refreshTimer = setInterval(() => void this.refreshCapabilities(), this.options.refreshMs);
+    }
+    stop() {
+        if (this.heartbeat !== undefined)
+            clearInterval(this.heartbeat);
+        if (this.refreshTimer !== undefined)
+            clearInterval(this.refreshTimer);
+        this.heartbeat = undefined;
+        this.refreshTimer = undefined;
+    }
+    async register(nodeId, credential) {
+        const config = this.options.config();
+        if (config === undefined)
+            return;
+        const registered = {
+            serverUrl: config.serverUrl,
+            allowedRoots: config.allowedRoots,
+            ...(config.databasePath === undefined ? {} : { databasePath: config.databasePath }),
+            ...(config.upgrade === undefined ? {} : { upgrade: config.upgrade }),
+            nodeId,
+            credential
+        };
+        this.options.setConfig(registered);
+        await saveNodeConfig(registered, this.options.configPath);
+        this.connected();
+    }
+    connected() {
+        if (this.heartbeat !== undefined)
+            clearInterval(this.heartbeat);
+        this.options.control.send('capabilities', this.options.capabilities());
+        this.options.terminal.connect();
+        this.options.control.send('heartbeat', {});
+        this.options.metrics.heartbeatSent();
+        this.options.events.replay();
+        this.heartbeat = setInterval(() => {
+            this.options.metrics.heartbeatSent();
+            this.options.control.send('heartbeat', {});
+        }, this.options.heartbeatMs);
+    }
+    async refreshCapabilities() {
+        if (this.options.stopped() || this.refreshing)
+            return;
+        this.refreshing = true;
+        try {
+            let next;
+            try {
+                next = await this.options.detectCapabilities();
+            }
+            catch {
+                next = {
+                    ...this.options.capabilities(),
+                    codex: { available: false },
+                    claudeCode: { available: false },
+                    openCode: { available: false }
+                };
+            }
+            if (this.options.stopped() ||
+                JSON.stringify(next) === JSON.stringify(this.options.capabilities()))
+                return;
+            this.options.setCapabilities(next);
+            this.options.control.send('capabilities', next);
+        }
+        finally {
+            this.refreshing = false;
+        }
+    }
+}

package/dist/service/node-control-channel.d.ts

@@ -0,0 +1,32 @@
+import WebSocket from 'ws';
+import { type NodeCapabilities, type NodeEnvelope } from '@myagentroam/protocol';
+import type { NodeConfig } from '../config.js';
+interface NodeControlChannelOptions {
+    readonly config: () => NodeConfig | undefined;
+    readonly capabilities: () => NodeCapabilities;
+    readonly stopped: () => boolean;
+    readonly reconnect: boolean;
+    readonly reconnectDelay: (attempt: number) => number;
+    readonly onConnecting: (attempt: number) => void;
+    readonly onReconnectScheduled: () => void;
+    readonly onMessage: (raw: string) => void;
+    readonly onClose: (code: number, reason: string) => void;
+}
+export declare class NodeControlChannel {
+    private readonly options;
+    private socket;
+    private readonly outbound;
+    private reconnectTimer;
+    private attempts;
+    constructor(options: NodeControlChannelOptions);
+    connect(): void;
+    connected(): boolean;
+    /** Keeps transport injection at the transport boundary for contract tests. */
+    replaceSocketForTesting(socket: WebSocket | undefined): void;
+    close(code?: number, reason?: string): void;
+    stop(): void;
+    send(type: string, payload: unknown, replyTo?: string): void;
+    sendEnvelope(envelope: NodeEnvelope): void;
+    private scheduleReconnect;
+}
+export {};