@myagentroam/node 0.9.114 → 0.9.116

package/dist/runner/opencode-runner.js

@@ -4,6 +4,7 @@ import { declaredRunnerProfiles } from '../runner-profiles.js';
 import { AbstractRunner } from './abstract-runner.js';
 import { isWithinWorkspace } from './codex/conversation-parser.js';
 import { createHash } from 'node:crypto';
+import { homedir } from 'node:os';
 import { openCodeConversationPage } from './opencode/conversation-parser.js';
 import { nodeLog } from '../operational.js';
 const PROFILE_ENTRY_TTL_MS = 30 * 60_000;
@@ -12,9 +13,8 @@ export class OpenCodeRunner extends AbstractRunner {
     clientFactory;
     name = 'opencode';
     discoveryScope = 'WORKSPACE_REQUIRED';
-    modelsByWorkspace = new Map();
-    contextLimitsByWorkspace = new Map();
-    profileTimersByWorkspace = new Map();
+    contextLimits = new Map();
+    contextLimitsExpiresAt = 0;
     profileCache = new Map();
     profileRefreshes = new Map();
     execution = new Map();
@@ -34,11 +34,11 @@ export class OpenCodeRunner extends AbstractRunner {
         }).find((profile) => profile.runner === this.name);
         return { ...base, models: [] };
     }
-    async refreshProfile(capabilities, workspace, environment = {}) {
-        if (capabilities.openCode?.available !== true || workspace === undefined) {
+    async refreshProfile(capabilities, _workspace, environment = {}) {
+        if (capabilities.openCode?.available !== true) {
             return this.profile(capabilities);
         }
-        const cacheKey = this.profileCacheKey(workspace.path, environment);
+        const cacheKey = this.environmentFingerprint(environment);
         const now = Date.now();
         for (const [key, entry] of this.profileCache)
             if (entry.expiresAt <= now)
@@ -46,46 +46,42 @@ export class OpenCodeRunner extends AbstractRunner {
         const cached = this.profileCache.get(cacheKey);
         if (cached !== undefined) {
             nodeLog('runner.opencode.profile.cache-hit', {
-                workspaceId: workspace.id,
                 models: cached.models.length,
                 remainingTtlMs: cached.expiresAt - now
             });
-            this.modelsByWorkspace.set(workspace.path, cached.models);
-            this.contextLimitsByWorkspace.set(workspace.path, cached.contextLimits);
-            this.scheduleProfileExpiry(workspace.path);
+            this.contextLimits = cached.contextLimits;
+            this.contextLimitsExpiresAt = cached.expiresAt;
             return { ...this.profile(capabilities), models: cached.models };
         }
         const current = this.profileRefreshes.get(cacheKey);
         if (current !== undefined) {
-            nodeLog('runner.opencode.profile.single-flight-joined', { workspaceId: workspace.id });
+            nodeLog('runner.opencode.profile.single-flight-joined', {});
             return current;
         }
-        const refresh = this.fetchProfile(capabilities, workspace, environment, cacheKey).finally(() => {
+        const refresh = this.fetchProfile(capabilities, environment, cacheKey).finally(() => {
             if (this.profileRefreshes.get(cacheKey) === refresh)
                 this.profileRefreshes.delete(cacheKey);
         });
         this.profileRefreshes.set(cacheKey, refresh);
         return refresh;
     }
-    async fetchProfile(capabilities, workspace, environment, cacheKey) {
+    async fetchProfile(capabilities, environment, cacheKey) {
         const client = this.managedClient(environment);
         const startedAt = performance.now();
         try {
-            const catalog = await client.providers(workspace.path);
+            const catalog = await client.providers(homedir());
             const models = openCodeProfileModels(catalog);
             const contextLimits = openCodeContextLimits(catalog);
-            this.modelsByWorkspace.set(workspace.path, models);
-            this.contextLimitsByWorkspace.set(workspace.path, contextLimits);
+            const expiresAt = Date.now() + PROFILE_ENTRY_TTL_MS;
+            this.contextLimits = contextLimits;
+            this.contextLimitsExpiresAt = expiresAt;
             this.profileCache.set(cacheKey, {
-                expiresAt: Date.now() + PROFILE_ENTRY_TTL_MS,
-                workspacePath: workspace.path,
-                environmentFingerprint: this.environmentFingerprint(environment),
+                expiresAt,
+                environmentFingerprint: cacheKey,
                 models,
                 contextLimits
             });
-            this.scheduleProfileExpiry(workspace.path);
             nodeLog('runner.opencode.profile.providers.completed', {
-                workspaceId: workspace.id,
                 models: models.length,
                 durationMs: Math.round(performance.now() - startedAt)
             });
@@ -93,7 +89,6 @@ export class OpenCodeRunner extends AbstractRunner {
         }
         catch {
             nodeLog('runner.opencode.profile.providers.failed', {
-                workspaceId: workspace.id,
                 durationMs: Math.round(performance.now() - startedAt)
             });
         }
@@ -102,11 +97,6 @@ export class OpenCodeRunner extends AbstractRunner {
         }
         return this.profile(capabilities);
     }
-    profileCacheKey(workspacePath, environment) {
-        return createHash('sha256')
-            .update(JSON.stringify({ workspacePath, environment: this.environmentFingerprint(environment) }))
-            .digest('hex');
-    }
     environmentFingerprint(environment) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         return createHash('sha256').update(JSON.stringify(entries)).digest('hex');
@@ -125,18 +115,18 @@ export class OpenCodeRunner extends AbstractRunner {
             openCode: { available: true }
         });
     }
-    supportsConfiguration(configuration, workspace, environment = {}) {
+    supportsConfiguration(configuration, _workspace, environment = {}) {
         if (configuration.runner !== this.name)
             return false;
-        const models = this.cachedModels(workspace, environment);
+        const models = this.cachedModels(environment);
         const model = models.find((candidate) => candidate.id === configuration.model);
         return (model !== undefined &&
             (model.supportedEfforts.length === 0 ||
                 model.supportedEfforts.includes(configuration.effort)) &&
             this.profileForValidation().accessOptions.some((candidate) => candidate.id === configuration.access));
     }
-    defaultConfiguration(workspace, environment = {}) {
-        const model = this.cachedModels(workspace, environment)[0];
+    defaultConfiguration(_workspace, environment = {}) {
+        const model = this.cachedModels(environment)[0];
         return {
             runner: this.name,
             model: model?.id ?? '',
@@ -144,13 +134,11 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
-    cachedModels(workspace, environment) {
+    cachedModels(environment) {
         const fingerprint = this.environmentFingerprint(environment);
         const now = Date.now();
         return [...this.profileCache.values()]
-            .filter((entry) => entry.expiresAt > now &&
-            entry.environmentFingerprint === fingerprint &&
-            (workspace === undefined || entry.workspacePath === workspace.path))
+            .filter((entry) => entry.expiresAt > now && entry.environmentFingerprint === fingerprint)
             .flatMap((entry) => entry.models);
     }
     mcpConfiguration(raw, secrets) {
@@ -306,24 +294,20 @@ export class OpenCodeRunner extends AbstractRunner {
         const cache = object(tokens?.cache);
         const usedTokens = positiveNumber(tokens?.input) + positiveNumber(cache?.read);
         const modelId = provider !== undefined && model !== undefined ? `${provider}/${model}` : session.model;
-        const limits = [...this.contextLimitsByWorkspace].find(([workspacePath]) => isWithinWorkspace(session.cwd, workspacePath))?.[1];
-        const maxTokens = modelId === null ? undefined : limits?.get(modelId);
-        return maxTokens === undefined || usedTokens <= 0
-            ? undefined
-            : { model: modelId, usedTokens, maxTokens };
+        if (modelId === null || usedTokens <= 0)
+            return undefined;
+        const maxTokens = Date.now() >= this.contextLimitsExpiresAt ? undefined : this.contextLimits.get(modelId);
+        return maxTokens === undefined ? undefined : { model: modelId, usedTokens, maxTokens };
     }
     async stop() {
         for (const execution of this.execution.values())
             execution.abort.abort();
         this.execution.clear();
         this.managedTurns.clear();
-        for (const timer of this.profileTimersByWorkspace.values())
-            clearTimeout(timer);
-        this.profileTimersByWorkspace.clear();
         this.profileCache.clear();
         this.profileRefreshes.clear();
-        this.modelsByWorkspace.clear();
-        this.contextLimitsByWorkspace.clear();
+        this.contextLimits = new Map();
+        this.contextLimitsExpiresAt = 0;
         const stopping = [
             this.client.stop(),
             ...[...this.environmentClients.values()].map(({ client }) => client.stop()),
@@ -333,22 +317,6 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
-    scheduleProfileExpiry(workspacePath) {
-        this.clearProfileTimer(workspacePath);
-        const timer = setTimeout(() => {
-            this.profileTimersByWorkspace.delete(workspacePath);
-            this.modelsByWorkspace.delete(workspacePath);
-            this.contextLimitsByWorkspace.delete(workspacePath);
-        }, PROFILE_ENTRY_TTL_MS);
-        timer.unref();
-        this.profileTimersByWorkspace.set(workspacePath, timer);
-    }
-    clearProfileTimer(workspacePath) {
-        const timer = this.profileTimersByWorkspace.get(workspacePath);
-        if (timer !== undefined)
-            clearTimeout(timer);
-        this.profileTimersByWorkspace.delete(workspacePath);
-    }
     managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
         if (entries.length === 0 && isolationKey === undefined)

package/dist/service/runner-service.js

@@ -22,11 +22,8 @@ export class RunnerService {
     profiles() {
         return this.runners.profiles(this.capabilities());
     }
-    refreshProfiles(workspaceId, environment = {}) {
-        const workspace = workspaceId === undefined ? undefined : this.database().getWorkspace(workspaceId);
-        if (workspaceId !== undefined && workspace === undefined)
-            throw new Error('WORKSPACE_NOT_FOUND');
-        return this.runners.refreshProfiles(this.capabilities(), workspace, environment);
+    refreshProfiles(environment = {}) {
+        return this.runners.refreshProfiles(this.capabilities(), undefined, environment);
     }
     async usageStatuses() {
         return {
@@ -51,9 +48,6 @@ export class RunnerService {
             'configureModels' in marAgent &&
             typeof marAgent.configureModels === 'function')
             marAgent.configureModels(input.marAgentModels);
-        const workspaceId = typeof input.workspaceId === 'string' && input.workspaceId.length > 0
-            ? input.workspaceId
-            : undefined;
         const environment = parseSecretEnvironment(input.secretEnvironment);
         const defaults = this.database()
             .getRunnerDefaults()
@@ -68,7 +62,7 @@ export class RunnerService {
             return normalized;
         });
         return {
-            profiles: await this.refreshProfiles(workspaceId, environment),
+            profiles: await this.refreshProfiles(environment),
             defaults
         };
     }

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

@@ -1,5 +1,6 @@
 import { tmpdir } from 'node:os';
-import { isAbsolute, win32 } from 'node:path';
+import { isAbsolute, relative, resolve, win32 } from 'node:path';
+import { realpath } from 'node:fs/promises';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAllowedFileContentRange, readWorkspaceFileContentRange, readAllowedTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
 const INDEX_CACHE_LIMIT = 32;
 export class WorkspaceFileService {
@@ -52,6 +53,19 @@ export class WorkspaceFileService {
         const path = normalizeFilePreviewPath(input.path);
         if (workspacePath !== workspace.path && isFilePreviewAbsolutePath(path))
             throw new Error('FILE_PATH_ESCAPE');
+        if (input.previewDirectory !== undefined) {
+            if (typeof input.previewDirectory !== 'string' ||
+                isFilePreviewAbsolutePath(path) ||
+                isFilePreviewAbsolutePath(input.previewDirectory))
+                throw new Error('FILE_PATH_ESCAPE');
+            const root = await realpath(resolve(workspacePath, input.previewDirectory));
+            const target = await realpath(resolve(workspacePath, path));
+            const suffix = relative(root, target);
+            if (suffix === '..' ||
+                suffix.startsWith(`..${process.platform === 'win32' ? '\\' : '/'}`) ||
+                isAbsolute(suffix))
+                throw new Error('FILE_PATH_ESCAPE');
+        }
         const offset = typeof input.offset === 'number' ? input.offset : 0;
         const limit = typeof input.limit === 'number' ? input.limit : 512 * 1024;
         return isFilePreviewAbsolutePath(path)

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

@@ -150,7 +150,8 @@ export class WorkspaceWorkbenchService {
         const workspace = this.options.requireWorkspace(input.workspaceId);
         const repository = await this.fileRepository(workspace, input);
         return {
-            file: await this.options.files.readContent(workspace, input, repository)
+            file: await this.options.files.readContent(workspace, input, repository),
+            ...(input.previewDirectory === undefined ? {} : { previewBoundaryVerified: true })
         };
     }
     async directFileMetadata(input) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.114",
+  "version": "0.9.116",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,9 +30,9 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.114",
-    "@myagentroam/code-navigation": "0.9.114",
-    "@myagentroam/protocol": "0.9.114"
+    "@myagentroam/protocol": "0.9.116",
+    "@myagentroam/agent": "0.9.116",
+    "@myagentroam/code-navigation": "0.9.116"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"