nexus-agentd 0.2.5 → 0.2.6

package/dist/session.js

@@ -1,9 +1,10 @@
 import { randomUUID } from 'node:crypto';
-import { open, realpath } from 'node:fs/promises';
-import { basename, extname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { realpath } from 'node:fs/promises';
+import { extname } from 'node:path';
 import { AcpProcessRuntime } from './acp/runtime.js';
 import { A2AClientRuntime, probeA2AAgent } from './a2a/runtime.js';
 import { SessionEventLog } from './events.js';
+import { ContainedReadError, readContainedFile } from './workspace.js';
 const MAX_SESSION_ARTIFACTS = 64;
 const MAX_ARTIFACT_BASE64_CHARS = 16 * 1024 * 1024;
 const MAX_SESSION_BASE64_CHARS = 32 * 1024 * 1024;
@@ -193,40 +194,21 @@ export class ManagedSession {
         return artifacts;
     }
     async publishSingleFile(requestedPath) {
-        let handle;
         try {
             const workspaceRoot = await realpath(this.workspace);
-            const unresolved = resolve(workspaceRoot, requestedPath);
-            const target = await realpath(unresolved);
-            assertWorkspacePath(workspaceRoot, target);
-            handle = await open(target, 'r');
-            // Resolve again after opening so a swapped symlink cannot silently
-            // redirect a publish request outside the configured workspace.
-            const verifiedTarget = await realpath(unresolved);
-            assertWorkspacePath(workspaceRoot, verifiedTarget);
-            if (verifiedTarget !== target) {
-                throw new SessionRequestError(409, 'Published file changed while it was being opened');
-            }
-            const stats = await handle.stat();
-            if (!stats.isFile()) {
-                throw new SessionRequestError(400, 'Only regular files can be published');
-            }
-            if (stats.size > MAX_PUBLISHED_FILE_BYTES) {
-                throw new SessionRequestError(413, `Published file exceeds the ${MAX_PUBLISHED_FILE_BYTES} byte limit`);
-            }
-            const bytes = await handle.readFile();
-            const filename = basename(verifiedTarget);
-            const workspacePath = relative(workspaceRoot, verifiedTarget).split(sep).join('/');
+            const file = await readContainedFile([workspaceRoot], requestedPath, {
+                maxBytes: MAX_PUBLISHED_FILE_BYTES
+            });
             const artifact = {
                 id: `published:${randomUUID()}`,
-                name: filename,
-                filename,
-                mediaType: mediaTypeForPath(filename),
-                bytesBase64: bytes.toString('base64'),
+                name: file.filename,
+                filename: file.filename,
+                mediaType: mediaTypeForPath(file.filename),
+                bytesBase64: file.bytes.toString('base64'),
                 metadata: {
                     source: 'workspace_publish',
-                    path: workspacePath,
-                    size: bytes.length
+                    path: file.relative,
+                    size: file.size
                 }
             };
             this.addArtifact(artifact);
@@ -236,6 +218,8 @@ export class ManagedSession {
         catch (error) {
             if (error instanceof SessionRequestError)
                 throw error;
+            if (error instanceof ContainedReadError)
+                throw publishFailure(error);
             const code = error?.code;
             if (code === 'ENOENT') {
                 throw new SessionRequestError(404, 'Published file was not found');
@@ -245,9 +229,6 @@ export class ManagedSession {
             }
             throw error;
         }
-        finally {
-            await handle?.close();
-        }
     }
     setPending(request) {
         this.completion = undefined;
@@ -297,7 +278,7 @@ export class ManagedSession {
         return attachmentView(attachment);
     }
     async message(message, attachmentIds = []) {
-        if (!this.runtime)
+        if (!this.runtime || this.runtime.isAvailable?.() === false)
             throw new SessionRequestError(409, 'Agent runtime is unavailable');
         const attachments = this.inputAttachmentsFor(attachmentIds);
         if (this.pendingRequest) {
@@ -326,13 +307,14 @@ export class ManagedSession {
             task: message,
             inputAttachmentCount: attachments.length
         }).id;
+        this.setState('running');
         void this.runtime.prompt(message, attachments).catch((error) => {
             if (this.state !== 'canceled')
                 this.setState('failed', errorMessage(error));
         });
     }
     async resolvePending(response, attachmentIds = []) {
-        if (!this.runtime) {
+        if (!this.runtime || this.runtime.isAvailable?.() === false) {
             throw new SessionRequestError(409, 'Agent runtime is unavailable');
         }
         const pending = this.pendingRequest;
@@ -349,11 +331,31 @@ export class ManagedSession {
         await this.runtime.respondPending(response, attachments);
     }
     async cancel() {
-        await this.runtime?.cancel();
+        const runtime = this.runtime;
+        this.runtime = undefined;
+        this.clearPending();
+        this.setState('canceled');
+        try {
+            await runtime?.cancel();
+        }
+        finally {
+            try {
+                await runtime?.dispose();
+            }
+            finally {
+                this.inputAttachments.clear();
+            }
+        }
     }
     async dispose() {
-        await this.runtime?.dispose();
-        this.inputAttachments.clear();
+        const runtime = this.runtime;
+        this.runtime = undefined;
+        try {
+            await runtime?.dispose();
+        }
+        finally {
+            this.inputAttachments.clear();
+        }
     }
     snapshot() {
         return {
@@ -535,7 +537,7 @@ export class SessionManager {
         const session = new ManagedSession(agentId, config.protocol === 'a2a' ? 'a2a' : 'acp', workspace, ownerKeyId, this.config.maxEventsPerSession, this.config.maxOutputChars, config.name || agentId, this.runStore, this.instanceId);
         const runtime = config.protocol === 'a2a'
             ? new A2AClientRuntime(config, session, this.config.promptTimeoutMs || 30 * 60_000)
-            : new AcpProcessRuntime(driver, session, this.config.maxOutputChars, this.config.promptTimeoutMs || 30 * 60_000);
+            : new AcpProcessRuntime(driver, session, this.config.maxOutputChars, this.config.promptTimeoutMs || 30 * 60_000, this.workspacePolicy.listRoots());
         this.sessions.set(session.id, session);
         session.attach(runtime);
         try {
@@ -544,8 +546,15 @@ export class SessionManager {
         }
         catch (error) {
             session.setState('failed', errorMessage(error));
-            await session.dispose();
-            this.sessions.delete(session.id);
+            try {
+                await session.dispose();
+            }
+            catch (cleanupError) {
+                console.error(JSON.stringify({ level: 'error', event: 'session_start_cleanup_failed', sessionId: session.id, message: errorMessage(cleanupError) }));
+            }
+            finally {
+                this.sessions.delete(session.id);
+            }
             throw new SessionRequestError(502, `Agent failed to start: ${errorMessage(error)}`);
         }
     }
@@ -559,7 +568,7 @@ export class SessionManager {
         return this.sessions.size;
     }
     listRuns(query = {}) {
-        return this.runStore?.list(query) || { runs: [], total: 0 };
+        return this.runStore?.list(query) || { runs: [], total: 0, stats: { active: 0, completed: 0, failed: 0 } };
     }
     getRun(id) {
         const run = this.runStore?.get(id);
@@ -678,17 +687,29 @@ export class SessionManager {
         for (const [id, session] of this.sessions) {
             if (session.updatedAt > cutoff)
                 continue;
-            if (!isTerminal(session.state)) {
-                session.setState('failed', 'Session expired after exceeding its lifetime');
-            }
-            await session.dispose();
-            this.sessions.delete(id);
+            await this.withSessionLock(id, async () => {
+                if (this.sessions.get(id) !== session || session.updatedAt > cutoff)
+                    return;
+                if (!isTerminal(session.state))
+                    session.setState('failed', 'Session expired after exceeding its lifetime');
+                try {
+                    await session.dispose();
+                }
+                catch (error) {
+                    console.error(JSON.stringify({ level: 'error', event: 'session_cleanup_failed', sessionId: id, message: errorMessage(error) }));
+                }
+                finally {
+                    this.sessions.delete(id);
+                }
+            });
         }
     }
     restartCleanup() {
         if (this.cleanupTimer)
             clearInterval(this.cleanupTimer);
-        this.cleanupTimer = setInterval(() => void this.cleanup(), this.config.cleanupIntervalMs || 60_000);
+        this.cleanupTimer = setInterval(() => void this.cleanup().catch((error) => {
+            console.error(JSON.stringify({ level: 'error', event: 'session_cleanup_failed', message: errorMessage(error) }));
+        }), this.config.cleanupIntervalMs || 60_000);
         this.cleanupTimer.unref?.();
     }
     defaultWorkspace(agentId) {
@@ -746,10 +767,16 @@ function runArtifact(artifact) {
         metadata: artifact.metadata ? structuredClone(artifact.metadata) : undefined
     };
 }
-function assertWorkspacePath(workspaceRoot, target) {
-    const child = relative(workspaceRoot, target);
-    if (child === '..' || child.startsWith(`..${sep}`) || isAbsolute(child)) {
-        throw new SessionRequestError(403, 'Published files must stay inside the session workspace');
+function publishFailure(error) {
+    switch (error.failure) {
+        case 'swapped':
+            return new SessionRequestError(409, 'Published file changed while it was being opened');
+        case 'not-a-file':
+            return new SessionRequestError(400, 'Only regular files can be published');
+        case 'too-large':
+            return new SessionRequestError(413, `Published file exceeds the ${MAX_PUBLISHED_FILE_BYTES} byte limit`);
+        case 'outside':
+            return new SessionRequestError(403, 'Published files must stay inside the session workspace');
     }
 }
 function mediaTypeForPath(path) {