@myagentroam/node 0.11.35 → 0.11.37

package/dist/{service → workspace}/workspace-upload-service.js

@@ -1,17 +1,17 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { link, lstat, mkdir, open, readFile, rename, rm } 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';
+import { parseComposerAttachmentUpload, validComposerAttachmentName } from '../session/attachments.js';
+import { preflightWorkspaceUpload, workspaceUploadTemporaryName } from './files.js';
 const CHUNK_BYTES = 512 * 1024;
 const TTL_MS = 60 * 60_000;
 const MAX_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 export class WorkspaceUploadService {
-    state;
     onCompleted;
     temporaryRoot;
-    constructor(state, onCompleted, temporaryRoot) {
-        this.state = state;
+    uploads = new Map();
+    composerAttachments = new Map();
+    constructor(onCompleted, temporaryRoot) {
         this.onCompleted = onCompleted;
         this.temporaryRoot = temporaryRoot;
     }
@@ -45,8 +45,8 @@ export class WorkspaceUploadService {
         if (attachment !== undefined &&
             (!validComposerAttachmentName(input.name) ||
                 input.size > MAX_ATTACHMENT_BYTES ||
-                this.state.composerAttachments.has(attachment.id) ||
-                [...this.state.uploads.values()].some((upload) => upload.composerAttachment?.id === attachment.id)))
+                this.composerAttachments.has(attachment.id) ||
+                [...this.uploads.values()].some((upload) => upload.composerAttachment?.id === attachment.id)))
             throw new Error('COMPOSER_ATTACHMENT_INVALID');
         const target = attachment === undefined
             ? await preflightWorkspaceUpload(workspace.path, typeof input.directory === 'string' ? input.directory : '.', input.name)
@@ -57,13 +57,13 @@ export class WorkspaceUploadService {
             throw new Error('UPLOAD_TARGET_DIRECTORY');
         if (target.status === 'EXISTS_FILE' && !input.overwrite)
             throw new Error('UPLOAD_TARGET_EXISTS');
-        if ([...this.state.uploads.values()].some((upload) => upload.workspaceId === workspace.id && upload.targetPath === target.absolutePath))
+        if ([...this.uploads.values()].some((upload) => upload.workspaceId === workspace.id && upload.targetPath === target.absolutePath))
             throw new Error('UPLOAD_TARGET_BUSY');
         const id = randomUUID();
         const temporaryPath = resolve(dirname(target.absolutePath), workspaceUploadTemporaryName(id));
         const handle = await open(temporaryPath, 'wx+');
         const timer = setTimeout(() => {
-            const upload = this.state.uploads.get(id);
+            const upload = this.uploads.get(id);
             if (upload !== undefined)
                 void this.remove(upload).catch(() => undefined);
         }, TTL_MS);
@@ -82,7 +82,7 @@ export class WorkspaceUploadService {
             receivedBytes: 0,
             timer
         };
-        this.state.uploads.set(id, upload);
+        this.uploads.set(id, upload);
         return this.status(id);
     }
     async write(input) {
@@ -115,7 +115,7 @@ export class WorkspaceUploadService {
     }
     async createDirect(workspace, input) {
         const normalized = input.path.replaceAll('\\', '/');
-        const existing = [...this.state.uploads.values()].find((upload) => input.composerAttachment === undefined &&
+        const existing = [...this.uploads.values()].find((upload) => input.composerAttachment === undefined &&
             upload.composerAttachment === undefined &&
             upload.workspaceId === workspace.id &&
             upload.path === normalized &&
@@ -203,7 +203,7 @@ export class WorkspaceUploadService {
             await rm(upload.temporaryPath);
         }
         clearTimeout(upload.timer);
-        this.state.uploads.delete(upload.id);
+        this.uploads.delete(upload.id);
         this.onCompleted(upload.workspaceId);
         if (upload.composerAttachment !== undefined) {
             const attachment = {
@@ -218,7 +218,7 @@ export class WorkspaceUploadService {
                 reserved: false,
                 timer: undefined
             };
-            this.state.composerAttachments.set(attachment.id, attachment);
+            this.composerAttachments.set(attachment.id, attachment);
             this.scheduleAttachmentExpiry(attachment);
         }
         return {
@@ -231,10 +231,10 @@ export class WorkspaceUploadService {
     async cancel(uploadId) {
         if (typeof uploadId !== 'string')
             throw new Error('UPLOAD_NOT_FOUND');
-        const active = this.state.uploads.get(uploadId);
+        const active = this.uploads.get(uploadId);
         if (active !== undefined)
             return this.remove(active);
-        const attachment = this.state.composerAttachments.get(uploadId);
+        const attachment = this.composerAttachments.get(uploadId);
         if (attachment === undefined)
             throw new Error('UPLOAD_NOT_FOUND');
         if (attachment.reserved)
@@ -245,7 +245,7 @@ export class WorkspaceUploadService {
         if (new Set(ids).size !== ids.length)
             throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
         const storedAttachments = ids.map((id) => {
-            const stored = this.state.composerAttachments.get(id);
+            const stored = this.composerAttachments.get(id);
             if (stored === undefined || stored.workspaceId !== workspaceId || stored.reserved)
                 throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
             return stored;
@@ -258,7 +258,7 @@ export class WorkspaceUploadService {
         let active = true;
         const assertReserved = () => {
             if (!active ||
-                storedAttachments.some((stored) => this.state.composerAttachments.get(stored.id) !== stored))
+                storedAttachments.some((stored) => this.composerAttachments.get(stored.id) !== stored))
                 throw new Error('COMPOSER_ATTACHMENT_UNAVAILABLE');
         };
         const release = () => {
@@ -266,7 +266,7 @@ export class WorkspaceUploadService {
                 return;
             active = false;
             for (const stored of storedAttachments) {
-                if (this.state.composerAttachments.get(stored.id) !== stored)
+                if (this.composerAttachments.get(stored.id) !== stored)
                     continue;
                 stored.reserved = false;
                 this.scheduleAttachmentExpiry(stored);
@@ -298,7 +298,7 @@ export class WorkspaceUploadService {
                     assertReserved();
                     retain(storedAttachments.map((stored) => dirname(stored.targetPath)));
                     for (const stored of storedAttachments)
-                        this.state.composerAttachments.delete(stored.id);
+                        this.composerAttachments.delete(stored.id);
                     active = false;
                 },
                 release
@@ -310,13 +310,13 @@ export class WorkspaceUploadService {
         }
     }
     async shutdown() {
-        await Promise.allSettled([...this.state.uploads.values()].map((upload) => this.remove(upload)));
-        for (const attachment of this.state.composerAttachments.values())
+        await Promise.allSettled([...this.uploads.values()].map((upload) => this.remove(upload)));
+        for (const attachment of this.composerAttachments.values())
             await this.removeCompleted(attachment);
-        this.state.composerAttachments.clear();
+        this.composerAttachments.clear();
     }
     fileResource(workspaceId, resourcePath) {
-        for (const attachment of this.state.composerAttachments.values())
+        for (const attachment of this.composerAttachments.values())
             if (attachment.workspaceId === workspaceId && attachment.path === resourcePath)
                 return attachment.targetPath;
         return undefined;
@@ -324,13 +324,13 @@ export class WorkspaceUploadService {
     require(id) {
         if (typeof id !== 'string')
             throw new Error('UPLOAD_NOT_FOUND');
-        const upload = this.state.uploads.get(id);
+        const upload = this.uploads.get(id);
         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)
+        if (this.uploads.get(upload.id) !== upload || upload.cancelled || signal?.aborted)
             throw new Error('UPLOAD_CANCELLED');
     }
     async validateCommit(upload) {
@@ -381,12 +381,12 @@ export class WorkspaceUploadService {
             await rm(upload.temporaryPath, { force: true });
         if (upload.composerAttachment !== undefined)
             await rm(dirname(upload.targetPath), { recursive: true, force: true });
-        this.state.uploads.delete(upload.id);
+        this.uploads.delete(upload.id);
     }
     async removeCompleted(attachment) {
-        if (this.state.composerAttachments.get(attachment.id) !== attachment)
+        if (this.composerAttachments.get(attachment.id) !== attachment)
             return;
-        this.state.composerAttachments.delete(attachment.id);
+        this.composerAttachments.delete(attachment.id);
         clearTimeout(attachment.timer);
         await rm(dirname(attachment.targetPath), { recursive: true, force: true }).catch(() => undefined);
     }

package/dist/{service → workspace}/workspace-watch-service.js

@@ -1,13 +1,14 @@
 import { posix } from 'node:path';
 const WATCH_TTL_MS = 45_000;
 export class WorkspaceWatchService {
-    state;
     onSessionWatchRequired;
     onSessionWatchUnused;
     onWorkspaceWatchUnused;
     onWatchRemoved;
-    constructor(state, onSessionWatchRequired, onSessionWatchUnused, onWorkspaceWatchUnused, onWatchRemoved = () => undefined) {
-        this.state = state;
+    watches = new Map();
+    watchRevisions = new Map();
+    watchSnapshotSequence = 0;
+    constructor(onSessionWatchRequired, onSessionWatchUnused, onWorkspaceWatchUnused, onWatchRemoved = () => undefined) {
         this.onSessionWatchRequired = onSessionWatchRequired;
         this.onSessionWatchUnused = onSessionWatchUnused;
         this.onWorkspaceWatchUnused = onWorkspaceWatchUnused;
@@ -58,10 +59,10 @@ export class WorkspaceWatchService {
     }
     create(workspaceId, watchId, sessionHash, workbenchConnectionId, nodeGeneration, topics, prepareFiles = false) {
         const key = `${sessionHash}:${workbenchConnectionId}`;
-        for (const [activeWorkspaceId, watches] of this.state.watches)
+        for (const [activeWorkspaceId, watches] of this.watches)
             if (activeWorkspaceId !== workspaceId && watches.has(key))
                 this.remove(activeWorkspaceId, key);
-        const previous = this.state.watches.get(workspaceId)?.get(key);
+        const previous = this.watches.get(workspaceId)?.get(key);
         const watch = {
             workspaceId,
             watchId,
@@ -74,9 +75,9 @@ export class WorkspaceWatchService {
             timer: undefined
         };
         watch.timer = this.expiryTimer(workspaceId, key);
-        const watches = this.state.watches.get(workspaceId) ?? new Map();
+        const watches = this.watches.get(workspaceId) ?? new Map();
         watches.set(key, watch);
-        this.state.watches.set(workspaceId, watches);
+        this.watches.set(workspaceId, watches);
         if (previous !== undefined) {
             clearTimeout(previous.timer);
             this.onWatchRemoved(previous);
@@ -88,7 +89,7 @@ export class WorkspaceWatchService {
         return watch;
     }
     renew(workspaceId, key, watchId) {
-        const watch = this.state.watches.get(workspaceId)?.get(key);
+        const watch = this.watches.get(workspaceId)?.get(key);
         if (watch === undefined || watch.watchId !== watchId)
             return undefined;
         if (watch.expiresAt <= Date.now()) {
@@ -101,26 +102,26 @@ export class WorkspaceWatchService {
         return watch;
     }
     matches(workspaceId, key, watchId) {
-        const watch = this.state.watches.get(workspaceId)?.get(key);
+        const watch = this.watches.get(workspaceId)?.get(key);
         return watch !== undefined && watch.watchId === watchId && watch.expiresAt > Date.now();
     }
     observes(workspaceId, sessionHash, connectionId) {
-        const watch = this.state.watches.get(workspaceId)?.get(`${sessionHash}:${connectionId}`);
+        const watch = this.watches.get(workspaceId)?.get(`${sessionHash}:${connectionId}`);
         return watch !== undefined && watch.expiresAt > Date.now();
     }
     existing(workspaceId, key) {
-        const watch = this.state.watches.get(workspaceId)?.get(key);
+        const watch = this.watches.get(workspaceId)?.get(key);
         return watch !== undefined && watch.expiresAt > Date.now() ? watch : undefined;
     }
     remove(workspaceId, key) {
-        const watches = this.state.watches.get(workspaceId);
+        const watches = this.watches.get(workspaceId);
         const watch = watches?.get(key);
         if (watch === undefined)
             return;
         clearTimeout(watch.timer);
         watches?.delete(key);
         if (watches?.size === 0)
-            this.state.watches.delete(workspaceId);
+            this.watches.delete(workspaceId);
         this.onWatchRemoved(watch);
         if (watches?.size === 0) {
             this.clearRevisions(workspaceId);
@@ -130,8 +131,8 @@ export class WorkspaceWatchService {
             this.onSessionWatchUnused(workspaceId);
     }
     clear(workspaceId) {
-        const watches = this.state.watches.get(workspaceId);
-        this.state.watches.delete(workspaceId);
+        const watches = this.watches.get(workspaceId);
+        this.watches.delete(workspaceId);
         if (watches !== undefined)
             for (const watch of watches.values()) {
                 clearTimeout(watch.timer);
@@ -142,37 +143,37 @@ export class WorkspaceWatchService {
         this.onWorkspaceWatchUnused(workspaceId);
     }
     clearAll() {
-        const workspaceIds = [...this.state.watches.keys()];
-        const watchesByWorkspace = [...this.state.watches.values()];
-        this.state.watches.clear();
+        const workspaceIds = [...this.watches.keys()];
+        const watchesByWorkspace = [...this.watches.values()];
+        this.watches.clear();
         for (const watches of watchesByWorkspace)
             for (const watch of watches.values()) {
                 clearTimeout(watch.timer);
                 this.onWatchRemoved(watch);
             }
-        this.state.watchRevisions.clear();
+        this.watchRevisions.clear();
         for (const workspaceId of workspaceIds) {
             this.onSessionWatchUnused(workspaceId);
             this.onWorkspaceWatchUnused(workspaceId);
         }
     }
     nextRevision(viewKey) {
-        const revision = (this.state.watchRevisions.get(viewKey) ?? 0) + 1;
-        this.state.watchRevisions.set(viewKey, revision);
+        const revision = (this.watchRevisions.get(viewKey) ?? 0) + 1;
+        this.watchRevisions.set(viewKey, revision);
         return revision;
     }
     nextSnapshotSequence() {
-        this.state.watchSnapshotSequence += 1;
-        return this.state.watchSnapshotSequence;
+        this.watchSnapshotSequence += 1;
+        return this.watchSnapshotSequence;
     }
     topicActive(workspaceId, topic) {
-        return [...(this.state.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
+        return [...(this.watches.get(workspaceId)?.values() ?? [])].some((watch) => topic === 'files' ? watch.topics.files !== undefined : watch.topics[topic]);
     }
     activeWatches(workspaceId) {
-        return [...(this.state.watches.get(workspaceId)?.values() ?? [])].filter((watch) => watch.expiresAt > Date.now());
+        return [...(this.watches.get(workspaceId)?.values() ?? [])].filter((watch) => watch.expiresAt > Date.now());
     }
     activeWorkspaceIds(topic) {
-        return [...this.state.watches.keys()].filter((workspaceId) => this.topicActive(workspaceId, topic));
+        return [...this.watches.keys()].filter((workspaceId) => this.topicActive(workspaceId, topic));
     }
     expiryTimer(workspaceId, key) {
         const timer = setTimeout(() => this.remove(workspaceId, key), WATCH_TTL_MS);
@@ -180,9 +181,9 @@ export class WorkspaceWatchService {
         return timer;
     }
     clearRevisions(workspaceId) {
-        for (const key of [...this.state.watchRevisions.keys()])
+        for (const key of [...this.watchRevisions.keys()])
             if (key.startsWith(`${workspaceId}:`))
-                this.state.watchRevisions.delete(key);
+                this.watchRevisions.delete(key);
     }
 }
 function normalizeViewPath(value) {

package/dist/{service → workspace}/workspace-workbench-service.js

@@ -1,9 +1,10 @@
 import { createHash } from 'node:crypto';
 import { isAbsolute, win32 } from 'node:path';
-import { listGitHistoryRefs, normalizeFilePreviewPath, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, resolveWorkspaceGitRoot, restoreCurrentChange } from '../workspace.js';
+import { listGitHistoryRefs, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, resolveWorkspaceGitRoot, restoreCurrentChange } from './git.js';
+import { normalizeFilePreviewPath } from './files.js';
 import { WorkspaceCodeNavigationService } from './workspace-code-navigation-service.js';
 import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
-import { WorkspaceWatchController } from './workspace-watch-controller.js';
+import { WorkspaceWatchController } from '../service/workspace-watch-controller.js';
 import { WorkspaceWatchSnapshotService } from './workspace-watch-snapshot-service.js';
 export class WorkspaceWorkbenchService {
     options;
@@ -104,7 +105,7 @@ export class WorkspaceWorkbenchService {
     async readPredictionFile(workspaceId, path, worktreePath) {
         const workspace = this.options.requireWorkspace(workspaceId);
         const repository = await this.fileRepository(workspace, worktreePath ? { worktreePath, path } : {});
-        const { readWorkspaceTextFile } = await import('../workspace.js');
+        const { readWorkspaceTextFile } = await import('./files.js');
         return readWorkspaceTextFile(repository, path, 0, 64 * 1024);
     }
     async readFile(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.11.35",
+  "version": "0.11.37",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -38,10 +38,10 @@
     "sharp": "0.35.5",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.11.35",
+    "@myagentroam/agent": "0.11.37",
+    "@myagentroam/protocol": "0.11.37",
     "@myagentroam/code-navigation": "0.11.0",
-    "@myagentroam/marctl": "0.11.2",
-    "@myagentroam/protocol": "0.11.35"
+    "@myagentroam/marctl": "0.11.3"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"