@myagentroam/node 0.1.3 → 0.1.6

package/dist/service/session-catalog-service.js

@@ -0,0 +1,224 @@
+import { removeNativeSession } from '../native-session-history.js';
+import { isTerminalRunStatus, sessionPage } from '../util/node-operation-parsers.js';
+export class SessionCatalogService {
+    options;
+    rewindQueue = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'session.list': (data) => this.list(record(data)),
+            'session.resume': (data) => this.resume(record(data)),
+            'session.remove': (data) => this.remove(record(data)),
+            'session.rewind': (data) => this.enqueueRewind(record(data))
+        };
+    }
+    async list(input) {
+        const workspaceId = typeof input.workspaceId === 'string' ? input.workspaceId : undefined;
+        const nativeSessions = workspaceId === undefined
+            ? this.options.cachedNative()
+            : await this.options.cachedWorkspace(workspaceId);
+        const native = nativeSessions.map((session) => this.options.present({ ...session, externalDiscovered: true }));
+        const projected = this.options.runtime
+            .listAgentSessions()
+            .filter((session) => session.nativeControl === 'MAR_MANAGED' ||
+            (session.nativeControl === 'EXTERNAL' && session.externalSessionId !== null))
+            .map((session) => {
+            const source = native.find((candidate) => this.options.projectionForNative(candidate)?.id === session.id);
+            return this.options.present(source === undefined
+                ? session
+                : {
+                    ...session,
+                    runnerTitle: source.runnerTitle,
+                    pinnedAt: source.pinnedAt,
+                    pinOrder: source.pinOrder ?? null,
+                    externalDiscovered: true,
+                    titleSource: session.customTitle === null ? source.titleSource : session.titleSource,
+                    lastActivityAt: source.lastActivityAt
+                });
+        });
+        const merged = new Map([
+            ...projected,
+            ...native.filter((candidate) => candidate.externalSessionId === null ||
+                this.options.projectionForNative(candidate) === undefined)
+        ].map((session) => [session.id, session]));
+        if (workspaceId !== undefined)
+            this.mergePersisted(merged, workspaceId);
+        const sessions = [...merged.values()];
+        return sessionPage(workspaceId === undefined
+            ? sessions
+            : sessions.filter((session) => session.workspaceId === workspaceId), input);
+    }
+    mergePersisted(merged, workspaceId) {
+        const database = this.options.database();
+        const workspace = database.getWorkspace(workspaceId);
+        if (workspace === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        for (const persisted of database.listSessionRecords(workspaceId)) {
+            if (merged.has(persisted.id))
+                continue;
+            merged.set(persisted.id, this.options.present({
+                id: persisted.id,
+                nodeId: this.options.nodeId(),
+                workspaceId,
+                runner: persisted.runner,
+                externalSessionId: persisted.id,
+                nativeControl: 'EXTERNAL',
+                channelToken: null,
+                cwd: workspace.path,
+                model: persisted.metadata.model,
+                effort: persisted.metadata.effort,
+                access: persisted.metadata.access,
+                customTitle: persisted.metadata.customTitle,
+                runnerTitle: persisted.metadata.runnerTitle,
+                pinnedAt: persisted.pinOrder === null ? null : 1,
+                pinOrder: persisted.pinOrder,
+                externalDiscovered: false,
+                titleSource: persisted.metadata.customTitle === null ? 'RUNNER' : 'CUSTOM',
+                lastActivityAt: 0,
+                createdAt: 0
+            }));
+        }
+    }
+    async resume(input) {
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const value = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.resolve(input.sessionId));
+        if (value === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (value.nativeControl !== 'EXTERNAL')
+            return {
+                session: this.options.present(value),
+                delivery: this.options.resume.delivery(value)
+            };
+        const resumed = await this.options.resume.resume(value, true);
+        const failure = resumed === undefined ? this.options.resume.failure(value.id) : undefined;
+        return {
+            session: this.options.present(resumed ?? value),
+            delivery: resumed === undefined ? 'REJECTED' : 'RESUMABLE',
+            ...(resumed === undefined
+                ? {
+                    reasonCode: failure?.code ?? 'SESSION_RESUME_REJECTED',
+                    ...(failure?.detail === undefined ? {} : { reasonDetail: failure.detail })
+                }
+                : {})
+        };
+    }
+    enqueueRewind(input) {
+        const result = this.rewindQueue.then(() => this.rewind(input));
+        this.rewindQueue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async rewind(input) {
+        if (!validRewindId(input.sessionId, 128) ||
+            !validRewindId(input.turnId, 128) ||
+            (input.position !== 'BEFORE' && input.position !== 'AFTER') ||
+            (input.boundary !== null && !validRewindId(input.boundary, 256)))
+            throw new Error('SESSION_REWIND_INVALID');
+        const source = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.resolve(input.sessionId));
+        if (source === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (source.externalSessionId === null)
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        const presented = this.options.present(source);
+        if (!presented.runtime?.capabilities?.includes('session.rewind'))
+            throw new Error('SESSION_REWIND_UNAVAILABLE');
+        const turn = await this.findTurn(source, input.turnId);
+        const expected = input.position === 'BEFORE' ? turn?.rewind?.before : turn?.rewind?.after;
+        if (turn === undefined || expected !== input.boundary)
+            throw new Error('SESSION_REWIND_TARGET_INVALID');
+        const title = rewindTitle(source.customTitle ?? source.runnerTitle ?? '未命名会话', this.options.runtime
+            .listAgentSessions()
+            .flatMap((candidate) => [candidate.customTitle ?? candidate.runnerTitle].filter(isString)));
+        const runner = this.options.runners.require(source.runner);
+        const nativeId = await runner.forkNative(source, input.boundary, title);
+        const session = this.options.runtime.createAgentSession({
+            workspaceId: source.workspaceId,
+            runner: source.runner,
+            cwd: source.cwd,
+            nativeControl: 'MAR_MANAGED',
+            ...(nativeId === null ? {} : { externalSessionId: nativeId }),
+            ...(source.model === null ? {} : { model: source.model }),
+            ...(source.effort === null ? {} : { effort: source.effort }),
+            ...(source.access === null ? {} : { access: source.access }),
+            title
+        });
+        if (nativeId !== null)
+            runner.rememberManagedNative(session, nativeId);
+        this.options.emitSession(session);
+        return { session: this.options.present(session) };
+    }
+    async findTurn(session, turnId) {
+        let cursor;
+        for (let pageIndex = 0; pageIndex < 100; pageIndex += 1) {
+            const page = await this.options.history(session, {
+                ...(cursor === undefined ? {} : { cursor }),
+                limit: 100
+            });
+            const turn = page.turns.find((candidate) => candidate.id === turnId);
+            if (turn !== undefined || page.nextCursor === null)
+                return turn;
+            cursor = page.nextCursor;
+        }
+        throw new Error('SESSION_REWIND_TARGET_INVALID');
+    }
+    async remove(input) {
+        if (typeof input.sessionId !== 'string')
+            throw new Error('SESSION_INVALID');
+        const session = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.resolve(input.sessionId));
+        if (session === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        if (session.externalSessionId === null)
+            throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        if (this.options.runtime
+            .listRunsForSession(session.id)
+            .some((run) => !isTerminalRunStatus(run.status)))
+            throw new Error('SESSION_ACTIVE');
+        if (session.nativeControl === 'EXTERNAL') {
+            await this.options.refreshActivity(session);
+            if (this.options.externalActivity(session.id) === 'EXTERNAL_ACTIVE')
+                throw new Error('SESSION_ACTIVE');
+        }
+        const nativeIds = this.options.nativeIds(session);
+        const runner = this.options.runners.require(session.runner);
+        for (const externalSessionId of nativeIds) {
+            try {
+                if (!(await runner.removeNative(session, externalSessionId)))
+                    await removeNativeSession(session.runner, session.cwd, externalSessionId);
+            }
+            catch (error) {
+                if (!(error instanceof Error) || error.message !== 'NATIVE_TRANSCRIPT_UNAVAILABLE')
+                    throw error;
+            }
+        }
+        this.options.database().deleteSessionRecord(session.id);
+        this.options.forget(session, nativeIds);
+        return { deleted: true };
+    }
+}
+export function rewindTitle(sourceTitle, existingTitles = []) {
+    const base = sourceTitle.replace(/ \(Copy \d+\)$/u, '');
+    const existing = new Set(existingTitles);
+    for (let sequence = 1; sequence < Number.MAX_SAFE_INTEGER; sequence += 1) {
+        const suffix = ` (Copy ${sequence})`;
+        const candidate = `${base.slice(0, 160 - suffix.length)}${suffix}`;
+        if (!existing.has(candidate))
+            return candidate;
+    }
+    throw new Error('SESSION_REWIND_TITLE_UNAVAILABLE');
+}
+function validRewindId(value, maximum) {
+    return typeof value === 'string' && value.length > 0 && value.length <= maximum;
+}
+function isString(value) {
+    return value !== null;
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return value;
+}

package/dist/service/session-command-service.d.ts

@@ -0,0 +1,23 @@
+import type { RunnerProfile } from '@myagentroam/protocol';
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { ExternalSessionResumeService } from './external-session-resume-service.js';
+import type { NativeSessionProjectionService } from './native-session-projection-service.js';
+interface SessionCommandServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly projection: NativeSessionProjectionService;
+    readonly resume: ExternalSessionResumeService;
+    readonly profiles: () => readonly RunnerProfile[];
+    readonly present: (session: NodeAgentSession) => unknown;
+}
+export declare class SessionCommandService {
+    private readonly options;
+    constructor(options: SessionCommandServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    private runnerCommand;
+    private sessionCommand;
+}
+export {};

package/dist/service/session-command-service.js

@@ -0,0 +1,69 @@
+import { parseCommandInvocation } from '../runner-command-engine.js';
+import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { parseSecretEnvironment } from '../util/secret-environment.js';
+export class SessionCommandService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    operations() {
+        return {
+            'runner.command.execute': (data) => this.runnerCommand(record(data)),
+            'session.command.execute': (data) => this.sessionCommand(record(data))
+        };
+    }
+    runnerCommand(input) {
+        const runner = this.options.runners.product(input.runner);
+        if (runner === undefined ||
+            typeof input.commandId !== 'string' ||
+            typeof input.input !== 'string')
+            throw new Error('RUNNER_COMMAND_INVALID');
+        try {
+            return runner.executeGlobalCommand(input.commandId, input.input);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'RUNNER_COMMAND_INVALID')
+                throw error;
+            throw new Error('RUNNER_COMMAND_INVALID');
+        }
+    }
+    async sessionCommand(input) {
+        if (typeof input.sessionId !== 'string' ||
+            typeof input.commandId !== 'string' ||
+            input.commandId.length === 0 ||
+            typeof input.input !== 'string' ||
+            input.input.length < 2 ||
+            input.input.length > 20_000)
+            throw new Error('RUNNER_COMMAND_INVALID');
+        const resolved = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.projection.resolve(input.sessionId));
+        if (resolved === undefined)
+            throw new Error('SESSION_NOT_FOUND');
+        const session = resolved.nativeControl === 'EXTERNAL' ? await this.options.resume.resume(resolved) : resolved;
+        if (session === undefined)
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const command = this.options
+            .profiles()
+            .find((profile) => profile.runner === session.runner)
+            ?.commands.find((candidate) => isPlainRecord(candidate) && candidate.id === input.commandId);
+        if (command?.available !== true)
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const invocation = parseCommandInvocation({ descriptor: command }, input.input);
+        const secretEnvironment = parseSecretEnvironment(input.secretEnvironment);
+        const runner = this.options.runners.product(session.runner);
+        if (runner === undefined)
+            throw new Error('RUNNER_COMMAND_UNAVAILABLE');
+        const result = await runner.executeCommand(session, command, invocation.input, {
+            secretEnvironment
+        });
+        return {
+            ...(isPlainRecord(result) ? result : { result }),
+            session: this.options.present(session)
+        };
+    }
+}
+function record(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return value;
+}

package/dist/service/session-context-service.d.ts

@@ -0,0 +1,34 @@
+import type { NodeAgentSession } from '../database.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+export interface SessionContextUsage {
+    readonly model: string | null;
+    readonly usedTokens: number;
+    readonly maxTokens: number;
+    readonly percentage: number;
+}
+export interface SessionContextReadResult {
+    readonly context: SessionContextUsage | null;
+    readonly pending: boolean;
+}
+export interface SessionContextServiceOptions {
+    readonly runners: RunnerRegistry;
+    readonly session: (sessionId: string) => NodeAgentSession | undefined;
+    readonly stopped: () => boolean;
+    readonly publish: (input: {
+        sessionId: string;
+        workspaceId: string;
+        context: SessionContextUsage;
+        pending: false;
+    }) => void;
+}
+export declare class SessionContextService {
+    private readonly options;
+    private readonly snapshots;
+    private readonly timers;
+    private readonly versions;
+    constructor(options: SessionContextServiceOptions);
+    read(session: NodeAgentSession): Promise<SessionContextReadResult>;
+    schedule(sessionId: string): void;
+    dispose(): void;
+    private current;
+}

package/dist/service/session-context-service.js

@@ -0,0 +1,87 @@
+const REFRESH_DELAYS_MS = [100, 400, 1_000];
+export class SessionContextService {
+    options;
+    snapshots = new Map();
+    timers = new Map();
+    versions = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async read(session) {
+        if (session.externalSessionId === null)
+            return { context: null, pending: false };
+        const usage = await this.options.runners.product(session.runner)?.readContextUsage(session);
+        if (usage === undefined)
+            return { context: null, pending: false };
+        const context = {
+            model: usage.model ?? session.model,
+            usedTokens: usage.usedTokens,
+            maxTokens: usage.maxTokens,
+            percentage: Math.round((usage.usedTokens / usage.maxTokens) * 1000) / 10
+        };
+        this.snapshots.set(session.id, context);
+        return { context, pending: false };
+    }
+    schedule(sessionId) {
+        const pending = this.timers.get(sessionId);
+        if (pending !== undefined)
+            clearTimeout(pending);
+        this.timers.delete(sessionId);
+        const version = (this.versions.get(sessionId) ?? 0) + 1;
+        this.versions.set(sessionId, version);
+        let published = this.snapshots.get(sessionId);
+        const attempt = (index) => {
+            const timer = setTimeout(() => {
+                if (this.timers.get(sessionId) === timer)
+                    this.timers.delete(sessionId);
+                if (!this.current(sessionId, version))
+                    return;
+                const session = this.options.session(sessionId);
+                if (session === undefined || session.externalSessionId === null)
+                    return;
+                void this.read(session)
+                    .then(({ context }) => {
+                    if (!this.current(sessionId, version))
+                        return;
+                    if (context !== null && (published === undefined || !sameUsage(published, context))) {
+                        published = context;
+                        this.options.publish({
+                            sessionId: session.id,
+                            workspaceId: session.workspaceId,
+                            context,
+                            pending: false
+                        });
+                    }
+                })
+                    .catch(() => undefined)
+                    .finally(() => {
+                    if (!this.current(sessionId, version))
+                        return;
+                    if (index + 1 < REFRESH_DELAYS_MS.length)
+                        attempt(index + 1);
+                    else
+                        this.versions.delete(sessionId);
+                });
+            }, REFRESH_DELAYS_MS[index]);
+            this.timers.set(sessionId, timer);
+            timer.unref();
+        };
+        attempt(0);
+    }
+    dispose() {
+        for (const timer of this.timers.values())
+            clearTimeout(timer);
+        this.timers.clear();
+        this.versions.clear();
+        this.snapshots.clear();
+    }
+    current(sessionId, version) {
+        return !this.options.stopped() && this.versions.get(sessionId) === version;
+    }
+}
+function sameUsage(left, right) {
+    return (left.model === right.model &&
+        left.usedTokens === right.usedTokens &&
+        left.maxTokens === right.maxTokens &&
+        left.percentage === right.percentage);
+}

package/dist/service/session-domain-state.d.ts

@@ -0,0 +1,8 @@
+export declare class SessionDomainState<TSession, TActivity> {
+    readonly directNative: Map<string, TSession>;
+    readonly externalActivity: Map<string, TActivity>;
+    readonly resumedByDirectId: Map<string, string>;
+    readonly resumeFailures: Map<string, string>;
+    readonly messageResumeFailures: Map<string, string>;
+    readonly resumeFailureDetails: Map<string, string>;
+}

package/dist/service/session-domain-state.js

@@ -0,0 +1,8 @@
+export class SessionDomainState {
+    directNative = new Map();
+    externalActivity = new Map();
+    resumedByDirectId = new Map();
+    resumeFailures = new Map();
+    messageResumeFailures = new Map();
+    resumeFailureDetails = new Map();
+}

package/dist/service/session-identity-service.d.ts

@@ -0,0 +1,24 @@
+import type { NodeAgentSession } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+export interface SessionIdentityServiceOptions {
+    readonly runtime: NodeRuntimeState;
+    readonly persist: (session: NodeAgentSession, nativeSessionId: string) => void;
+    readonly migrateCommands: (previousId: string, nextId: string) => void;
+    readonly migrateQueue: (previousId: string, nextId: string) => void;
+    readonly migrateRunnerState: (previousId: string, nextId: string) => void;
+    readonly emitSession: (session: NodeAgentSession) => void;
+    readonly emitRun: (run: unknown) => void;
+    readonly emitQueue: (workspaceId: string, sessionId: string) => void;
+    readonly emitTurn: (turn: unknown) => void;
+}
+export declare class SessionIdentityService {
+    private readonly options;
+    readonly bootstrapIds: Set<string>;
+    private readonly waiters;
+    constructor(options: SessionIdentityServiceOptions);
+    markBootstrap(sessionId: string): void;
+    promote(sessionId: string, nativeSessionId: string): void;
+    wait(bootstrapSessionId: string): Promise<string>;
+    reject(sessionId: string, code: string): void;
+    dispose(): void;
+}

package/dist/service/session-identity-service.js

@@ -0,0 +1,86 @@
+export class SessionIdentityService {
+    options;
+    bootstrapIds = new Set();
+    waiters = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    markBootstrap(sessionId) {
+        this.bootstrapIds.add(sessionId);
+    }
+    promote(sessionId, nativeSessionId) {
+        const current = this.options.runtime.getAgentSession(sessionId);
+        this.options.runtime.promoteSessionIdentity(sessionId, nativeSessionId);
+        if (current !== undefined)
+            this.options.persist(current, nativeSessionId);
+        this.options.migrateCommands(sessionId, nativeSessionId);
+        this.options.migrateQueue(sessionId, nativeSessionId);
+        this.options.migrateRunnerState(sessionId, nativeSessionId);
+        this.bootstrapIds.delete(sessionId);
+        const waiter = this.waiters.get(sessionId);
+        if (waiter !== undefined) {
+            clearTimeout(waiter.timer);
+            this.waiters.delete(sessionId);
+            waiter.resolve(nativeSessionId);
+        }
+        const session = this.options.runtime.getAgentSession(nativeSessionId);
+        if (session === undefined)
+            return;
+        this.options.emitSession(session);
+        for (const run of this.options.runtime.listRunsForSession(nativeSessionId))
+            this.options.emitRun(run);
+        this.options.emitQueue(session.workspaceId, nativeSessionId);
+        for (const turn of this.options.runtime.listConversationTurns({ sessionId: nativeSessionId })
+            .turns)
+            if (turn.status !== 'QUEUED')
+                this.options.emitTurn(turn);
+    }
+    wait(bootstrapSessionId) {
+        const existing = this.waiters.get(bootstrapSessionId);
+        if (existing !== undefined)
+            return existing.promise;
+        let resolveIdentity;
+        let rejectIdentity;
+        const promise = new Promise((resolve, reject) => {
+            resolveIdentity = resolve;
+            rejectIdentity = reject;
+        });
+        const timer = setTimeout(() => {
+            this.waiters.delete(bootstrapSessionId);
+            rejectIdentity(new Error('SESSION_NATIVE_ID_TIMEOUT'));
+        }, 30_000);
+        timer.unref();
+        this.waiters.set(bootstrapSessionId, {
+            promise,
+            resolve: resolveIdentity,
+            reject: rejectIdentity,
+            timer
+        });
+        return promise;
+    }
+    reject(sessionId, code) {
+        const waiter = this.waiters.get(sessionId);
+        if (waiter === undefined)
+            return;
+        clearTimeout(waiter.timer);
+        this.waiters.delete(sessionId);
+        waiter.reject(new Error(code));
+        queueMicrotask(() => {
+            try {
+                this.options.runtime.removeAgentSession(sessionId);
+                this.bootstrapIds.delete(sessionId);
+            }
+            catch {
+                // Runner cleanup may still own the bootstrap Session.
+            }
+        });
+    }
+    dispose() {
+        for (const waiter of this.waiters.values()) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('NODE_STOPPED'));
+        }
+        this.waiters.clear();
+        this.bootstrapIds.clear();
+    }
+}

package/dist/service/session-lifecycle-service.d.ts

@@ -0,0 +1,31 @@
+import type { NodeOperationHandler } from '../connector/node-operation-router.js';
+import type { NodeAgentSession, NodeDatabase } from '../database.js';
+import type { NodeRuntimeState } from '../runtime-state.js';
+import type { RunnerRegistry } from '../runner/runner-registry.js';
+import type { NativeSessionProjectionService } from './native-session-projection-service.js';
+import type { SessionIdentityService } from './session-identity-service.js';
+interface SessionLifecycleServiceOptions {
+    readonly database: () => NodeDatabase;
+    readonly runtime: NodeRuntimeState;
+    readonly runners: RunnerRegistry;
+    readonly projection: NativeSessionProjectionService;
+    readonly identity: SessionIdentityService;
+    readonly present: (session: NodeAgentSession) => unknown;
+    readonly emitSession: (session: NodeAgentSession) => void;
+    readonly execute: (operation: string, data: Record<string, unknown>) => Promise<unknown>;
+    readonly interceptedSessionId: (clientMessageId: string) => string | undefined;
+}
+export declare class SessionLifecycleService {
+    private readonly options;
+    private readonly starts;
+    constructor(options: SessionLifecycleServiceOptions);
+    operations(): Readonly<Record<string, NodeOperationHandler>>;
+    clear(): void;
+    private updateMetadata;
+    private movePin;
+    private create;
+    private updateConfiguration;
+    private start;
+    private startFresh;
+}
+export {};