@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/tools/mcp/index.js

@@ -0,0 +1,177 @@
+import { MCP_TOOL_SCHEMA } from '@pellux/goodvibes-sdk/platform/tools/mcp/schema';
+function summarizeServer(server) {
+    return {
+        name: server.name,
+        connected: server.connected,
+        role: server.role,
+        trustMode: server.trustMode,
+        schemaFreshness: server.schemaFreshness,
+        quarantined: server.schemaFreshness === 'quarantined',
+    };
+}
+function previewServer(server) {
+    return {
+        ...summarizeServer(server),
+        allowedPathCount: server.allowedPaths.length,
+        allowedHostCount: server.allowedHosts.length,
+        quarantineReason: server.quarantineReason,
+        quarantineDetail: server.quarantineDetail,
+        quarantineApprovedBy: server.quarantineApprovedBy,
+    };
+}
+function summarizeDecision(decision) {
+    return {
+        serverName: decision.serverName,
+        toolName: decision.toolName,
+        verdict: decision.verdict,
+        reason: decision.reason,
+        evaluatedAt: decision.evaluatedAt,
+    };
+}
+export function createMcpTool(mcpRegistry) {
+    return {
+        definition: {
+            name: 'mcp',
+            description: 'Inspect MCP servers, tools, schemas, and trust state.',
+            parameters: MCP_TOOL_SCHEMA.parameters,
+            sideEffects: ['state'],
+            concurrency: 'serial',
+        },
+        async execute(args) {
+            if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
+                return { success: false, error: 'Invalid args: mode is required.' };
+            }
+            const input = args;
+            const view = input.view ?? 'descriptor';
+            if (input.mode === 'servers') {
+                const security = mcpRegistry.listServerSecurity();
+                const filtered = input.serverName
+                    ? security.filter((server) => server.name === input.serverName)
+                    : security;
+                const payload = filtered.map((server) => {
+                    if (view === 'full')
+                        return server;
+                    if (view === 'preview')
+                        return previewServer(server);
+                    return summarizeServer(server);
+                });
+                return { success: true, output: JSON.stringify({ view, count: payload.length, servers: payload }) };
+            }
+            if (input.mode === 'tools') {
+                const tools = await mcpRegistry.listAllTools();
+                const filtered = input.serverName
+                    ? tools.filter((tool) => tool.serverName === input.serverName)
+                    : tools;
+                const summarized = filtered.map((tool) => ({
+                    qualifiedName: tool.qualifiedName,
+                    serverName: tool.serverName,
+                    toolName: tool.toolName,
+                    description: tool.description,
+                }));
+                return { success: true, output: JSON.stringify({ view, count: summarized.length, tools: summarized }) };
+            }
+            if (input.mode === 'schema') {
+                if (!input.qualifiedName)
+                    return { success: false, error: 'schema requires qualifiedName.' };
+                const schema = await mcpRegistry.getToolSchema(input.qualifiedName);
+                if (!schema)
+                    return { success: false, error: `Unknown MCP tool: ${input.qualifiedName}` };
+                return { success: true, output: JSON.stringify(schema) };
+            }
+            if (input.mode === 'resources') {
+                const security = mcpRegistry.listServerSecurity();
+                const filtered = input.serverName
+                    ? security.filter((server) => server.name === input.serverName)
+                    : security;
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        count: filtered.length,
+                        servers: filtered.map((server) => ({
+                            name: server.name,
+                            resourceCount: 0,
+                            availableResources: [],
+                            note: 'resource inventory is not surfaced by the lightweight MCP registry path yet',
+                            trustMode: server.trustMode,
+                            schemaFreshness: server.schemaFreshness,
+                        })),
+                    }),
+                };
+            }
+            if (input.mode === 'security') {
+                const servers = mcpRegistry.listServerSecurity();
+                const filtered = input.serverName
+                    ? servers.filter((server) => server.name === input.serverName)
+                    : servers;
+                const recentDecisions = mcpRegistry.listRecentSecurityDecisions();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        servers: filtered.map((server) => {
+                            if (view === 'full')
+                                return server;
+                            if (view === 'preview')
+                                return previewServer(server);
+                            return summarizeServer(server);
+                        }),
+                        recentDecisions: view === 'full'
+                            ? recentDecisions
+                            : recentDecisions.slice(0, 8).map(summarizeDecision),
+                    }),
+                };
+            }
+            if (input.mode === 'auth') {
+                const servers = mcpRegistry.listServerSecurity();
+                const filtered = input.serverName
+                    ? servers.filter((server) => server.name === input.serverName)
+                    : servers;
+                const recentDecisions = mcpRegistry.listRecentSecurityDecisions();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        servers: filtered.map((server) => {
+                            if (view === 'full') {
+                                return {
+                                    ...server,
+                                    allowedPaths: server.allowedPaths,
+                                    allowedHosts: server.allowedHosts,
+                                };
+                            }
+                            if (view === 'preview')
+                                return previewServer(server);
+                            return summarizeServer(server);
+                        }),
+                        recentDecisions: view === 'full'
+                            ? recentDecisions
+                            : recentDecisions.slice(0, 8).map(summarizeDecision),
+                    }),
+                };
+            }
+            if (input.mode === 'approve-quarantine') {
+                if (!input.serverName || !input.operatorId) {
+                    return { success: false, error: 'approve-quarantine requires serverName and operatorId.' };
+                }
+                mcpRegistry.approveSchemaQuarantine(input.serverName, input.operatorId);
+                return { success: true, output: JSON.stringify({ serverName: input.serverName, approvedBy: input.operatorId }) };
+            }
+            if (input.mode === 'set-trust') {
+                if (!input.serverName || !input.trustMode) {
+                    return { success: false, error: 'set-trust requires serverName and trustMode.' };
+                }
+                mcpRegistry.setServerTrustMode(input.serverName, input.trustMode);
+                return { success: true, output: JSON.stringify({ serverName: input.serverName, trustMode: input.trustMode }) };
+            }
+            if (input.mode === 'set-role') {
+                if (!input.serverName || !input.role) {
+                    return { success: false, error: 'set-role requires serverName and role.' };
+                }
+                mcpRegistry.setServerRole(input.serverName, input.role === 'deploy' ? 'ops' : input.role);
+                return { success: true, output: JSON.stringify({ serverName: input.serverName, role: input.role }) };
+            }
+            return { success: false, error: `Unknown mode: ${input.mode}` };
+        },
+    };
+}

package/dist/_internal/platform/tools/packet/index.js

@@ -18,7 +18,7 @@ function summarizePacket(record) {
 }
 export function createPacketTool(workingDirectory) {
     const workspaceRoot = resolve(workingDirectory);
-    const packetsDir = join(workspaceRoot, '.goodvibes', 'tui');
+    const packetsDir = join(workspaceRoot, '.goodvibes', 'goodvibes');
     const packetsPath = join(packetsDir, 'packets.json');
     function loadPackets() {
         try {

package/dist/_internal/platform/tools/query/index.js

@@ -16,7 +16,7 @@ function summarizeQuery(record) {
 }
 export function createQueryTool(workingDirectory) {
     const workspaceRoot = resolve(workingDirectory);
-    const queriesDir = join(workspaceRoot, '.goodvibes', 'tui');
+    const queriesDir = join(workspaceRoot, '.goodvibes', 'goodvibes');
     const queriesPath = join(queriesDir, 'queries.json');
     function loadQueries() {
         try {

package/dist/_internal/platform/tools/registry-tool/index.js

@@ -114,20 +114,20 @@ function fuzzyFilter(items, query) {
 function getSkillDirs(roots) {
     const dirs = [
         join(roots.workingDirectory, '.goodvibes', 'skills'),
-        join(roots.workingDirectory, '.goodvibes', 'tui', 'skills'),
+        join(roots.workingDirectory, '.goodvibes', 'goodvibes', 'skills'),
     ];
     if (roots.homeDirectory) {
-        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'tui', 'skills'));
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'goodvibes', 'skills'));
     }
     return dirs;
 }
 function getAgentDirs(roots) {
     const dirs = [
         join(roots.workingDirectory, '.goodvibes', 'agents'),
-        join(roots.workingDirectory, '.goodvibes', 'tui', 'agents'),
+        join(roots.workingDirectory, '.goodvibes', 'goodvibes', 'agents'),
     ];
     if (roots.homeDirectory) {
-        dirs.push(join(roots.homeDirectory, '.goodvibes', 'agents'), join(roots.homeDirectory, '.goodvibes', 'tui', 'agents'));
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'agents'), join(roots.homeDirectory, '.goodvibes', 'goodvibes', 'agents'));
     }
     return dirs;
 }

package/dist/_internal/platform/tools/registry-tool/skill-loader.js

@@ -10,10 +10,10 @@ import { materializeMarkdownBody, parseMarkdownFrontmatter, normalizeFrontmatter
 function getSkillDirs(roots) {
     const dirs = [
         join(roots.workingDirectory, '.goodvibes', 'skills'),
-        join(roots.workingDirectory, '.goodvibes', 'tui', 'skills'),
+        join(roots.workingDirectory, '.goodvibes', 'goodvibes', 'skills'),
     ];
     if (roots.homeDirectory) {
-        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'tui', 'skills'));
+        dirs.push(join(roots.homeDirectory, '.goodvibes', 'skills'), join(roots.homeDirectory, '.goodvibes', 'goodvibes', 'skills'));
     }
     return dirs;
 }

package/dist/_internal/platform/tools/remote-trigger/index.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
+import { RemoteRunnerRegistry } from '../../runtime/remote/runner-registry.js';
+export declare function createRemoteTool(registry: RemoteRunnerRegistry): Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/remote-trigger/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/remote-trigger/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAuC/E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI,CAyFrE"}

package/dist/_internal/platform/tools/remote-trigger/index.js

@@ -0,0 +1,123 @@
+import { RemoteRunnerRegistry } from '../../runtime/remote/runner-registry.js';
+import { REMOTE_TRIGGER_TOOL_SCHEMA } from '@pellux/goodvibes-sdk/platform/tools/remote-trigger/schema';
+function summarizePool(pool) {
+    return {
+        id: pool.id,
+        label: pool.label,
+        runnerCount: pool.runnerIds.length,
+        runnerIds: pool.runnerIds,
+        updatedAt: pool.lastUpdatedAt,
+    };
+}
+function summarizeContract(contract) {
+    return {
+        id: contract.id,
+        runnerId: contract.runnerId,
+        label: contract.label,
+        sourceTransport: contract.sourceTransport,
+        trustClass: contract.trustClass,
+        template: contract.template,
+        transportState: contract.transport.state,
+        toolCount: contract.capabilityCeiling.allowedTools.length,
+        reviewMode: contract.capabilityCeiling.reviewMode,
+        communicationLane: contract.capabilityCeiling.communicationLane,
+    };
+}
+function summarizeArtifact(artifact) {
+    return {
+        id: artifact.id,
+        runnerId: artifact.runnerId,
+        createdAt: artifact.createdAt,
+        task: artifact.task.task,
+        status: artifact.task.status,
+        hasKnowledgeInjections: artifact.knowledgeInjections.length > 0,
+    };
+}
+export function createRemoteTool(registry) {
+    return {
+        definition: {
+            name: 'remote',
+            description: 'Manage remote runner pools, contracts, and portable artifacts.',
+            parameters: REMOTE_TRIGGER_TOOL_SCHEMA.parameters,
+            sideEffects: ['workflow', 'state'],
+            concurrency: 'serial',
+        },
+        async execute(args) {
+            if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
+                return { success: false, error: 'Invalid args: mode is required.' };
+            }
+            const input = args;
+            const view = input.view ?? 'summary';
+            if (input.mode === 'create-pool') {
+                if (!input.poolId)
+                    return { success: false, error: 'create-pool requires poolId.' };
+                const pool = registry.createPool({ id: input.poolId, label: input.label });
+                return { success: true, output: JSON.stringify(pool) };
+            }
+            if (input.mode === 'pools') {
+                const pools = registry.listPools();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        count: pools.length,
+                        pools: view === 'full' ? pools : pools.map(summarizePool),
+                    }),
+                };
+            }
+            if (input.mode === 'assign') {
+                if (!input.poolId || !input.runnerId)
+                    return { success: false, error: 'assign requires poolId and runnerId.' };
+                const pool = registry.assignRunnerToPool(input.poolId, input.runnerId);
+                if (!pool)
+                    return { success: false, error: `Unable to assign ${input.runnerId} to ${input.poolId}` };
+                return { success: true, output: JSON.stringify(pool) };
+            }
+            if (input.mode === 'unassign') {
+                if (!input.poolId || !input.runnerId)
+                    return { success: false, error: 'unassign requires poolId and runnerId.' };
+                const pool = registry.removeRunnerFromPool(input.poolId, input.runnerId);
+                if (!pool)
+                    return { success: false, error: `Unknown pool: ${input.poolId}` };
+                return { success: true, output: JSON.stringify(pool) };
+            }
+            if (input.mode === 'contracts') {
+                const contracts = registry.listContracts();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        count: contracts.length,
+                        contracts: view === 'full' ? contracts : contracts.map(summarizeContract),
+                    }),
+                };
+            }
+            if (input.mode === 'artifacts') {
+                const artifacts = registry.listArtifacts();
+                return {
+                    success: true,
+                    output: JSON.stringify({
+                        view,
+                        count: artifacts.length,
+                        artifacts: view === 'full' ? artifacts : artifacts.map(summarizeArtifact),
+                    }),
+                };
+            }
+            if (input.mode === 'review') {
+                if (!input.artifactId)
+                    return { success: false, error: 'review requires artifactId.' };
+                const summary = registry.buildReviewSummary(input.artifactId);
+                if (!summary)
+                    return { success: false, error: `Unknown artifact: ${input.artifactId}` };
+                return { success: true, output: summary };
+            }
+            if (input.mode === 'import-artifact') {
+                if (!input.path)
+                    return { success: false, error: 'import-artifact requires path.' };
+                const artifact = await registry.importArtifact(input.path);
+                return { success: true, output: JSON.stringify(artifact) };
+            }
+            return { success: false, error: `Unknown mode: ${input.mode}` };
+        },
+    };
+}

package/dist/_internal/platform/tools/repl/index.d.ts

@@ -0,0 +1,5 @@
+import { type ConfigManagerLike } from '../../runtime/sandbox/manager.js';
+import { SandboxSessionRegistry } from '../../runtime/sandbox/session-registry.js';
+import type { Tool } from '../../types/tools.js';
+export declare function createReplTool(configManager: ConfigManagerLike, sandboxSessionRegistry: SandboxSessionRegistry): Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/_internal/platform/tools/repl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/tools/repl/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAC1E,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAEnF,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AAwOjD,wBAAgB,cAAc,CAC5B,aAAa,EAAE,iBAAiB,EAChC,sBAAsB,EAAE,sBAAsB,GAC7C,IAAI,CA4EN"}

package/dist/_internal/platform/tools/repl/index.js

@@ -0,0 +1,252 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { mkdtempSync, rmSync } from 'node:fs';
+import ts from 'typescript';
+import { executeSandboxCommand } from '../../runtime/sandbox/backend.js';
+import {} from '../../runtime/sandbox/manager.js';
+import { SandboxSessionRegistry } from '../../runtime/sandbox/session-registry.js';
+import { summarizeError } from '../../utils/error-display.js';
+import { REPL_TOOL_SCHEMA } from './schema.js';
+function resolveHistoryPath(workspaceRoot) {
+    return join(workspaceRoot, '.goodvibes', 'goodvibes', 'repl-history.json');
+}
+function createLocalExecPlan(workspaceRoot) {
+    return {
+        backend: 'local',
+        command: process.env.SHELL || 'bash',
+        args: ['-lc', 'true'],
+        workspaceRoot,
+        summary: 'local process exec',
+    };
+}
+function loadHistory(historyPath) {
+    try {
+        return JSON.parse(readFileSync(historyPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+}
+function saveHistory(historyPath, entries) {
+    mkdirSync(dirname(historyPath), { recursive: true });
+    writeFileSync(historyPath, `${JSON.stringify(entries, null, 2)}\n`, 'utf-8');
+}
+function mapRuntimeToSandboxProfile(runtime) {
+    switch (runtime) {
+        case 'javascript': return 'eval-js';
+        case 'typescript': return 'eval-ts';
+        case 'python': return 'eval-py';
+        case 'sql': return 'eval-sql';
+        case 'graphql': return 'eval-graphql';
+    }
+}
+async function evalJavaScriptInSandbox(expression, bindings, launchPlan, configManager, sandboxSessionRegistry, sessionId) {
+    const payload = JSON.stringify({ expression, bindings });
+    const runner = `
+const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
+const bindings = payload.bindings ?? {};
+for (const [key, value] of Object.entries(bindings)) {
+  globalThis[key] = value;
+}
+const value = eval(payload.expression);
+process.stdout.write(typeof value === 'string' ? value : JSON.stringify(value));
+`;
+    const result = sessionId
+        ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', runner], configManager, {
+            timeoutMs: 1000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        })
+        : executeSandboxCommand(launchPlan, process.execPath, ['-e', runner], {
+            timeoutMs: 1000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || 'JavaScript eval failed.').trim());
+    }
+    return result.stdout.trim();
+}
+async function evalTypeScript(expression, bindings, configManager, sandboxSessionRegistry, launchPlan, sessionId) {
+    const transpiled = ts.transpileModule(expression, {
+        compilerOptions: {
+            target: ts.ScriptTarget.ES2022,
+            module: ts.ModuleKind.ES2022,
+        },
+    }).outputText;
+    return evalJavaScriptInSandbox(transpiled, bindings, launchPlan, configManager, sandboxSessionRegistry, sessionId);
+}
+function evalPython(expression, workspaceRoot, configManager, sandboxSessionRegistry, launchPlan, sessionId) {
+    const replTempBase = join(workspaceRoot, '.goodvibes', 'goodvibes', 'repl-temp');
+    mkdirSync(replTempBase, { recursive: true });
+    const tempRoot = mkdtempSync(join(replTempBase, 'gv-repl-py-'));
+    const venvPath = join(tempRoot, 'venv');
+    const pythonLaunchPlan = launchPlan.backend === 'local' ? {
+        ...createLocalExecPlan(tempRoot),
+        workspaceRoot: tempRoot,
+    } : launchPlan;
+    const create = sessionId
+        ? sandboxSessionRegistry.execute(sessionId, 'python3', ['-m', 'venv', venvPath], configManager, { cwd: tempRoot })
+        : executeSandboxCommand(pythonLaunchPlan, 'python3', ['-m', 'venv', venvPath], { cwd: tempRoot });
+    if (create.status !== 0) {
+        rmSync(tempRoot, { recursive: true, force: true });
+        throw new Error(create.stderr || create.stdout || 'Failed to create ephemeral Python venv.');
+    }
+    const pythonBin = join(venvPath, 'bin', 'python');
+    const run = sessionId
+        ? sandboxSessionRegistry.execute(sessionId, pythonBin, ['-I', '-S', '-c', `import json\nresult = (${expression})\nprint(json.dumps(result))`], configManager, {
+            cwd: tempRoot,
+            timeoutMs: 5000,
+        })
+        : executeSandboxCommand(pythonLaunchPlan, pythonBin, ['-I', '-S', '-c', `import json\nresult = (${expression})\nprint(json.dumps(result))`], {
+            cwd: tempRoot,
+            timeoutMs: 5000,
+        });
+    rmSync(tempRoot, { recursive: true, force: true });
+    if (run.status !== 0) {
+        throw new Error((run.stderr || run.stdout || 'Python eval failed.').trim());
+    }
+    return run.stdout.trim();
+}
+async function evalSql(expression, configManager, sandboxSessionRegistry, launchPlan, sessionId) {
+    const payload = JSON.stringify({ expression });
+    const script = `
+import { Database } from 'bun:sqlite';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
+const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
+const db = new Database(':memory:');
+db.exec("CREATE TABLE sandbox_eval (id INTEGER PRIMARY KEY, value TEXT);");
+db.exec("INSERT INTO sandbox_eval (value) VALUES ('alpha'), ('beta');");
+const rows = db.query(payload.expression).all();
+process.stdout.write(JSON.stringify(rows));
+`;
+    const result = sessionId
+        ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', script], configManager, {
+            timeoutMs: 5000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        })
+        : executeSandboxCommand(launchPlan, process.execPath, ['-e', script], {
+            timeoutMs: 5000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || 'SQL eval failed.').trim());
+    }
+    return result.stdout.trim();
+}
+function evalGraphql(expression, configManager, sandboxSessionRegistry, launchPlan, sessionId) {
+    const payload = JSON.stringify({ expression });
+    const script = `
+const payload = JSON.parse(process.env.GV_REPL_PAYLOAD ?? '{}');
+const normalized = String(payload.expression ?? '').replace(/\\s+/g, ' ').trim();
+const opMatch = normalized.match(/^(query|mutation|subscription)\\s+([A-Za-z0-9_]+)?/i);
+const fields = [...normalized.matchAll(/\\b([A-Za-z_][A-Za-z0-9_]*)\\b/g)].map((match) => match[1]).slice(0, 12);
+process.stdout.write(JSON.stringify({
+  operation: opMatch?.[1]?.toLowerCase() ?? 'query',
+  name: opMatch?.[2] ?? null,
+  fields,
+  normalized,
+}));
+`;
+    const result = sessionId
+        ? sandboxSessionRegistry.execute(sessionId, process.execPath, ['-e', script], configManager, {
+            timeoutMs: 2000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        })
+        : executeSandboxCommand(launchPlan, process.execPath, ['-e', script], {
+            timeoutMs: 2000,
+            env: {
+                ...process.env,
+                GV_REPL_PAYLOAD: payload,
+            },
+        });
+    if (result.status !== 0) {
+        throw new Error((result.stderr || result.stdout || 'GraphQL eval failed.').trim());
+    }
+    return result.stdout.trim();
+}
+export function createReplTool(configManager, sandboxSessionRegistry) {
+    return {
+        definition: {
+            name: 'repl',
+            description: 'Evaluate bounded JavaScript, TypeScript, Python, SQL, and GraphQL snippets through controlled sandbox profiles.',
+            parameters: REPL_TOOL_SCHEMA.parameters,
+            sideEffects: ['exec', 'state'],
+            concurrency: 'serial',
+        },
+        async execute(args) {
+            if (!args || typeof args !== 'object' || typeof args.mode !== 'string') {
+                return { success: false, error: 'Invalid args: mode is required.' };
+            }
+            const input = args;
+            if (!input.workspaceRoot || input.workspaceRoot.trim().length === 0) {
+                return { success: false, error: 'repl requires workspaceRoot.' };
+            }
+            const historyPath = resolveHistoryPath(input.workspaceRoot);
+            const history = loadHistory(historyPath);
+            const localExecPlan = createLocalExecPlan(input.workspaceRoot);
+            if (input.mode === 'history') {
+                return { success: true, output: JSON.stringify({ count: history.length, history }) };
+            }
+            if (!input.expression)
+                return { success: false, error: 'eval requires expression.' };
+            const runtime = input.runtime ?? 'javascript';
+            const sandboxSession = await sandboxSessionRegistry.start(mapRuntimeToSandboxProfile(runtime), `repl:${runtime}`, configManager);
+            try {
+                let rendered = '';
+                switch (runtime) {
+                    case 'javascript':
+                        rendered = await evalJavaScriptInSandbox(input.expression, input.bindings ?? {}, sandboxSession.launchPlan ?? localExecPlan, configManager, sandboxSessionRegistry, sandboxSession.id);
+                        break;
+                    case 'typescript':
+                        rendered = await evalTypeScript(input.expression, input.bindings ?? {}, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
+                        break;
+                    case 'python':
+                        rendered = evalPython(input.expression, input.workspaceRoot, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
+                        break;
+                    case 'sql':
+                        rendered = await evalSql(input.expression, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
+                        break;
+                    case 'graphql':
+                        rendered = evalGraphql(input.expression, configManager, sandboxSessionRegistry, sandboxSession.launchPlan ?? localExecPlan, sandboxSession.id);
+                        break;
+                }
+                saveHistory(historyPath, [...history, {
+                        ts: Date.now(),
+                        runtime,
+                        expression: input.expression,
+                        sessionId: sandboxSession.id,
+                        backend: sandboxSession.resolvedBackend ?? sandboxSession.backend,
+                        launchSummary: sandboxSession.launchPlan?.summary,
+                        result: rendered,
+                    }]);
+                return { success: true, output: rendered };
+            }
+            catch (error) {
+                saveHistory(historyPath, [...history, {
+                        ts: Date.now(),
+                        runtime,
+                        expression: input.expression,
+                        sessionId: sandboxSession.id,
+                        backend: sandboxSession.resolvedBackend ?? sandboxSession.backend,
+                        launchSummary: sandboxSession.launchPlan?.summary,
+                        error: summarizeError(error),
+                    }]);
+                return { success: false, error: summarizeError(error) };
+            }
+        },
+    };
+}