just-bash-mcp 2.9.4 → 3.0.0

package/src/tools/sandbox-tools.ts

@@ -9,230 +9,135 @@
  * - OutputMessage type for streaming output
  */
 
-import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import {
-	NetworkAccessDeniedError,
-	RedirectNotAllowedError,
-	SecurityViolationError,
-	TooManyRedirectsError,
-	type OutputMessage,
-} from "just-bash";
-import { z } from "zod/v4";
-import { config } from "../config/index.ts";
-import {
-	createErrorResponse,
-	createJsonResponse,
-	createSuccessResponse,
-	truncateOutput,
-} from "../utils/index.ts";
-import { getPersistentSandbox, resetPersistentSandbox } from "./bash-instance.ts";
+import type {McpServer} from '@modelcontextprotocol/sdk/server/mcp.js'
+import {NetworkAccessDeniedError, RedirectNotAllowedError, SecurityViolationError, TooManyRedirectsError, type OutputMessage} from 'just-bash'
+import {z} from 'zod/v4'
+import {config} from '../config/index.ts'
+import {createErrorResponse, createJsonResponse, createSuccessResponse, truncateOutput} from '../utils/index.ts'
+import {getPersistentSandbox, resetPersistentSandbox} from './bash-instance.ts'
 
 function classifyError(error: unknown, prefix: string) {
-	if (error instanceof NetworkAccessDeniedError) {
-		return createErrorResponse(error, `${prefix} [Network Access Denied]`);
-	}
-	if (error instanceof TooManyRedirectsError) {
-		return createErrorResponse(error, `${prefix} [Too Many Redirects]`);
-	}
-	if (error instanceof RedirectNotAllowedError) {
-		return createErrorResponse(error, `${prefix} [Redirect Not Allowed]`);
-	}
-	if (error instanceof SecurityViolationError) {
-		return createErrorResponse(error, `${prefix} [Security Violation]`);
-	}
-	return createErrorResponse(error, prefix);
+ if (error instanceof NetworkAccessDeniedError) {
+  return createErrorResponse(error, `${prefix} [Network Access Denied]`)
+ }
+ if (error instanceof TooManyRedirectsError) {
+  return createErrorResponse(error, `${prefix} [Too Many Redirects]`)
+ }
+ if (error instanceof RedirectNotAllowedError) {
+  return createErrorResponse(error, `${prefix} [Redirect Not Allowed]`)
+ }
+ if (error instanceof SecurityViolationError) {
+  return createErrorResponse(error, `${prefix} [Security Violation]`)
+ }
+ return createErrorResponse(error, prefix)
 }
 
 export function registerSandboxTools(server: McpServer): void {
-	server.registerTool(
-		"bash_sandbox_run",
-		{
-			description:
-				"Run a command in a persistent isolated environment with optional structured output and logs.",
-			inputSchema: {
-				command: z.string().describe("The command to execute"),
-				cwd: z.string().optional().describe("Working directory for the command"),
-				env: z.record(z.string(), z.string()).optional().describe("Environment variables to set"),
-				includeOutput: z
-					.boolean()
-					.optional()
-					.describe("Include structured output messages from SandboxCommand.output()"),
-				includeLogs: z
-					.boolean()
-					.optional()
-					.describe("Include execution logs from SandboxCommand.logs()"),
-			},
-		},
-		async ({
-			command,
-			cwd,
-			env,
-			includeOutput = false,
-			includeLogs = false,
-		}: {
-			command: string;
-			cwd?: string;
-			env?: Record<string, string>;
-			includeOutput?: boolean;
-			includeLogs?: boolean;
-		}) => {
-			try {
-				const sandbox = await getPersistentSandbox();
-				const cmd = await sandbox.runCommand(command, { cwd, env });
-				const result = await cmd.wait();
-				const stdout = await cmd.stdout();
-				const stderr = await cmd.stderr();
+ server.registerTool(
+  'bash_sandbox_run',
+  {
+   description: 'Run a command in a persistent isolated environment with optional structured output and logs.',
+   inputSchema: {
+    command: z.string().describe('The command to execute'),
+    cwd: z.string().optional().describe('Working directory for the command'),
+    env: z.record(z.string(), z.string()).optional().describe('Environment variables to set'),
+    includeOutput: z.boolean().optional().describe('Include structured output messages from SandboxCommand.output()'),
+    includeLogs: z.boolean().optional().describe('Include execution logs from SandboxCommand.logs()')
+   }
+  },
+  async ({command, cwd, env, includeOutput = false, includeLogs = false}: {command: string; cwd?: string; env?: Record<string, string>; includeOutput?: boolean; includeLogs?: boolean}) => {
+   try {
+    const sandbox = await getPersistentSandbox()
+    const cmd = await sandbox.runCommand(command, {cwd, env})
+    const result = await cmd.wait()
+    const stdout = await cmd.stdout()
+    const stderr = await cmd.stderr()
 
-				const response: {
-					stdout: string;
-					stderr: string;
-					exitCode: number;
-					output?: string;
-					logs?: OutputMessage[];
-				} = {
-					stdout: truncateOutput(stdout, config.MAX_OUTPUT_LENGTH, "stdout"),
-					stderr: truncateOutput(stderr, config.MAX_OUTPUT_LENGTH, "stderr"),
-					exitCode: result.exitCode,
-				};
+    const response: {stdout: string; stderr: string; exitCode: number; output?: string; logs?: OutputMessage[]} = {stdout: truncateOutput(stdout, config.MAX_OUTPUT_LENGTH, 'stdout'), stderr: truncateOutput(stderr, config.MAX_OUTPUT_LENGTH, 'stderr'), exitCode: result.exitCode}
 
-				if (includeOutput) {
-					response.output = truncateOutput(await cmd.output(), config.MAX_OUTPUT_LENGTH, "stdout");
-				}
-				if (includeLogs) {
-					const logs: OutputMessage[] = [];
-					for await (const message of cmd.logs()) {
-						logs.push(message);
-					}
-					response.logs = logs;
-				}
+    if (includeOutput) {
+     response.output = truncateOutput(await cmd.output(), config.MAX_OUTPUT_LENGTH, 'stdout')
+    }
+    if (includeLogs) {
+     const logs: OutputMessage[] = []
+     for await (const message of cmd.logs()) {
+      logs.push(message)
+     }
+     response.logs = logs
+    }
 
-				return createJsonResponse(response, result.exitCode !== 0);
-			} catch (error) {
-				return classifyError(error, "Sandbox error");
-			}
-		},
-	);
+    return createJsonResponse(response, result.exitCode !== 0)
+   } catch (error) {
+    return classifyError(error, 'Sandbox error')
+   }
+  }
+ )
 
-	server.registerTool(
-		"bash_sandbox_domain",
-		{
-			description: "Get the current sandbox domain or identifier.",
-			inputSchema: {},
-		},
-		async () => {
-			try {
-				const sandbox = await getPersistentSandbox();
-				return createJsonResponse({ domain: sandbox.domain });
-			} catch (error) {
-				return classifyError(error, "Domain error");
-			}
-		},
-	);
+ server.registerTool('bash_sandbox_domain', {description: 'Get the current sandbox domain or identifier.', inputSchema: {}}, async () => {
+  try {
+   const sandbox = await getPersistentSandbox()
+   return createJsonResponse({domain: sandbox.domain})
+  } catch (error) {
+   return classifyError(error, 'Domain error')
+  }
+ })
 
-	server.registerTool(
-		"bash_sandbox_write_files",
-		{
-			description: "Write multiple files to the persistent isolated environment at once.",
-			inputSchema: {
-				files: z.record(z.string(), z.string()).describe("Files to write (path -> content)"),
-			},
-		},
-		async ({ files }: { files: Record<string, string> }) => {
-			try {
-				const sandbox = await getPersistentSandbox();
-				await sandbox.writeFiles(files);
+ server.registerTool('bash_sandbox_write_files', {description: 'Write multiple files to the persistent isolated environment at once.', inputSchema: {files: z.record(z.string(), z.string()).describe('Files to write (path -> content)')}}, async ({files}: {files: Record<string, string>}) => {
+  try {
+   const sandbox = await getPersistentSandbox()
+   await sandbox.writeFiles(files)
 
-				return createSuccessResponse(
-					`Successfully wrote ${Object.keys(files).length} file(s): ${Object.keys(files).join(", ")}`,
-				);
-			} catch (error) {
-				return classifyError(error, "Write error");
-			}
-		},
-	);
+   return createSuccessResponse(`Successfully wrote ${Object.keys(files).length} file(s): ${Object.keys(files).join(', ')}`)
+  } catch (error) {
+   return classifyError(error, 'Write error')
+  }
+ })
 
-	server.registerTool(
-		"bash_sandbox_read_file",
-		{
-			description: "Read a file from the persistent isolated environment.",
-			inputSchema: {
-				path: z.string().describe("The file path to read"),
-				encoding: z.enum(["utf-8", "base64"]).optional().describe("File encoding (default: utf-8)"),
-			},
-		},
-		async ({ path, encoding = "utf-8" }: { path: string; encoding?: "utf-8" | "base64" }) => {
-			try {
-				const sandbox = await getPersistentSandbox();
-				const content = await sandbox.readFile(path, encoding);
+ server.registerTool(
+  'bash_sandbox_read_file',
+  {description: 'Read a file from the persistent isolated environment.', inputSchema: {path: z.string().describe('The file path to read'), encoding: z.enum(['utf-8', 'base64']).optional().describe('File encoding (default: utf-8)')}},
+  async ({path, encoding = 'utf-8'}: {path: string; encoding?: 'utf-8' | 'base64'}) => {
+   try {
+    const sandbox = await getPersistentSandbox()
+    const content = await sandbox.readFile(path, encoding)
 
-				return {
-					content: [
-						{
-							type: "text" as const,
-							text: truncateOutput(content, config.MAX_OUTPUT_LENGTH, "stdout"),
-						},
-					],
-				};
-			} catch (error) {
-				return classifyError(error, "Read error");
-			}
-		},
-	);
+    return {content: [{type: 'text' as const, text: truncateOutput(content, config.MAX_OUTPUT_LENGTH, 'stdout')}]}
+   } catch (error) {
+    return classifyError(error, 'Read error')
+   }
+  }
+ )
 
-	server.registerTool(
-		"bash_sandbox_mkdir",
-		{
-			description: "Create a directory in the persistent isolated environment.",
-			inputSchema: {
-				path: z.string().describe("The directory path to create"),
-				recursive: z
-					.boolean()
-					.optional()
-					.describe("Create parent directories if needed (default: true)"),
-			},
-		},
-		async ({ path, recursive = true }: { path: string; recursive?: boolean }) => {
-			try {
-				const sandbox = await getPersistentSandbox();
-				await sandbox.mkDir(path, { recursive });
+ server.registerTool(
+  'bash_sandbox_mkdir',
+  {description: 'Create a directory in the persistent isolated environment.', inputSchema: {path: z.string().describe('The directory path to create'), recursive: z.boolean().optional().describe('Create parent directories if needed (default: true)')}},
+  async ({path, recursive = true}: {path: string; recursive?: boolean}) => {
+   try {
+    const sandbox = await getPersistentSandbox()
+    await sandbox.mkDir(path, {recursive})
 
-				return createSuccessResponse(`Successfully created directory: ${path}`);
-			} catch (error) {
-				return classifyError(error, "Mkdir error");
-			}
-		},
-	);
+    return createSuccessResponse(`Successfully created directory: ${path}`)
+   } catch (error) {
+    return classifyError(error, 'Mkdir error')
+   }
+  }
+ )
 
-	server.registerTool(
-		"bash_sandbox_stop",
-		{
-			description:
-				"Stop and clean up the persistent isolated environment, releasing all resources. Use bash_sandbox_reset to just clear state.",
-			inputSchema: {},
-		},
-		async () => {
-			try {
-				await resetPersistentSandbox();
-				return createSuccessResponse("Sandbox environment has been stopped and cleaned up.");
-			} catch (error) {
-				return classifyError(error, "Stop error");
-			}
-		},
-	);
+ server.registerTool('bash_sandbox_stop', {description: 'Stop and clean up the persistent isolated environment, releasing all resources. Use bash_sandbox_reset to just clear state.', inputSchema: {}}, async () => {
+  try {
+   await resetPersistentSandbox()
+   return createSuccessResponse('Sandbox environment has been stopped and cleaned up.')
+  } catch (error) {
+   return classifyError(error, 'Stop error')
+  }
+ })
 
-	server.registerTool(
-		"bash_sandbox_reset",
-		{
-			description: "Reset the persistent isolated environment, clearing all files and state.",
-			inputSchema: {},
-		},
-		async () => {
-			try {
-				await resetPersistentSandbox();
-				return createSuccessResponse("Sandbox environment has been reset.");
-			} catch (error) {
-				return classifyError(error, "Reset error");
-			}
-		},
-	);
+ server.registerTool('bash_sandbox_reset', {description: 'Reset the persistent isolated environment, clearing all files and state.', inputSchema: {}}, async () => {
+  try {
+   await resetPersistentSandbox()
+   return createSuccessResponse('Sandbox environment has been reset.')
+  } catch (error) {
+   return classifyError(error, 'Reset error')
+  }
+ })
 }

package/src/types.ts

@@ -4,4 +4,4 @@
  * Keeping this as a wildcard export guarantees this wrapper stays 1:1 with
  * whatever the installed just-bash version exposes.
  */
-export * from "just-bash";
+export * from 'just-bash'

package/src/utils/index.ts

@@ -2,83 +2,48 @@
  * Utility functions for just-bash-mcp
  */
 
-import { config } from "../config/index.ts";
+import {config} from '../config/index.ts'
 
 /**
  * Truncate output to maximum length with notification message
  */
-export function truncateOutput(
-	output: string,
-	maxLength: number,
-	streamName: "stdout" | "stderr",
-): string {
-	if (output.length <= maxLength) {
-		return output;
-	}
-	const truncatedLength = output.length - maxLength;
-	return `${output.slice(0, maxLength)}\n\n[${streamName} truncated: ${truncatedLength} characters removed]`;
+export function truncateOutput(output: string, maxLength: number, streamName: 'stdout' | 'stderr'): string {
+ if (output.length <= maxLength) {
+  return output
+ }
+ const truncatedLength = output.length - maxLength
+ return `${output.slice(0, maxLength)}\n\n[${streamName} truncated: ${truncatedLength} characters removed]`
 }
 
 /**
  * Create a successful MCP tool response
  */
-export function createSuccessResponse(text: string): {
-	content: Array<{ type: "text"; text: string }>;
-} {
-	return {
-		content: [{ type: "text" as const, text }],
-	};
+export function createSuccessResponse(text: string): {content: Array<{type: 'text'; text: string}>} {
+ return {content: [{type: 'text' as const, text}]}
 }
 
 /**
  * Create an error MCP tool response
  */
-export function createErrorResponse(
-	error: unknown,
-	prefix = "Error",
-): { content: Array<{ type: "text"; text: string }>; isError: true } {
-	const message = error instanceof Error ? error.message : String(error);
-	return {
-		content: [{ type: "text" as const, text: `${prefix}: ${message}` }],
-		isError: true,
-	};
+export function createErrorResponse(error: unknown, prefix = 'Error'): {content: Array<{type: 'text'; text: string}>; isError: true} {
+ const message = error instanceof Error ? error.message : String(error)
+ return {content: [{type: 'text' as const, text: `${prefix}: ${message}`}], isError: true}
 }
 
 /**
  * Create a JSON MCP tool response
  */
-export function createJsonResponse(
-	data: unknown,
-	isError = false,
-): { content: Array<{ type: "text"; text: string }>; isError?: boolean } {
-	const response: {
-		content: Array<{ type: "text"; text: string }>;
-		isError?: boolean;
-	} = {
-		content: [{ type: "text" as const, text: JSON.stringify(data, null, 2) }],
-	};
-	if (isError) {
-		response.isError = true;
-	}
-	return response;
+export function createJsonResponse(data: unknown, isError = false): {content: Array<{type: 'text'; text: string}>; isError?: boolean} {
+ const response: {content: Array<{type: 'text'; text: string}>; isError?: boolean} = {content: [{type: 'text' as const, text: JSON.stringify(data, null, 2)}]}
+ if (isError) {
+  response.isError = true
+ }
+ return response
 }
 
 /**
  * Format bash execution result for MCP response
  */
-export function formatExecResult(result: {
-	stdout: string;
-	stderr: string;
-	exitCode: number;
-	env?: Record<string, string>;
-}): { content: Array<{ type: "text"; text: string }>; isError?: boolean } {
-	return createJsonResponse(
-		{
-			stdout: truncateOutput(result.stdout, config.MAX_OUTPUT_LENGTH, "stdout"),
-			stderr: truncateOutput(result.stderr, config.MAX_OUTPUT_LENGTH, "stderr"),
-			exitCode: result.exitCode,
-			...(result.env && { env: result.env }),
-		},
-		result.exitCode !== 0,
-	);
+export function formatExecResult(result: {stdout: string; stderr: string; exitCode: number; env?: Record<string, string>}): {content: Array<{type: 'text'; text: string}>; isError?: boolean} {
+ return createJsonResponse({stdout: truncateOutput(result.stdout, config.MAX_OUTPUT_LENGTH, 'stdout'), stderr: truncateOutput(result.stderr, config.MAX_OUTPUT_LENGTH, 'stderr'), exitCode: result.exitCode, ...(result.env && {env: result.env})}, result.exitCode !== 0)
 }