@myagentroam/node 0.9.0 → 0.9.3

package/dist/service/conversation-segment-service.js

@@ -0,0 +1,156 @@
+const TURN_PAGE_SIZE = 30;
+export function conversationSegments(turn) {
+    const groups = [];
+    let current = [];
+    for (const item of turn.items) {
+        if (current.at(-1)?.kind === 'assistant_message' && item.kind !== 'assistant_message') {
+            groups.push(current);
+            current = [];
+        }
+        current.push(item);
+    }
+    if (current.length > 0 || groups.length === 0)
+        groups.push(current);
+    return groups.map((items, index) => {
+        const id = `${turn.id}:segment:${index}`;
+        const latest = index === groups.length - 1;
+        const projectedItems = items.map((item) => ({
+            ...item,
+            segmentId: id,
+            segmentIndex: index
+        }));
+        return {
+            id,
+            sessionId: turn.sessionId,
+            turnId: turn.id,
+            runId: turn.runId,
+            index,
+            status: (latest ? turn.status : 'SUCCEEDED'),
+            ...(latest && turn.rewind !== undefined ? { rewind: turn.rewind } : {}),
+            items: projectedItems,
+            startedAt: projectedItems[0]?.startedAt ?? turn.startedAt,
+            completedAt: projectedItems.at(-1)?.completedAt ?? null
+        };
+    });
+}
+export function conversationSegmentIdentityForItem(turn, itemId, itemKind) {
+    let index = 0;
+    const runtimeItemId = turn.runId === null ? itemId : `${turn.runId}:${itemId}`;
+    for (const [itemIndex, item] of turn.items.entries()) {
+        const previous = turn.items[itemIndex - 1];
+        if (previous?.kind === 'assistant_message' && item.kind !== 'assistant_message')
+            index += 1;
+        if (item.id === itemId || item.id === runtimeItemId)
+            return { id: `${turn.id}:segment:${index}`, index };
+    }
+    if (turn.items.at(-1)?.kind === 'assistant_message' && itemKind !== 'assistant_message')
+        index += 1;
+    return { id: `${turn.id}:segment:${index}`, index };
+}
+export class ConversationSegmentService {
+    readTurns;
+    constructor(readTurns) {
+        this.readTurns = readTurns;
+    }
+    projectInitial(session, page, limit) {
+        const all = page.turns.flatMap(conversationSegments);
+        const segments = all.slice(-limit);
+        return {
+            snapshotSequence: page.snapshotSequence,
+            source: page.source,
+            readAt: page.readAt,
+            latestVisibleAt: page.latestVisibleAt,
+            unit: 'SEGMENT',
+            segments,
+            nextCursor: segments.length === 0 || (segments.length === all.length && page.nextCursor === null)
+                ? null
+                : encodeCursor({
+                    version: 1,
+                    sessionId: session.id,
+                    beforeSegmentId: segments[0].id
+                })
+        };
+    }
+    async read(session, input) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const boundary = input.cursor === undefined ? undefined : decodeCursor(input.cursor, session.id);
+        const collected = [];
+        const visited = new Set();
+        let turnCursor;
+        let locatingBoundary = boundary !== undefined;
+        let hasOlder = false;
+        let metadata;
+        while (collected.length < limit) {
+            const page = await this.readTurns(session, {
+                ...(turnCursor === undefined ? {} : { cursor: turnCursor }),
+                limit: TURN_PAGE_SIZE
+            });
+            metadata ??= {
+                snapshotSequence: page.snapshotSequence,
+                source: page.source,
+                readAt: page.readAt,
+                latestVisibleAt: page.latestVisibleAt
+            };
+            const pageSegments = page.turns.flatMap(conversationSegments);
+            let eligible = pageSegments;
+            if (locatingBoundary) {
+                const boundaryIndex = pageSegments.findIndex((segment) => segment.id === boundary?.beforeSegmentId);
+                if (boundaryIndex >= 0) {
+                    eligible = pageSegments.slice(0, boundaryIndex);
+                    locatingBoundary = false;
+                }
+                else
+                    eligible = [];
+            }
+            if (!locatingBoundary && eligible.length > 0) {
+                const remaining = Math.max(0, limit - collected.length);
+                const take = eligible.slice(-remaining);
+                hasOlder = eligible.length > take.length || page.nextCursor !== null;
+                collected.unshift(...take);
+            }
+            if (collected.length >= limit || page.nextCursor === null)
+                break;
+            if (visited.has(page.nextCursor))
+                throw new Error('EVENT_CURSOR_INVALID');
+            visited.add(page.nextCursor);
+            turnCursor = page.nextCursor;
+        }
+        if (locatingBoundary)
+            throw new Error('EVENT_CURSOR_INVALID');
+        const nextCursor = collected.length === 0 || !hasOlder
+            ? null
+            : encodeCursor({
+                version: 1,
+                sessionId: session.id,
+                beforeSegmentId: collected[0].id
+            });
+        return {
+            ...(metadata ?? {
+                snapshotSequence: 0,
+                source: 'runtime',
+                readAt: Date.now(),
+                latestVisibleAt: 0
+            }),
+            unit: 'SEGMENT',
+            segments: collected,
+            nextCursor
+        };
+    }
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString('base64url');
+}
+function decodeCursor(value, sessionId) {
+    try {
+        const decoded = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (decoded.version !== 1 ||
+            decoded.sessionId !== sessionId ||
+            typeof decoded.beforeSegmentId !== 'string' ||
+            decoded.beforeSegmentId.length === 0)
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}

package/dist/service/external-session-resume-service.js

@@ -1,3 +1,4 @@
+const RESUME_FAILURE_TTL_MS = 30 * 60_000;
 export class ExternalSessionResumeService {
     options;
     constructor(options) {
@@ -84,15 +85,23 @@ export class ExternalSessionResumeService {
             : 'REJECTED';
     }
     clearFailure(sessionId) {
+        const timer = this.options.state.failureTimers.get(sessionId);
+        if (timer !== undefined)
+            clearTimeout(timer);
+        this.options.state.failureTimers.delete(sessionId);
         this.options.state.resumeFailures.delete(sessionId);
         this.options.state.resumeFailureDetails.delete(sessionId);
         this.options.state.messageResumeFailures.delete(sessionId);
     }
     setFailure(sessionId, code, detail) {
+        this.clearFailure(sessionId);
         this.options.state.resumeFailures.set(sessionId, code);
         if (detail === undefined)
             this.options.state.resumeFailureDetails.delete(sessionId);
         else
             this.options.state.resumeFailureDetails.set(sessionId, detail);
+        const timer = setTimeout(() => this.clearFailure(sessionId), RESUME_FAILURE_TTL_MS);
+        timer.unref();
+        this.options.state.failureTimers.set(sessionId, timer);
     }
 }

package/dist/service/fake-managed-run-service.d.ts

@@ -17,7 +17,6 @@ interface FakeManagedRunServiceOptions {
         readonly payload: unknown;
         readonly expiresAt: number;
     }) => void;
-    readonly captureSnapshot: (runId: string, cwd: string) => Promise<void>;
     readonly disconnect: () => void;
 }
 /** Test-only managed Run adapter; production Runner paths never depend on it. */

package/dist/service/fake-managed-run-service.js

@@ -32,8 +32,6 @@ export class FakeManagedRunService {
                 this.options.emitRun(runId, eventType, eventPayload, status);
                 if (status !== undefined && isTerminalRunStatus(status)) {
                     this.options.state.active.delete(runId);
-                    if (cwd !== undefined)
-                        void this.options.captureSnapshot(runId, cwd);
                 }
             },
             approval: (approvalId, approvalPayload, expiresAt) => {

package/dist/service/mcp-installation-verifier.js

@@ -4,7 +4,7 @@ import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/
 const INSTALL_TIMEOUT_MS = 90_000;
 export class McpInstallationVerifier {
     async verify(input) {
-        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.0' });
+        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.1' });
         try {
             await withTimeout((async () => {
                 if (input.entry.runtime.transport === 'STDIO') {

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

@@ -238,7 +238,12 @@ export class NativeSessionProjectionService {
                 this.options.state.externalActivity.delete(directId);
                 this.options.state.resumedByDirectId.delete(directId);
                 this.options.state.resumeFailures.delete(directId);
+                this.options.state.messageResumeFailures.delete(directId);
                 this.options.state.resumeFailureDetails.delete(directId);
+                const timer = this.options.state.failureTimers.get(directId);
+                if (timer !== undefined)
+                    clearTimeout(timer);
+                this.options.state.failureTimers.delete(directId);
             }
         }
         for (const [directId, resumedId] of this.options.state.resumedByDirectId)

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

@@ -8,6 +8,7 @@ export interface NativeSessionWatchOptions<TPage extends {
     readonly refreshActivity: (session: NodeAgentSession) => Promise<void>;
     readonly present: (session: NodeAgentSession) => unknown;
     readonly readPage: (session: NodeAgentSession, limit: number) => Promise<TPage>;
+    readonly projectInitialPage?: (session: NodeAgentSession, page: TPage, unit: 'SEGMENT', limit: number) => unknown;
     readonly emitSession: (session: unknown) => void;
     readonly emitTurn: (turn: unknown) => void;
 }

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

@@ -15,7 +15,12 @@ export class NativeSessionWatchService {
         };
     }
     async executeWatch(input) {
-        if (typeof input.sessionId !== 'string' || (input.mode !== 'initial' && input.mode !== 'renew'))
+        const projectInitialPage = this.options.projectInitialPage;
+        if (input.unit === 'SEGMENT' && projectInitialPage === undefined)
+            throw new Error('SESSION_INVALID');
+        if (typeof input.sessionId !== 'string' ||
+            (input.mode !== 'initial' && input.mode !== 'renew') ||
+            (input.unit !== undefined && input.unit !== 'SEGMENT'))
             throw new Error('SESSION_INVALID');
         const session = await this.options.resolve(input.sessionId);
         if (session === undefined || session.externalSessionId === null)
@@ -27,9 +32,21 @@ export class NativeSessionWatchService {
             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)
+        const turnSnapshot = watch === undefined ? undefined : await this.refresh(session.id, INITIAL_TURN_LIMIT);
+        if (watch !== undefined && turnSnapshot === undefined) {
+            this.stop(session.id);
             throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+        }
+        let snapshot = turnSnapshot;
+        if (turnSnapshot !== undefined && input.unit === 'SEGMENT') {
+            try {
+                snapshot = projectInitialPage(session, turnSnapshot, 'SEGMENT', 10);
+            }
+            catch (error) {
+                this.stop(session.id);
+                throw error;
+            }
+        }
         return {
             session: this.options.present(session),
             watch: watch === undefined ? null : { expiresAt: watch.expiresAt },
@@ -131,7 +148,7 @@ export class NativeSessionWatchService {
             }
             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 turns = page.turns.length <= 10 ? page.turns : page.turns.slice(-10);
             const signature = JSON.stringify(turns);
             if (signature === watch.signature)
                 return page;

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

@@ -3,7 +3,6 @@ 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;
@@ -15,7 +14,6 @@ interface NodeConnectionLifecycleServiceOptions {
     readonly setCapabilities: (capabilities: NodeCapabilities) => void;
     readonly control: NodeControlChannel;
     readonly terminal: NodeTerminalChannel;
-    readonly events: WorkbenchEventService;
     readonly metrics: NodeMetrics;
     readonly heartbeatMs: number;
     readonly refreshMs: number;

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

@@ -48,7 +48,6 @@ export class NodeConnectionLifecycleService {
         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', {});

package/dist/service/node-control-channel.js

@@ -5,7 +5,7 @@ import { nodeConnectEndpoint } from '../runner/codex/conversation-parser.js';
 export class NodeControlChannel {
     options;
     socket;
-    outbound = new ControlOutboundScheduler(() => this.socket);
+    outbound = new ControlOutboundScheduler(() => this.socket, () => this.socket?.close(1013, 'NODE_CONTROL_BACKPRESSURE_TIMEOUT'));
     reconnectTimer;
     attempts = 0;
     constructor(options) {

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

@@ -8,7 +8,6 @@ interface NodeControlMessageServiceOptions {
     readonly close: (code: number, reason: string) => void;
     readonly inspectWorkspace: (envelope: NodeEnvelope) => Promise<void>;
     readonly handleNodeRequest: (envelope: NodeEnvelope) => Promise<void>;
-    readonly acknowledgeWorkbenchEvent: (replyTo: string | undefined) => void;
     readonly reconcileRuns: (envelope: NodeEnvelope) => void;
     readonly runners: RunnerRegistry;
     readonly deliverSessionChannelMessage: (envelope: NodeEnvelope) => void;

package/dist/service/node-control-message-service.js

@@ -33,12 +33,8 @@ export class NodeControlMessageService {
             void this.options.handleNodeRequest(envelope);
             return;
         }
-        if (envelope.type === 'ack') {
-            const payload = envelope.payload;
-            if (payload.type === 'workbench.event')
-                this.options.acknowledgeWorkbenchEvent(envelope.replyTo);
+        if (envelope.type === 'ack')
             return;
-        }
         if (envelope.type === 'runs.reconcile') {
             this.options.reconcileRuns(envelope);
             return;
@@ -49,7 +45,14 @@ export class NodeControlMessageService {
         }
         if (envelope.type === 'run.start') {
             this.options.send('ack', { type: envelope.type }, envelope.id);
-            this.options.runners.startManagedRun(envelope);
+            try {
+                this.options.runners.startManagedRun(envelope);
+            }
+            catch (error) {
+                // A delayed internal start may arrive after the terminal projection was removed.
+                if (!(error instanceof Error) || error.message !== 'RUN_TERMINAL')
+                    throw error;
+            }
             return;
         }
         if (envelope.type === 'session.channel.message') {

package/dist/service/node-request-service.js

@@ -1,5 +1,6 @@
 import { nodeLog } from '../operational.js';
 import { validUserAuthorization } from '../runner/codex/conversation-parser.js';
+import { safeErrorCode } from '../util/safe-error.js';
 /** Validates and executes the closed Admin-facing Node operation envelope. */
 export class NodeRequestService {
     options;
@@ -44,7 +45,7 @@ export class NodeRequestService {
                 durationMs: Math.round(performance.now() - startedAt),
                 error: error instanceof Error ? error.message : 'INTERNAL_ERROR'
             });
-            this.options.send('node.response', { error: error instanceof Error ? error.message : 'INTERNAL_ERROR' }, envelope.id);
+            this.options.send('node.response', { error: safeErrorCode(error, 'INTERNAL_ERROR') }, envelope.id);
         }
     }
 }

package/dist/service/node-workspace-coordinator.d.ts

@@ -1,7 +1,6 @@
 import type { NodeEnvelope } from '@myagentroam/protocol';
 import type { NodeConfig } from '../config.js';
 import type { NodeAgentSession, NodeDatabase, NodeWorkspace } from '../database.js';
-import type { NodeRuntimeState } from '../runtime-state.js';
 import type { TerminalSummary } from '../terminal.js';
 import type { WorkspaceChangeService } from './workspace-change-service.js';
 import type { WorkspaceSessionService } from './workspace-session-service.js';
@@ -9,14 +8,13 @@ import type { WorkspaceWatchService } from './workspace-watch-service.js';
 interface NodeWorkspaceCoordinatorOptions {
     readonly config: () => NodeConfig | undefined;
     readonly database: () => NodeDatabase | undefined;
-    readonly runtime: NodeRuntimeState;
     readonly watches: WorkspaceWatchService;
     readonly sessions: WorkspaceSessionService;
     readonly changes: WorkspaceChangeService;
     readonly emit: (workspaceId: string, topic: 'files' | 'changes', revision: number) => void;
     readonly send: (type: string, payload: unknown, replyTo?: string) => void;
 }
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export declare class NodeWorkspaceCoordinator {
     private readonly options;
     constructor(options: NodeWorkspaceCoordinatorOptions);
@@ -27,6 +25,5 @@ export declare class NodeWorkspaceCoordinator {
     invalidateChanges(workspaceId: string): void;
     persistTerminal(summary: TerminalSummary): void;
     inspect(envelope: NodeEnvelope): Promise<void>;
-    captureRunSnapshot(runId: string, cwd: string): Promise<void>;
 }
 export {};

package/dist/service/node-workspace-coordinator.js

@@ -1,5 +1,5 @@
-import { inspectWorkspace, readGitSummary } from '../workspace.js';
-/** Coordinates Workspace invalidation, inspection, snapshots and persisted Terminal summaries. */
+import { inspectWorkspace } from '../workspace.js';
+/** Coordinates Workspace invalidation, inspection and persisted Terminal summaries. */
 export class NodeWorkspaceCoordinator {
     options;
     constructor(options) {
@@ -67,14 +67,4 @@ export class NodeWorkspaceCoordinator {
             this.options.send('workspace.inspect.result', { error: 'WORKSPACE_INVALID' }, envelope.id);
         }
     }
-    async captureRunSnapshot(runId, cwd) {
-        try {
-            const snapshot = await readGitSummary(cwd);
-            this.options.runtime.saveSnapshot(runId, snapshot);
-            this.options.send('workspace.snapshot', { runId, snapshot });
-        }
-        catch {
-            // Ordinary directories have no Git snapshot and keep the existing Run result.
-        }
-    }
 }

package/dist/service/run-attachment-service.d.ts

@@ -11,14 +11,15 @@ export interface NativeImageSource {
     readonly name: string;
     readonly mime: string;
     readonly path: string;
+    readonly root: string;
 }
 export type RunnerImageAttachment = NodeMessageAttachmentInput & {
     readonly mime: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp';
 };
 export declare class RunAttachmentService {
-    private readonly nativeImageRoot;
+    private readonly nativeImageRoots;
     readonly state: AttachmentDomainState<CachedRunImages, NativeImageSource>;
-    constructor(nativeImageRoot: (session: NodeAgentSession) => string | undefined);
+    constructor(nativeImageRoots: (session: NodeAgentSession) => readonly string[]);
     materializeCodex(runId: string, attachments: readonly RunnerImageAttachment[]): Promise<readonly Extract<CodexComposerInput, {
         readonly type: 'localImage';
     }>[]>;

package/dist/service/run-attachment-service.js

@@ -1,14 +1,15 @@
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve } from 'node:path';
-import { lstat, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, mkdtemp, readFile, realpath, rm, writeFile } from 'node:fs/promises';
 import { AttachmentDomainState } from './attachment-domain-state.js';
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const IMAGE_CACHE_TTL_MS = 60 * 60_000;
+const NATIVE_IMAGE_INDEX_TTL_MS = 60 * 60_000;
 export class RunAttachmentService {
-    nativeImageRoot;
+    nativeImageRoots;
     state = new AttachmentDomainState();
-    constructor(nativeImageRoot) {
-        this.nativeImageRoot = nativeImageRoot;
+    constructor(nativeImageRoots) {
+        this.nativeImageRoots = nativeImageRoots;
     }
     async materializeCodex(runId, attachments) {
         if (attachments.length === 0)
@@ -43,21 +44,28 @@ export class RunAttachmentService {
             throw new Error('MESSAGE_ATTACHMENT_DIRECTORY_INVALID');
         const runDirectory = join(filesDirectory, runId);
         await mkdir(runDirectory, { mode: 0o700 });
+        this.state.runFileDirectories.set(runId, runDirectory);
         try {
             await Promise.all(attachments.map((attachment) => writeFile(join(runDirectory, attachment.name), Buffer.from(attachment.dataBase64, 'base64'), { flag: 'wx', mode: 0o600 })));
             return attachments.map((attachment) => `.mar/temp-files/${runId}/${attachment.name}`);
         }
         catch (error) {
+            this.state.runFileDirectories.delete(runId);
             await rm(runDirectory, { recursive: true, force: true });
             throw error;
         }
     }
     cleanup(runId) {
         const directory = this.state.runDirectories.get(runId);
-        if (directory === undefined)
-            return;
-        this.state.runDirectories.delete(runId);
-        void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        if (directory !== undefined) {
+            this.state.runDirectories.delete(runId);
+            void rm(directory, { recursive: true, force: true }).catch(() => undefined);
+        }
+        const fileDirectory = this.state.runFileDirectories.get(runId);
+        if (fileDirectory !== undefined) {
+            this.state.runFileDirectories.delete(runId);
+            void rm(fileDirectory, { recursive: true, force: true }).catch(() => undefined);
+        }
     }
     cache(runId, images) {
         if (images.length === 0)
@@ -95,8 +103,8 @@ export class RunAttachmentService {
         return cached.images[imageIndex];
     }
     registerNative(session, images) {
-        const root = this.nativeImageRoot(session);
-        if (root === undefined)
+        const roots = this.nativeImageRoots(session).map((root) => resolve(root));
+        if (roots.length === 0)
             return [];
         const runId = `native-history:${session.id}`;
         const sources = this.state.nativeHistoryImages.get(runId) ?? [];
@@ -107,20 +115,33 @@ export class RunAttachmentService {
                 continue;
             }
             const path = resolve(image.localPath);
-            const relation = relative(root, path);
-            if (relation.length === 0 || relation.startsWith('..') || isAbsolute(relation)) {
+            const root = roots.find((candidate) => {
+                const relation = relative(candidate, path);
+                return relation.length > 0 && !relation.startsWith('..') && !isAbsolute(relation);
+            });
+            if (root === undefined) {
                 attachments.push({ name: image.name, mime: image.mime });
                 continue;
             }
             let imageIndex = sources.findIndex((source) => source.path === path);
             if (imageIndex < 0) {
                 imageIndex = sources.length;
-                sources.push({ name: image.name, mime: image.mime, path });
+                sources.push({ name: image.name, mime: image.mime, path, root });
             }
             attachments.push({ name: image.name, mime: image.mime, runId, imageIndex });
         }
-        if (sources.length > 0)
+        if (sources.length > 0) {
             this.state.nativeHistoryImages.set(runId, sources);
+            const previousTimer = this.state.nativeHistoryImageTimers.get(runId);
+            if (previousTimer !== undefined)
+                clearTimeout(previousTimer);
+            const timer = setTimeout(() => {
+                this.state.nativeHistoryImageTimers.delete(runId);
+                this.state.nativeHistoryImages.delete(runId);
+            }, NATIVE_IMAGE_INDEX_TTL_MS);
+            timer.unref();
+            this.state.nativeHistoryImageTimers.set(runId, timer);
+        }
         return attachments;
     }
     async readNative(runId, imageIndex) {
@@ -128,10 +149,17 @@ export class RunAttachmentService {
         if (source === undefined)
             return undefined;
         try {
-            const info = await lstat(source.path);
+            const [actualRoot, actualPath] = await Promise.all([
+                realpath(source.root),
+                realpath(source.path)
+            ]);
+            const relation = relative(actualRoot, actualPath);
+            if (relation.length === 0 || relation.startsWith('..') || isAbsolute(relation))
+                return undefined;
+            const info = await lstat(actualPath);
             if (!info.isFile() || info.size <= 0 || info.size > MAX_ATTACHMENT_BYTES)
                 return undefined;
-            return { ...source, dataBase64: (await readFile(source.path)).toString('base64') };
+            return { ...source, dataBase64: (await readFile(actualPath)).toString('base64') };
         }
         catch {
             return undefined;
@@ -151,10 +179,16 @@ export class RunAttachmentService {
         this.state.runImages.delete(runId);
     }
     dispose() {
-        for (const runId of this.state.runDirectories.keys())
+        for (const runId of new Set([
+            ...this.state.runDirectories.keys(),
+            ...this.state.runFileDirectories.keys()
+        ]))
             this.cleanup(runId);
         for (const runId of this.state.runImages.keys())
             this.clear(runId);
+        for (const timer of this.state.nativeHistoryImageTimers.values())
+            clearTimeout(timer);
+        this.state.nativeHistoryImageTimers.clear();
         this.state.nativeHistoryImages.clear();
     }
 }

package/dist/service/run-event-service.d.ts

@@ -25,7 +25,9 @@ export declare class RunEventService {
     constructor(options: RunEventServiceOptions);
     emit(runId: string, eventType: string, payload: unknown, status?: FakeRunnerStatus): void;
     clear(): void;
+    flushPendingText(runId: string): void;
     private enqueueText;
     private flushText;
     private emitNow;
+    private notificationPayload;
 }