@myagentroam/node 0.1.7 → 0.9.0

package/dist/runner-profiles.js

@@ -1,38 +1,18 @@
-// Codex reasoning efforts follow the official Codex model surface. Keep this
-// shared so an alias such as GPT-5.6 Luna cannot accidentally lose `high`.
-const CODEX_REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const CLAUDE_MODEL_ENVIRONMENT = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
     haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL'
 };
 /**
- * The Runner APIs used by MAR do not expose a portable model-list endpoint.
- * Keep the supported, product-visible choices in one Node-owned definition so
- * the browser never guesses models, effort levels, permission modes, or slash
- * commands. Model aliases for Claude are accepted by the Agent SDK and avoid
- * coupling the UI to a vendor version suffix.
+ * Keep product-visible permission modes and slash commands in one Node-owned
+ * definition. Codex models are supplied by App Server `model/list`; Claude
+ * aliases are accepted by the Agent SDK and avoid coupling the UI to a vendor
+ * version suffix.
  */
 const definitions = {
     codex: {
         runner: 'codex',
-        models: [
-            {
-                id: 'gpt-5.6-sol',
-                label: 'GPT-5.6 Sol',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
-            },
-            {
-                id: 'gpt-5.6-terra',
-                label: 'GPT-5.6 Terra',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
-            },
-            {
-                id: 'gpt-5.6-luna',
-                label: 'GPT-5.6 Luna',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
-            }
-        ],
+        models: [],
         accessOptions: [
             { id: 'on-request', label: 'On-request', description: '由 Codex 在需要额外权限时请求确认。' },
             {

package/dist/runtime-command-detector.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCommand } from '@myagentroam/protocol';
+export declare function detectRuntimeCommands(): Promise<RuntimeCommand[]>;
+export declare function normalizeVersion(id: RuntimeCommand['id'], value: string): string | undefined;

package/dist/runtime-command-detector.js

@@ -0,0 +1,78 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const COMMANDS = [
+    { id: 'npx', candidates: ['npx'], versionArguments: ['--version'] },
+    { id: 'git', candidates: ['git'], versionArguments: ['--version'] },
+    { id: 'python', candidates: ['python3', 'python'], versionArguments: ['--version'] },
+    { id: 'pip', candidates: ['pip3', 'pip'], versionArguments: ['--version'] }
+];
+export async function detectRuntimeCommands() {
+    return Promise.all(COMMANDS.map(detectCommand));
+}
+async function detectCommand(descriptor) {
+    for (const command of descriptor.candidates) {
+        try {
+            const [{ stdout, stderr }, path] = await Promise.all([
+                executeVersion(command, descriptor.versionArguments),
+                resolveCommandPath(command)
+            ]);
+            const version = normalizeVersion(descriptor.id, `${stdout}${stderr}`.trim().split(/\r?\n/u)[0]?.trim() ?? '');
+            return {
+                id: descriptor.id,
+                command,
+                available: true,
+                ...(version === undefined || version === '' ? {} : { version }),
+                ...(path === undefined ? {} : { path })
+            };
+        }
+        catch {
+            // Try the platform-compatible fallback command name.
+        }
+    }
+    return {
+        id: descriptor.id,
+        command: descriptor.candidates[0],
+        available: false
+    };
+}
+export function normalizeVersion(id, value) {
+    const normalized = value.trim();
+    if (normalized === '')
+        return undefined;
+    const patterns = {
+        git: /^git version\s+(\S+)/iu,
+        python: /^python\s+(\S+)/iu,
+        pip: /^pip\s+(\S+)/iu
+    };
+    const match = patterns[id]?.exec(normalized);
+    return (match?.[1] ?? normalized).slice(0, 512);
+}
+async function executeVersion(command, args) {
+    const executable = process.platform === 'win32' ? process.env['ComSpec'] || 'cmd.exe' : command;
+    const commandArgs = process.platform === 'win32'
+        ? ['/d', '/s', '/c', [command, ...args].map(quoteWindowsArgument).join(' ')]
+        : [...args];
+    return execFileAsync(executable, commandArgs, {
+        timeout: 5_000,
+        maxBuffer: 64 * 1024,
+        windowsHide: true
+    });
+}
+function quoteWindowsArgument(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+async function resolveCommandPath(command) {
+    try {
+        const resolver = process.platform === 'win32' ? 'where.exe' : 'which';
+        const { stdout } = await execFileAsync(resolver, [command], {
+            timeout: 2_000,
+            maxBuffer: 64 * 1024,
+            windowsHide: true
+        });
+        return stdout.trim().split(/\r?\n/u)[0]?.trim().slice(0, 2048) || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/service/mcp-installation-verifier.d.ts

@@ -0,0 +1,9 @@
+import type { McpCatalogEntry, McpInstallationConfiguration } from '@myagentroam/protocol';
+export declare class McpInstallationVerifier {
+    verify(input: {
+        readonly entry: McpCatalogEntry;
+        readonly configuration: McpInstallationConfiguration;
+        readonly secrets: Readonly<Record<string, string>>;
+        readonly cwd: string;
+    }): Promise<void>;
+}

package/dist/service/mcp-installation-verifier.js

@@ -0,0 +1,87 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { getDefaultEnvironment, StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+const INSTALL_TIMEOUT_MS = 90_000;
+export class McpInstallationVerifier {
+    async verify(input) {
+        const client = new Client({ name: 'myagentroam-node-installer', version: '0.9.0' });
+        try {
+            await withTimeout((async () => {
+                if (input.entry.runtime.transport === 'STDIO') {
+                    await client.connect(new StdioClientTransport({
+                        command: input.entry.runtime.command,
+                        args: [...input.entry.runtime.args, ...(input.configuration.arguments ?? [])],
+                        env: {
+                            ...getDefaultEnvironment(),
+                            ...resolveReferences(input.entry.runtime.environment, input.secrets),
+                            ...resolveReferences(input.configuration.environment, input.secrets)
+                        },
+                        cwd: input.cwd,
+                        stderr: 'pipe'
+                    }));
+                }
+                else {
+                    await client.connect(new StreamableHTTPClientTransport(new URL(input.entry.runtime.url), {
+                        requestInit: {
+                            headers: {
+                                ...resolveReferences(input.entry.runtime.headers, input.secrets),
+                                ...resolveReferences(input.configuration.headers, input.secrets)
+                            }
+                        }
+                    }));
+                }
+                const tools = await client.listTools();
+                if (tools.tools.length === 0)
+                    throw new Error('MCP_TOOLS_UNAVAILABLE');
+            })());
+        }
+        catch (error) {
+            throw installError(error);
+        }
+        finally {
+            await Promise.race([client.close().catch(() => undefined), delay(2_000)]);
+        }
+    }
+}
+function resolveReferences(references, secrets) {
+    const result = {};
+    for (const [name, reference] of Object.entries(references ?? {})) {
+        const value = secrets[reference.secretName];
+        if (value === undefined)
+            throw new Error('MCP_SECRET_MISSING');
+        result[name] = value;
+    }
+    return result;
+}
+async function withTimeout(operation) {
+    let timer;
+    try {
+        await Promise.race([
+            operation,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('MCP_INSTALL_TIMEOUT')), INSTALL_TIMEOUT_MS);
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+function installError(error) {
+    const message = error instanceof Error ? error.message : '';
+    if (message === 'MCP_INSTALL_TIMEOUT' ||
+        message === 'MCP_SECRET_MISSING' ||
+        message === 'MCP_TOOLS_UNAVAILABLE')
+        return new Error(message);
+    if (/401|403|unauthorized|forbidden/iu.test(message))
+        return new Error('MCP_AUTH_FAILED');
+    if (/ENOENT|spawn/iu.test(message))
+        return new Error('MCP_COMMAND_UNAVAILABLE');
+    if (/fetch|connect|network|ECONN|ENOTFOUND/iu.test(message))
+        return new Error('MCP_CONNECTION_FAILED');
+    return new Error('MCP_PROTOCOL_VALIDATION_FAILED');
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/dist/service/mcp-node-operation-service.d.ts

@@ -0,0 +1,11 @@
+import type { NodeDatabase } from '../database.js';
+import { McpInstallationVerifier } from './mcp-installation-verifier.js';
+export declare class McpNodeOperationService {
+    private readonly requireDatabase;
+    private readonly verifier;
+    constructor(requireDatabase: () => NodeDatabase, verifier?: McpInstallationVerifier);
+    operations(): Readonly<Record<string, (data: unknown) => unknown>>;
+    private inspect;
+    private install;
+    private remove;
+}

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/node-connection-lifecycle-service.js

@@ -33,8 +33,7 @@ export class NodeConnectionLifecycleService {
         const registered = {
             serverUrl: config.serverUrl,
             allowedRoots: config.allowedRoots,
-            ...(config.databasePath === undefined ? {} : { databasePath: config.databasePath }),
-            ...(config.upgrade === undefined ? {} : { upgrade: config.upgrade }),
+            ...(config.dataDirectory === undefined ? {} : { dataDirectory: config.dataDirectory }),
             nodeId,
             credential
         };

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

@@ -17,19 +17,21 @@ export declare class RunnerService {
             id: string;
             label: string;
             supportedEfforts: string[];
+            isDefault?: boolean | undefined;
+            defaultEffort?: string | undefined;
         }[];
         accessOptions: {
             id: string;
-            label: string;
             description: string;
+            label: string;
         }[];
         commands: {
             id: string;
+            description: string;
             available: boolean;
             runner: "codex" | "claude-code" | "opencode";
             reasonCode: string | null;
             label: string;
-            description: string;
             inputHint: string;
             source: "CODEX_APP_SERVER" | "CLAUDE_AGENT_SDK" | "OPENCODE_SERVER";
             interaction: "RUNNER_TEXT" | "IMMEDIATE_ACTION" | "TOGGLE" | "VALUE";

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/skill-directory-service.d.ts

@@ -0,0 +1,17 @@
+import { type SkillInstallMetadata } from '@myagentroam/protocol';
+export type LocalSkillStatus = 'VALID' | 'UNKNOWN_VERSION' | 'PARTIAL' | 'INVALID' | 'INVALID_LINK' | 'GIT_EXCLUDE_BROKEN';
+export interface LocalSkillInspection {
+    readonly name: string;
+    readonly description: string;
+    readonly localStatus: LocalSkillStatus;
+    readonly install?: SkillInstallMetadata;
+}
+export interface LocalSkillTargetInspection {
+    readonly targetKind: 'NODE' | 'WORKSPACE';
+    readonly compatibilityMode: 'SYMLINK' | 'JUNCTION' | 'MANAGED_COPY' | 'UNAVAILABLE';
+    readonly skills: readonly LocalSkillInspection[];
+}
+export declare class SkillDirectoryService {
+    inspectNodeHome(home: string): Promise<LocalSkillTargetInspection>;
+    inspectWorkspace(workspace: string): Promise<LocalSkillTargetInspection>;
+}