@myagentroam/node 0.10.34 → 0.10.36

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

@@ -11,7 +11,7 @@ export class SessionQueryService {
             'session.cli.context': (data) => this.cliContext(record(data)),
             'session.goal.get': async (data) => {
                 const input = record(data);
-                const session = await this.requireSession(input.sessionId, input.workspaceId);
+                const session = await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true);
                 return { goal: this.options.goal?.(session.id) ?? null };
             },
             'session.runs': (data) => this.runs(record(data)),
@@ -24,7 +24,7 @@ export class SessionQueryService {
     }
     async get(input) {
         return {
-            session: this.options.present(await this.requireSession(input.sessionId, input.workspaceId))
+            session: this.options.present(await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true))
         };
     }
     async cliContext(input) {
@@ -35,7 +35,7 @@ export class SessionQueryService {
             throw new Error('WORKSPACE_NOT_FOUND');
         const session = input.sessionId === undefined
             ? undefined
-            : await this.requireSession(input.sessionId, workspace.id);
+            : await this.requireSession(input.sessionId, workspace.id, input.registeredOnly === true);
         return {
             workspace: { id: workspace.id, path: workspace.path },
             session: session === undefined ? null : this.options.present(session),
@@ -43,12 +43,12 @@ export class SessionQueryService {
         };
     }
     async runs(input) {
-        const session = await this.requireSession(input.sessionId, input.workspaceId);
+        const session = await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true);
         return { runs: this.options.runtime.listRunsForSession(session.id, { includeTerminal: true }) };
     }
     async turns(input) {
         const page = pageInput(input);
-        const session = await this.requireSession(input.sessionId, input.workspaceId);
+        const session = await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true);
         if (input.unit === 'SEGMENT')
             return this.options.segments(session, page);
         if (input.unit !== undefined && input.unit !== 'TURN')
@@ -66,7 +66,7 @@ export class SessionQueryService {
         return this.options.runtime.listConversationItems({ sessionId: session.id, ...page });
     }
     async readToolResource(input) {
-        const session = await this.requireSession(input.sessionId, input.workspaceId);
+        const session = await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true);
         if (typeof input.workspaceId !== 'string' || input.workspaceId !== session.workspaceId)
             throw new Error('SESSION_NOT_FOUND');
         const resource = toolResultResourceInputSchema.parse({
@@ -80,7 +80,7 @@ export class SessionQueryService {
         return toolResultResourcePageSchema.parse(await runner.readToolResultResource(session, resource));
     }
     async readContext(input) {
-        return this.options.context.read(await this.requireSession(input.sessionId, input.workspaceId));
+        return this.options.context.read(await this.requireSession(input.sessionId, input.workspaceId, input.registeredOnly === true));
     }
     async discover(input) {
         const runner = this.options.runners.product(input.runner);
@@ -96,10 +96,15 @@ export class SessionQueryService {
         const sessions = await this.options.discover(runner.name, workspaceId);
         return { sessions: sessions.map((session) => this.options.present(session)) };
     }
-    async requireSession(sessionId, workspaceId) {
+    async requireSession(sessionId, workspaceId, registeredOnly = false) {
         if (typeof sessionId !== 'string')
             throw new Error('SESSION_INVALID');
-        const session = this.options.runtime.getAgentSession(sessionId) ?? (await this.options.resolve(sessionId));
+        const session = this.options.runtime.getAgentSession(sessionId) ??
+            (await this.options.resolve(sessionId, registeredOnly));
+        if (session === undefined && registeredOnly && typeof workspaceId === 'string')
+            throw Object.assign(new Error('SESSION_NOT_FOUND'), {
+                publicDetails: this.options.similar(sessionId, workspaceId)
+            });
         if (session === undefined || (workspaceId !== undefined && session.workspaceId !== workspaceId))
             throw new Error('SESSION_NOT_FOUND');
         return session;

package/dist/service/workspace-queue-workbench-service.js

@@ -63,10 +63,15 @@ export class WorkspaceQueueWorkbenchService {
             })
         };
     }
-    get(input) {
-        const session = this.requireSession(input);
+    async get(input) {
+        if (typeof input.workspaceId !== 'string' || typeof input.sessionId !== 'string')
+            throw new Error('WORKSPACE_NOT_FOUND');
+        const session = this.options.runtime.getAgentSession(input.sessionId) ??
+            (await this.options.resolve(input.sessionId, input.registeredOnly === true));
+        if (session?.workspaceId !== input.workspaceId)
+            throw new Error('SESSION_NOT_FOUND');
         return {
-            queue: this.present(session.workspaceId, session.id)
+            queue: this.snapshot(session.id)
         };
     }
     pauseOrResume(mode, input) {

package/dist/service/workspace-upload-service.js

@@ -1,5 +1,5 @@
-import { randomUUID } from 'node:crypto';
-import { lstat, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { createHash, randomUUID } from 'node:crypto';
+import { link, lstat, mkdir, open, readFile, rename, rm, stat } from 'node:fs/promises';
 import { dirname, join, posix, resolve } from 'node:path';
 import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../util/node-operation-parsers.js';
 import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from '../workspace.js';
@@ -38,6 +38,8 @@ export class WorkspaceUploadService {
             !Number.isSafeInteger(input.size) ||
             input.size < 0 ||
             typeof input.overwrite !== 'boolean' ||
+            (input.sha256 !== undefined &&
+                (typeof input.sha256 !== 'string' || !/^[a-f0-9]{64}$/u.test(input.sha256))) ||
             (attachment !== undefined && input.directory !== undefined))
             throw new Error('UPLOAD_INVALID');
         if (attachment !== undefined &&
@@ -59,20 +61,26 @@ export class WorkspaceUploadService {
             throw new Error('UPLOAD_TARGET_BUSY');
         const id = randomUUID();
         const temporaryPath = resolve(dirname(target.absolutePath), workspaceUploadTemporaryName(id));
-        const handle = await open(temporaryPath, 'wx');
+        const parentIdentity = await stat(dirname(target.absolutePath));
+        const handle = await open(temporaryPath, 'wx+');
+        const stagingIdentity = await handle.stat();
         const timer = setTimeout(() => {
             const upload = this.state.uploads.get(id);
             if (upload !== undefined)
-                void this.remove(upload);
+                void this.remove(upload).catch(() => undefined);
         }, TTL_MS);
         const upload = {
             id,
             workspaceId: workspace.id,
+            workspacePath: workspace.path,
+            parentIdentity,
+            stagingIdentity,
             path: target.path,
             targetPath: target.absolutePath,
             temporaryPath,
             size: input.size,
             overwrite: input.overwrite,
+            ...(typeof input.sha256 === 'string' ? { directSha256: input.sha256 } : {}),
             ...(attachment === undefined ? {} : { composerAttachment: attachment }),
             handle,
             receivedBytes: 0,
@@ -88,6 +96,8 @@ export class WorkspaceUploadService {
             typeof input.dataBase64 !== 'string')
             throw new Error('UPLOAD_CHUNK_INVALID');
         const upload = this.require(input.uploadId);
+        if (upload.writing)
+            throw new Error('UPLOAD_OFFSET_INVALID');
         if (input.offset !== upload.receivedBytes)
             throw new Error('UPLOAD_OFFSET_INVALID');
         const bytes = Buffer.from(input.dataBase64, 'base64');
@@ -95,18 +105,42 @@ export class WorkspaceUploadService {
             throw new Error('UPLOAD_CHUNK_INVALID');
         if (upload.receivedBytes + bytes.length > upload.size)
             throw new Error('UPLOAD_SIZE_INVALID');
-        const result = await upload.handle.write(bytes, 0, bytes.length, upload.receivedBytes);
-        if (result.bytesWritten !== bytes.length)
-            throw new Error('UPLOAD_WRITE_FAILED');
-        upload.receivedBytes += bytes.length;
-        return this.status(upload.id);
+        upload.writing = true;
+        try {
+            const result = await upload.handle.write(bytes, 0, bytes.length, upload.receivedBytes);
+            if (result.bytesWritten !== bytes.length)
+                throw new Error('UPLOAD_WRITE_FAILED');
+            upload.receivedBytes += bytes.length;
+            return this.status(upload.id);
+        }
+        finally {
+            upload.writing = false;
+        }
     }
     async createDirect(workspace, input) {
         const normalized = input.path.replaceAll('\\', '/');
+        const existing = [...this.state.uploads.values()].find((upload) => input.composerAttachment === undefined &&
+            upload.composerAttachment === undefined &&
+            upload.workspaceId === workspace.id &&
+            upload.path === normalized &&
+            upload.size === input.size &&
+            upload.overwrite === input.overwrite &&
+            upload.directSha256 === input.sha256);
+        if (existing !== undefined) {
+            const target = await preflightWorkspaceUpload(workspace.path, posix.dirname(normalized), posix.basename(normalized));
+            if (target.absolutePath !== existing.targetPath ||
+                target.path !== existing.path ||
+                target.status === 'INVALID_NAME' ||
+                target.status === 'EXISTS_DIRECTORY' ||
+                (target.status === 'EXISTS_FILE' && !existing.overwrite))
+                throw new Error('UPLOAD_TARGET_INVALID');
+            return this.status(existing.id);
+        }
         const status = await this.create(workspace, {
             name: posix.basename(normalized),
             size: input.size,
             overwrite: input.overwrite,
+            sha256: input.sha256,
             ...(input.composerAttachment === undefined
                 ? { directory: posix.dirname(normalized) }
                 : {
@@ -124,11 +158,21 @@ export class WorkspaceUploadService {
         });
         return status.receivedBytes;
     }
-    async completeDirect(uploadId, size) {
+    async completeDirect(uploadId, size, signal) {
         const upload = this.require(uploadId);
-        if (size !== upload.size)
+        if (size !== upload.size || upload.receivedBytes !== upload.size)
             throw new Error('UPLOAD_SIZE_INVALID');
-        await this.complete(uploadId);
+        const hash = createHash('sha256');
+        for await (const bytes of upload.handle.createReadStream({ start: 0, autoClose: false })) {
+            this.assertActive(upload, signal);
+            hash.update(bytes);
+        }
+        this.assertActive(upload, signal);
+        if (hash.digest('hex') !== upload.directSha256) {
+            await this.remove(upload);
+            throw new Error('DIRECT_INTEGRITY_FAILED');
+        }
+        await this.complete(uploadId, signal);
     }
     status(uploadId) {
         const upload = this.require(uploadId);
@@ -139,27 +183,28 @@ export class WorkspaceUploadService {
             size: upload.size
         };
     }
-    async complete(uploadId) {
+    async complete(uploadId, signal) {
         const upload = this.require(uploadId);
         if (upload.receivedBytes !== upload.size)
             throw new Error('UPLOAD_INCOMPLETE');
         await upload.handle.sync();
+        this.assertActive(upload, signal);
         await upload.handle.close();
-        const existing = await lstat(upload.targetPath).catch((error) => error.code === 'ENOENT' ? undefined : Promise.reject(error));
-        if (existing?.isSymbolicLink())
-            throw new Error('FILE_PATH_ESCAPE');
-        if (existing !== undefined && (!existing.isFile() || !upload.overwrite))
-            throw new Error('UPLOAD_TARGET_EXISTS');
-        try {
+        await this.validateCommit(upload);
+        this.assertActive(upload, signal);
+        if (upload.overwrite) {
             await rename(upload.temporaryPath, upload.targetPath);
         }
-        catch (error) {
-            if (error.code !== 'EEXIST')
+        else {
+            try {
+                await link(upload.temporaryPath, upload.targetPath);
+            }
+            catch (error) {
+                if (error.code === 'EEXIST')
+                    throw new Error('UPLOAD_TARGET_EXISTS');
                 throw error;
-            if (!upload.overwrite)
-                throw new Error('UPLOAD_TARGET_EXISTS');
-            await rm(upload.targetPath, { force: false });
-            await rename(upload.temporaryPath, upload.targetPath);
+            }
+            await rm(upload.temporaryPath);
         }
         clearTimeout(upload.timer);
         this.state.uploads.delete(upload.id);
@@ -284,17 +329,68 @@ export class WorkspaceUploadService {
         if (typeof id !== 'string')
             throw new Error('UPLOAD_NOT_FOUND');
         const upload = this.state.uploads.get(id);
-        if (upload === undefined)
+        if (upload === undefined || upload.cancelled)
             throw new Error('UPLOAD_NOT_FOUND');
         return upload;
     }
+    assertActive(upload, signal) {
+        if (this.state.uploads.get(upload.id) !== upload || upload.cancelled || signal?.aborted)
+            throw new Error('UPLOAD_CANCELLED');
+    }
+    async validateCommit(upload) {
+        if (upload.composerAttachment === undefined) {
+            const target = await preflightWorkspaceUpload(upload.workspacePath, posix.dirname(upload.path), posix.basename(upload.path));
+            if (target.absolutePath !== upload.targetPath || target.path !== upload.path)
+                throw new Error('UPLOAD_TARGET_INVALID');
+            if (target.status === 'EXISTS_DIRECTORY')
+                throw new Error('UPLOAD_TARGET_DIRECTORY');
+            if (target.status === 'INVALID_NAME')
+                throw new Error('UPLOAD_NAME_INVALID');
+            if (target.status === 'EXISTS_FILE' && !upload.overwrite)
+                throw new Error('UPLOAD_TARGET_EXISTS');
+        }
+        else {
+            const target = await lstat(upload.targetPath).catch((error) => {
+                if (error.code === 'ENOENT')
+                    return undefined;
+                throw error;
+            });
+            if (target?.isSymbolicLink())
+                throw new Error('FILE_PATH_ESCAPE');
+            if (target !== undefined && (!target.isFile() || !upload.overwrite))
+                throw new Error('UPLOAD_TARGET_EXISTS');
+        }
+        const parent = await lstat(dirname(upload.targetPath));
+        if (!parent.isDirectory() ||
+            parent.isSymbolicLink() ||
+            !sameIdentity(parent, upload.parentIdentity))
+            throw new Error('UPLOAD_TARGET_INVALID');
+        const staging = await lstat(upload.temporaryPath);
+        if (!staging.isFile() ||
+            staging.isSymbolicLink() ||
+            !sameIdentity(staging, upload.stagingIdentity) ||
+            staging.size !== upload.size)
+            throw new Error('UPLOAD_STAGING_INVALID');
+    }
     async remove(upload) {
-        this.state.uploads.delete(upload.id);
+        upload.cancelled = true;
         clearTimeout(upload.timer);
         await upload.handle.close().catch(() => undefined);
-        await rm(upload.temporaryPath, { force: true }).catch(() => undefined);
+        const parent = await lstat(dirname(upload.temporaryPath));
+        const staging = await lstat(upload.temporaryPath).catch((error) => {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        });
+        if (!sameIdentity(parent, upload.parentIdentity) ||
+            parent.isSymbolicLink() ||
+            (staging !== undefined && !sameIdentity(staging, upload.stagingIdentity)))
+            throw new Error('UPLOAD_CLEANUP_FAILED');
+        if (staging !== undefined)
+            await rm(upload.temporaryPath, { force: true });
         if (upload.composerAttachment !== undefined)
-            await rm(dirname(upload.targetPath), { recursive: true, force: true }).catch(() => undefined);
+            await rm(dirname(upload.targetPath), { recursive: true, force: true });
+        this.state.uploads.delete(upload.id);
     }
     async removeCompleted(attachment) {
         if (this.state.composerAttachments.get(attachment.id) !== attachment)
@@ -331,6 +427,9 @@ export class WorkspaceUploadService {
         };
     }
 }
+function sameIdentity(actual, expected) {
+    return actual.dev === expected.dev && actual.ino === expected.ino;
+}
 async function safeDirectory(path) {
     const value = await lstat(path);
     if (!value.isDirectory() || value.isSymbolicLink())

package/dist/supervisor.js

@@ -14,8 +14,10 @@ export async function superviseNode(configPath, bootstrapEntrypoint) {
     let entrypoint = await readActiveEntrypoint(activePath, bootstrapEntrypoint);
     for (;;) {
         const childResult = await runProcess(process.execPath, [entrypoint, 'run', '--config', configPath], true, { ...process.env, MAR_NODE_SUPERVISED: '1' });
-        if (childResult.signalled)
+        if (childResult.signalled) {
+            process.exitCode = childResult.code ?? 1;
             return;
+        }
         const code = childResult.code;
         if (code !== UPGRADE_EXIT_CODE) {
             if (code === 0)
@@ -102,6 +104,8 @@ async function runProcess(command, args, inherit, env = process.env) {
         let settled = false;
         let signalled = false;
         const forward = (signal) => {
+            if (signalled)
+                return;
             signalled = true;
             child.kill(signal);
         };
@@ -115,8 +119,8 @@ async function runProcess(command, args, inherit, env = process.env) {
             process.off('SIGTERM', onSigterm);
             resolveProcess({ code, signalled });
         };
-        process.once('SIGINT', onSigint);
-        process.once('SIGTERM', onSigterm);
+        process.on('SIGINT', onSigint);
+        process.on('SIGTERM', onSigterm);
         child.once('error', () => finish(null));
         child.once('close', finish);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.34",
+  "version": "0.10.36",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,10 +37,10 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.10.34",
+    "@myagentroam/agent": "0.10.36",
     "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/marctl": "0.10.5",
-    "@myagentroam/protocol": "0.10.34"
+    "@myagentroam/marctl": "0.10.6",
+    "@myagentroam/protocol": "0.10.36"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"