@myagentroam/node 0.1.8 → 0.9.0

package/dist/service/mcp-node-operation-service.js

@@ -0,0 +1,90 @@
+import { mcpCatalogEntrySchema, mcpInstallationInputSchema, mcpTargetInspectionSchema } from '@myagentroam/protocol';
+import { homedir } from 'node:os';
+import { McpInstallationVerifier } from './mcp-installation-verifier.js';
+export class McpNodeOperationService {
+    requireDatabase;
+    verifier;
+    constructor(requireDatabase, verifier = new McpInstallationVerifier()) {
+        this.requireDatabase = requireDatabase;
+        this.verifier = verifier;
+    }
+    operations() {
+        return {
+            'node.mcps.inspect': () => this.inspect('NODE', ''),
+            'node.mcps.install': (data) => this.install('NODE', '', data),
+            'node.mcps.remove': (data) => this.remove('NODE', '', data),
+            'workspace.mcps.inspect': (data) => this.inspect('WORKSPACE', workspaceId(data)),
+            'workspace.mcps.install': (data) => this.install('WORKSPACE', workspaceId(data), data),
+            'workspace.mcps.remove': (data) => this.remove('WORKSPACE', workspaceId(data), data)
+        };
+    }
+    inspect(targetKind, targetId) {
+        const database = this.requireDatabase();
+        const own = database.listMcpInstallations(targetKind, targetId);
+        const ownNames = new Set(own.map((installation) => installation.serverName));
+        const installations = [
+            ...(targetKind === 'WORKSPACE'
+                ? database
+                    .listMcpInstallations('NODE')
+                    .filter((installation) => !ownNames.has(installation.serverName))
+                : []),
+            ...own
+        ].map((installation) => ({
+            catalogEntryId: installation.catalogEntryId,
+            serverName: installation.serverName,
+            displayName: installation.displayName,
+            version: installation.version,
+            origin: installation.targetKind,
+            enabled: installation.enabled,
+            status: 'CURRENT',
+            installedAt: installation.installedAt
+        }));
+        return mcpTargetInspectionSchema.parse({ targetKind, installations });
+    }
+    async install(targetKind, targetId, raw) {
+        if (!isRecord(raw))
+            throw new Error('MCP_INSTALL_INPUT_INVALID');
+        const entry = mcpCatalogEntrySchema.parse(raw['entry']);
+        const input = mcpInstallationInputSchema.parse({
+            catalogEntryId: entry.id,
+            enabled: raw['enabled'] ?? true,
+            configuration: raw['configuration'] ?? {}
+        });
+        const database = this.requireDatabase();
+        const secretEnvironment = isRecord(raw['secretEnvironment'])
+            ? Object.fromEntries(Object.entries(raw['secretEnvironment']).filter((entry) => typeof entry[1] === 'string'))
+            : {};
+        const cwd = targetKind === 'WORKSPACE' ? database.getWorkspace(targetId)?.path : homedir();
+        if (cwd === undefined)
+            throw new Error('WORKSPACE_NOT_FOUND');
+        if (input.enabled)
+            await this.verifier.verify({
+                entry,
+                configuration: input.configuration,
+                secrets: secretEnvironment,
+                cwd
+            });
+        database.saveMcpInstallation({
+            targetKind,
+            ...(targetKind === 'WORKSPACE' ? { targetId } : {}),
+            entry,
+            enabled: input.enabled,
+            configuration: input.configuration
+        });
+        return this.inspect(targetKind, targetId);
+    }
+    remove(targetKind, targetId, raw) {
+        if (!isRecord(raw) || typeof raw['serverName'] !== 'string')
+            throw new Error('MCP_INSTALL_INPUT_INVALID');
+        this.requireDatabase().removeMcpInstallation(targetKind, targetId, raw['serverName']);
+        return this.inspect(targetKind, targetId);
+    }
+}
+function workspaceId(raw) {
+    if (!isRecord(raw) || typeof raw['workspaceId'] !== 'string' || raw['workspaceId'] === '')
+        throw new Error('WORKSPACE_INVALID');
+    return raw['workspaceId'];
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/service/mcp-package-installer.d.ts

@@ -0,0 +1,8 @@
+import type { McpCatalogEntry } from '@myagentroam/protocol';
+export declare class McpPackageInstaller {
+    private readonly dataDirectory;
+    constructor(dataDirectory: string | (() => string));
+    prepare(entry: McpCatalogEntry): Promise<McpCatalogEntry>;
+    private install;
+    private prepareRuntimeEnvironment;
+}

package/dist/service/mcp-package-installer.js

@@ -0,0 +1,136 @@
+import { execFile } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+const installs = new Map();
+export class McpPackageInstaller {
+    dataDirectory;
+    constructor(dataDirectory) {
+        this.dataDirectory = dataDirectory;
+    }
+    prepare(entry) {
+        if (entry.runtime.transport !== 'STDIO')
+            return Promise.resolve(entry);
+        const request = packageRequest(entry.runtime.command, entry.runtime.args);
+        if (request === undefined)
+            return Promise.resolve(entry);
+        const key = `${request.spec}\0${entry.serverName}`;
+        const active = installs.get(key);
+        if (active !== undefined)
+            return active;
+        const operation = this.install(entry, request).finally(() => installs.delete(key));
+        installs.set(key, operation);
+        return operation;
+    }
+    async install(entry, request) {
+        const dataDirectory = typeof this.dataDirectory === 'string' ? this.dataDirectory : this.dataDirectory();
+        if (entry.runtime.transport !== 'STDIO')
+            return entry;
+        const runtimeEnvironment = entry.runtime.environment;
+        const digest = createHash('sha256').update(request.spec).digest('hex');
+        const root = resolve(dataDirectory, 'mcp-packages', digest);
+        const metadataPath = resolve(root, 'installation.json');
+        let executable = await installedExecutable(metadataPath, request.spec);
+        if (executable === undefined) {
+            const staging = `${root}.install-${randomUUID()}`;
+            await mkdir(dirname(root), { recursive: true, mode: 0o700 });
+            try {
+                await mkdir(staging, { recursive: true, mode: 0o700 });
+                await runNpmInstall(staging, request.spec);
+                executable = await resolvePackageExecutable(staging, request.spec);
+                await writeFile(resolve(staging, 'installation.json'), `${JSON.stringify({ spec: request.spec, executable: executable.slice(staging.length) })}\n`, { mode: 0o600 });
+                await rm(root, { recursive: true, force: true });
+                await rename(staging, root);
+                executable = resolve(root, `.${executable.slice(staging.length)}`);
+            }
+            catch (error) {
+                await rm(staging, { recursive: true, force: true });
+                throw packageError(error);
+            }
+        }
+        const prefixArgs = await this.prepareRuntimeEnvironment(entry.serverName, root, dataDirectory);
+        return {
+            ...entry,
+            runtime: {
+                transport: 'STDIO',
+                command: process.execPath,
+                args: [...prefixArgs, executable, ...request.serverArgs],
+                ...(runtimeEnvironment === undefined ? {} : { environment: runtimeEnvironment })
+            }
+        };
+    }
+    async prepareRuntimeEnvironment(serverName, packageRoot, dataDirectory) {
+        if (serverName !== 'io.github.microsoft/playwright-mcp')
+            return [];
+        const browserRoot = resolve(dataDirectory, 'mcp-browsers', 'playwright');
+        await mkdir(browserRoot, { recursive: true, mode: 0o700 });
+        const preload = resolve(packageRoot, 'playwright-environment.cjs');
+        await writeFile(preload, `process.env.PLAYWRIGHT_BROWSERS_PATH = ${JSON.stringify(browserRoot)};\n`, { mode: 0o600 });
+        const playwright = resolve(packageRoot, 'node_modules', 'playwright', 'cli.js');
+        await run(process.execPath, [playwright, 'install', 'chromium'], {
+            PLAYWRIGHT_BROWSERS_PATH: browserRoot
+        });
+        const modulePath = resolve(packageRoot, 'node_modules', 'playwright');
+        await run(process.execPath, [
+            '-e',
+            `const {chromium}=require(${JSON.stringify(modulePath)});chromium.launch({headless:true}).then(b=>b.close())`
+        ], { PLAYWRIGHT_BROWSERS_PATH: browserRoot });
+        return ['--require', preload];
+    }
+}
+function packageRequest(command, args) {
+    if (command !== 'npx')
+        return undefined;
+    const index = args.findIndex((argument) => !argument.startsWith('-'));
+    const spec = index < 0 ? '' : args[index];
+    if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+@\d[0-9A-Za-z.+-]*$/u.test(spec))
+        throw new Error('MCP_PACKAGE_SPEC_INVALID');
+    return { spec, serverArgs: args.slice(index + 1) };
+}
+async function runNpmInstall(root, spec) {
+    await run(process.platform === 'win32' ? 'npm.cmd' : 'npm', [
+        'install',
+        '--prefix',
+        root,
+        '--no-save',
+        '--package-lock=false',
+        '--ignore-scripts',
+        spec
+    ]);
+}
+async function run(command, args, environment = {}) {
+    await execute(command, [...args], {
+        env: { ...process.env, ...environment },
+        timeout: 300_000,
+        maxBuffer: 1024 * 1024,
+        ...(process.platform === 'win32' && command.endsWith('.cmd') ? { shell: true } : {})
+    });
+}
+async function resolvePackageExecutable(root, spec) {
+    const packageName = spec.slice(0, spec.lastIndexOf('@'));
+    const packageRoot = resolve(root, 'node_modules', ...packageName.split('/'));
+    const manifest = JSON.parse(await readFile(resolve(packageRoot, 'package.json'), 'utf8'));
+    const candidates = typeof manifest.bin === 'string' ? [manifest.bin] : Object.values(manifest.bin ?? {});
+    if (candidates.length !== 1)
+        throw new Error('MCP_PACKAGE_EXECUTABLE_INVALID');
+    return resolve(packageRoot, candidates[0]);
+}
+async function installedExecutable(metadataPath, spec) {
+    try {
+        const metadata = JSON.parse(await readFile(metadataPath, 'utf8'));
+        if (metadata['spec'] !== spec || typeof metadata['executable'] !== 'string')
+            return undefined;
+        return resolve(dirname(metadataPath), `.${metadata['executable']}`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function packageError(error) {
+    const message = error instanceof Error ? error.message : '';
+    if (message.startsWith('MCP_'))
+        return new Error(message);
+    return new Error('MCP_PACKAGE_INSTALL_FAILED');
+}

package/dist/service/runner-service.d.ts

@@ -17,6 +17,8 @@ export declare class RunnerService {
             id: string;
             label: string;
             supportedEfforts: string[];
+            isDefault?: boolean | undefined;
+            defaultEffort?: string | undefined;
         }[];
         accessOptions: {
             id: string;

package/dist/service/runner-service.js

@@ -54,14 +54,17 @@ export class RunnerService {
             profiles: await this.refreshProfiles(workspaceId, environment),
             defaults: this.database()
                 .getRunnerDefaults()
-                .filter((value) => this.runners.supportsConfiguration(value))
+                .filter((value) => this.runners.supportsConfiguration(value, undefined, environment))
         };
     }
     saveDefaults(data) {
+        const environment = parseSecretEnvironment(typeof data === 'object' && data !== null
+            ? data.secretEnvironment
+            : undefined);
         const parsed = runnerDefaultConfigurationSchema.safeParse(data);
         if (!parsed.success)
             throw new Error('RUNNER_DEFAULT_INVALID');
-        if (!this.runners.supportsConfiguration(parsed.data))
+        if (!this.runners.supportsConfiguration(parsed.data, undefined, environment))
             throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
         return { defaults: this.database().saveRunnerDefaults(parsed.data) };
     }

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

@@ -1,5 +1,6 @@
 import { validSessionEffort, validSessionOption, validSessionTitle } from '../util/node-operation-parsers.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { parseSecretEnvironment } from '../util/secret-environment.js';
 export class SessionLifecycleService {
     options;
     starts = new Map();
@@ -75,18 +76,19 @@ export class SessionLifecycleService {
         const workspace = database.getWorkspace(input.workspaceId);
         if (workspace === undefined)
             throw new Error('WORKSPACE_NOT_FOUND');
+        const environment = parseSecretEnvironment(input.secretEnvironment);
         const saved = database
             .getRunnerDefaults()
             .find((value) => value.runner === runner.name &&
-            this.options.runners.supportsConfiguration(value, workspace));
-        const fallback = runner.defaultConfiguration(workspace);
+            this.options.runners.supportsConfiguration(value, workspace, environment));
+        const fallback = runner.defaultConfiguration(workspace, environment);
         const configuration = {
             runner: runner.name,
             model: typeof input.model === 'string' ? input.model : (saved?.model ?? fallback.model),
             effort: typeof input.effort === 'string' ? input.effort : (saved?.effort ?? fallback.effort),
             access: typeof input.access === 'string' ? input.access : (saved?.access ?? fallback.access)
         };
-        if (!this.options.runners.supportsConfiguration(configuration, workspace))
+        if (!this.options.runners.supportsConfiguration(configuration, workspace, environment))
             throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
         const session = this.options.runtime.createAgentSession({
             workspaceId: input.workspaceId,
@@ -125,8 +127,9 @@ export class SessionLifecycleService {
             access: input.access
         };
         const workspace = this.options.database().getWorkspace(current.workspaceId);
+        const environment = parseSecretEnvironment(input.secretEnvironment);
         if (workspace === undefined ||
-            !this.options.runners.supportsConfiguration(configuration, workspace))
+            !this.options.runners.supportsConfiguration(configuration, workspace, environment))
             throw new Error('RUNNER_CONFIGURATION_UNSUPPORTED');
         const session = this.options.runtime.updateAgentSessionConfiguration({
             sessionId: current.id,

package/dist/service/workbench-manifest-service.d.ts

@@ -33,6 +33,8 @@ export declare class WorkbenchManifestService {
                 id: string;
                 label: string;
                 supportedEfforts: string[];
+                isDefault?: boolean | undefined;
+                defaultEffort?: string | undefined;
             }[];
             accessOptions: {
                 id: string;

package/dist/service/workspace-queue-workbench-service.d.ts

@@ -1,6 +1,7 @@
 import type { NodeOperationHandler } from '../connector/node-operation-router.js';
 import type { NodeRuntimeState } from '../runtime-state.js';
 import type { RunnerName } from '@myagentroam/protocol';
+import type { NodeMcpInstallation } from '../database.js';
 export interface QueuedRunStart<TAttachment = unknown> {
     readonly runId: string;
     readonly sessionId: string;
@@ -28,6 +29,7 @@ export interface WorkspaceQueueWorkbenchServiceOptions {
     readonly stopped: () => boolean;
     readonly markInterrupted: (runId: string) => void;
     readonly prepareInput: (runner: RunnerName, input: string, collaborationMode: 'default' | 'plan') => string;
+    readonly mcps: (workspaceId: string) => readonly NodeMcpInstallation[];
 }
 export declare class WorkspaceQueueWorkbenchService<TAttachment> {
     private readonly options;

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

@@ -178,7 +178,8 @@ export class WorkspaceQueueWorkbenchService {
                 ...(pending.access === null ? {} : { access: pending.access }),
                 collaborationMode: pending.collaborationMode,
                 ...(pending.serviceTier === undefined ? {} : { serviceTier: pending.serviceTier }),
-                secretEnvironment: pending.secretEnvironment
+                secretEnvironment: pending.secretEnvironment,
+                mcpInstallations: this.options.mcps(pending.workspaceId)
             });
         }
         catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.1.8",
+  "version": "0.9.0",
   "description": "MyAgentRoam Node runtime CLI.",
   "type": "module",
   "files": [
@@ -24,7 +24,7 @@
     "node-pty": "1.1.0",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/protocol": "^0.1.8"
+    "@myagentroam/protocol": "^0.9.0"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"