@computesdk/just-bash 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 computesdk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,387 @@
+# @computesdk/just-bash
+
+[just-bash](https://justbash.dev/) provider for ComputeSDK - Local sandboxed bash execution with a virtual filesystem. No external services, containers, or authentication required.
+
+## Installation
+
+```bash
+npm install @computesdk/just-bash
+```
+
+## Quick Start
+
+### Gateway Mode (Recommended)
+
+Use the gateway for zero-config auto-detection:
+
+```typescript
+import { compute } from 'computesdk';
+
+// just-bash is always available - no credentials needed
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCode('echo "Hello from just-bash!"');
+console.log(result.output); // "Hello from just-bash!"
+
+await sandbox.destroy();
+```
+
+### Direct Mode
+
+For direct SDK usage without the gateway:
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+
+const compute = justBash({});
+
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCommand('echo "Hello" | tr a-z A-Z');
+console.log(result.stdout); // "HELLO"
+
+await sandbox.destroy();
+```
+
+## Configuration
+
+### Environment Variables
+
+No environment variables are required. just-bash runs entirely locally.
+
+### Configuration Options
+
+```typescript
+interface JustBashConfig {
+  /** Enable Python support via pyodide (disabled by default) */
+  python?: boolean;
+  /** Initial files to populate in the virtual filesystem */
+  files?: Record<string, string>;
+  /** Initial environment variables */
+  env?: Record<string, string>;
+  /** Working directory (defaults to /home/user) */
+  cwd?: string;
+  /** Custom filesystem implementation (see Filesystem Backends below) */
+  fs?: IFileSystem;
+  /** Custom commands created with defineCommand() (see Custom Commands below) */
+  customCommands?: CustomCommand[];
+  /** Network configuration for curl (disabled by default) */
+  network?: NetworkConfig;
+}
+```
+
+## Filesystem Backends
+
+By default, just-bash uses an **InMemoryFs** — a pure in-memory filesystem. You can swap in alternative backends depending on your use case:
+
+### InMemoryFs (default)
+
+All files live in memory. Fast, deterministic, fully isolated.
+
+```typescript
+const compute = justBash({}); // InMemoryFs is the default
+```
+
+### OverlayFs (copy-on-write)
+
+Reads from a real directory on disk; writes stay in memory. The underlying directory is never modified.
+
+```typescript
+import { OverlayFs } from 'just-bash';
+
+const compute = justBash({
+  fs: new OverlayFs({ root: '/path/to/project' }),
+  cwd: '/path/to/project',
+});
+```
+
+### ReadWriteFs (direct disk access)
+
+Reads and writes go directly to a real directory. Use with caution — changes are real.
+
+```typescript
+import { ReadWriteFs } from 'just-bash';
+
+const compute = justBash({
+  fs: new ReadWriteFs({ root: '/tmp/sandbox' }),
+});
+```
+
+### MountableFs (compose multiple filesystems)
+
+Mount different filesystem backends at different paths.
+
+```typescript
+import { MountableFs, InMemoryFs } from 'just-bash';
+import { OverlayFs } from 'just-bash';
+
+const compute = justBash({
+  fs: new MountableFs({
+    base: new InMemoryFs(),
+    mounts: [
+      { mountPoint: '/project', filesystem: new OverlayFs({ root: '/real/project' }) },
+    ],
+  }),
+  cwd: '/project',
+});
+```
+
+## Custom Commands
+
+You can extend just-bash with custom commands using `defineCommand()`:
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+import { defineCommand } from 'just-bash';
+
+const hello = defineCommand('hello', async (args, ctx) => {
+  const name = args[0] || 'world';
+  return {
+    stdout: `Hello, ${name}!\n`,
+    stderr: '',
+    exitCode: 0,
+  };
+});
+
+const compute = justBash({ customCommands: [hello] });
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCommand('hello Alice');
+console.log(result.stdout); // "Hello, Alice!\n"
+```
+
+Custom commands receive a context object (`ctx`) with access to:
+- `ctx.fs` — the virtual filesystem
+- `ctx.cwd` — current working directory
+- `ctx.env` — environment variables
+- `ctx.stdin` — standard input
+- `ctx.exec(command)` — run subcommands
+
+## API Reference
+
+### Code Execution
+
+```typescript
+// Execute bash scripts
+const result = await sandbox.runCode(`
+  for i in 1 2 3; do
+    echo "Number: $i"
+  done
+`);
+console.log(result.output);
+// Number: 1
+// Number: 2
+// Number: 3
+
+// Execute Python code (requires python: true in config)
+const compute = justBash({ python: true });
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCode(`
+import json
+data = {"message": "Hello from Python"}
+print(json.dumps(data))
+`, 'python');
+```
+
+### Command Execution
+
+```typescript
+// Pipes and text processing
+const result = await sandbox.runCommand('echo -e "banana\\napple\\ncherry" | sort');
+console.log(result.stdout); // "apple\nbanana\ncherry\n"
+
+// JSON processing with jq
+await sandbox.filesystem.writeFile('/data.json', '[{"name":"Alice"},{"name":"Bob"}]');
+const result = await sandbox.runCommand('cat /data.json | jq ".[].name"');
+
+// Environment variables per command
+const result = await sandbox.runCommand('echo $MY_VAR', { env: { MY_VAR: 'hello' } });
+
+// Working directory per command
+const result = await sandbox.runCommand('cat config.json', { cwd: '/app' });
+```
+
+### Filesystem Operations
+
+```typescript
+// Write file
+await sandbox.filesystem.writeFile('/tmp/hello.txt', 'Hello World');
+
+// Read file
+const content = await sandbox.filesystem.readFile('/tmp/hello.txt');
+
+// Create directory
+await sandbox.filesystem.mkdir('/tmp/data');
+
+// List directory contents
+const files = await sandbox.filesystem.readdir('/tmp');
+
+// Check if file exists
+const exists = await sandbox.filesystem.exists('/tmp/hello.txt');
+
+// Remove file or directory
+await sandbox.filesystem.remove('/tmp/hello.txt');
+```
+
+### Sandbox Management
+
+```typescript
+// Get sandbox info
+const info = await sandbox.getInfo();
+console.log(info.id, info.provider, info.status);
+
+// List all active sandboxes
+const sandboxes = await compute.sandbox.list();
+
+// Get sandbox by ID
+const existing = await compute.sandbox.getById('sandbox-id');
+
+// Destroy sandbox
+await sandbox.destroy();
+```
+
+### Pre-populated Files
+
+```typescript
+const compute = justBash({
+  files: {
+    '/app/config.json': '{"port": 3000}',
+    '/app/data.csv': 'name,age\nAlice,25\nBob,30',
+  },
+  env: {
+    APP_ENV: 'production',
+  },
+  cwd: '/app',
+});
+
+const sandbox = await compute.sandbox.create();
+const result = await sandbox.runCommand('cat config.json');
+console.log(result.stdout); // {"port": 3000}
+```
+
+## Built-in Commands
+
+just-bash includes 60+ built-in commands:
+
+| Category | Commands |
+|----------|----------|
+| **File ops** | `cat`, `cp`, `ls`, `mkdir`, `mv`, `rm`, `touch`, `tree`, `ln`, `find` |
+| **Text processing** | `awk`, `grep`, `sed`, `cut`, `sort`, `uniq`, `wc`, `head`, `tail`, `tr` |
+| **Data processing** | `jq` (JSON), `yq` (YAML/XML), `sqlite3` (SQLite), CSV tools |
+| **Compression** | `gzip`, `tar` |
+| **Utilities** | `echo`, `printf`, `date`, `seq`, `timeout`, `basename`, `dirname` |
+| **Shell** | `export`, `source`, `alias`, `test`, `read`, `set`, `unset` |
+
+## Error Handling
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+
+const compute = justBash({});
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCommand('cat /nonexistent');
+if (result.exitCode !== 0) {
+  console.error('Command failed:', result.stderr);
+}
+
+// getUrl throws since just-bash has no network
+try {
+  await sandbox.getUrl({ port: 3000 });
+} catch (error) {
+  console.error(error.message); // "just-bash is a local sandbox without network capabilities..."
+}
+```
+
+## Examples
+
+### Data Pipeline
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+
+const compute = justBash({});
+const sandbox = await compute.sandbox.create();
+
+// Create CSV data
+await sandbox.filesystem.writeFile('/data/sales.csv',
+  'product,quantity,price\nWidget,100,9.99\nGadget,50,24.99\nDoohickey,200,4.99'
+);
+
+// Process with awk
+const result = await sandbox.runCommand(
+  'cat /data/sales.csv | tail -n +2 | awk -F, \'{ total += $2 * $3 } END { printf "Total revenue: $%.2f\\n", total }\''
+);
+console.log(result.stdout); // Total revenue: $3247.50
+
+await sandbox.destroy();
+```
+
+### JSON Processing
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+
+const compute = justBash({
+  files: {
+    '/data/users.json': JSON.stringify([
+      { name: 'Alice', age: 30, role: 'admin' },
+      { name: 'Bob', age: 25, role: 'user' },
+      { name: 'Charlie', age: 35, role: 'admin' },
+    ]),
+  },
+});
+const sandbox = await compute.sandbox.create();
+
+// Filter admins and extract names
+const result = await sandbox.runCommand(
+  'cat /data/users.json | jq \'[.[] | select(.role == "admin") | .name]\''
+);
+console.log(result.stdout); // ["Alice", "Charlie"]
+
+await sandbox.destroy();
+```
+
+### Script Execution
+
+```typescript
+import { justBash } from '@computesdk/just-bash';
+
+const compute = justBash({});
+const sandbox = await compute.sandbox.create();
+
+const result = await sandbox.runCode(`
+#!/bin/bash
+count=0
+for f in /proc/self/status /etc/hostname; do
+  if test -f "$f"; then
+    count=$((count + 1))
+  fi
+done
+echo "Found $count system files"
+`);
+
+console.log(result.output);
+
+await sandbox.destroy();
+```
+
+## Limitations
+
+- **No Network Access** - `getUrl()` is not supported; `curl` requires explicit `network` config
+- **No Real Processes** - Commands are interpreted in TypeScript, not executed as real OS processes
+- **No Node.js Runtime** - `runCode` with `node` runtime executes as bash, not actual Node.js
+- **In-Memory by Default** - Files don't persist unless you use `OverlayFs`, `ReadWriteFs`, or `MountableFs`
+- **Python via Pyodide** - Python support requires `python: true` and uses pyodide (WebAssembly-based)
+
+## When to Use just-bash
+
+- **Testing & Development** - Fast, no-cost sandbox for development and CI
+- **AI Agent Tools** - Secure bash execution for AI code generation
+- **Offline Environments** - No network or API keys required
+- **Unit Tests** - Deterministic, isolated test environments
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,48 @@
+import * as _computesdk_provider from '@computesdk/provider';
+import { Bash, BashOptions } from 'just-bash';
+
+/**
+ * just-bash-specific configuration options
+ */
+interface JustBashConfig {
+    /** Enable Python support via pyodide (disabled by default) */
+    python?: boolean;
+    /** Initial files to populate in the virtual filesystem */
+    files?: BashOptions['files'];
+    /** Initial environment variables */
+    env?: Record<string, string>;
+    /** Working directory (defaults to /home/user) */
+    cwd?: string;
+    /**
+     * Custom filesystem implementation.
+     * Defaults to InMemoryFs. Use OverlayFs for copy-on-write over a real directory,
+     * ReadWriteFs for direct disk access, or MountableFs to combine multiple filesystems.
+     */
+    fs?: BashOptions['fs'];
+    /**
+     * Custom commands to register alongside built-in commands.
+     * Created with `defineCommand()` from just-bash.
+     */
+    customCommands?: BashOptions['customCommands'];
+    /** Network configuration for commands like curl */
+    network?: BashOptions['network'];
+}
+/** Internal sandbox state */
+interface JustBashSandbox {
+    bash: Bash;
+    id: string;
+    createdAt: Date;
+    config: JustBashConfig;
+}
+/**
+ * Create a just-bash provider instance using the factory pattern
+ *
+ * just-bash provides local sandboxed bash execution with:
+ * - Virtual filesystem (in-memory)
+ * - 60+ built-in commands (cat, grep, sed, awk, jq, etc.)
+ * - Python support via pyodide
+ * - No external dependencies or authentication required
+ */
+declare const justBash: (config: JustBashConfig) => _computesdk_provider.Provider<JustBashSandbox, any, any>;
+
+export { type JustBashConfig, type JustBashSandbox, justBash };

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+import * as _computesdk_provider from '@computesdk/provider';
+import { Bash, BashOptions } from 'just-bash';
+
+/**
+ * just-bash-specific configuration options
+ */
+interface JustBashConfig {
+    /** Enable Python support via pyodide (disabled by default) */
+    python?: boolean;
+    /** Initial files to populate in the virtual filesystem */
+    files?: BashOptions['files'];
+    /** Initial environment variables */
+    env?: Record<string, string>;
+    /** Working directory (defaults to /home/user) */
+    cwd?: string;
+    /**
+     * Custom filesystem implementation.
+     * Defaults to InMemoryFs. Use OverlayFs for copy-on-write over a real directory,
+     * ReadWriteFs for direct disk access, or MountableFs to combine multiple filesystems.
+     */
+    fs?: BashOptions['fs'];
+    /**
+     * Custom commands to register alongside built-in commands.
+     * Created with `defineCommand()` from just-bash.
+     */
+    customCommands?: BashOptions['customCommands'];
+    /** Network configuration for commands like curl */
+    network?: BashOptions['network'];
+}
+/** Internal sandbox state */
+interface JustBashSandbox {
+    bash: Bash;
+    id: string;
+    createdAt: Date;
+    config: JustBashConfig;
+}
+/**
+ * Create a just-bash provider instance using the factory pattern
+ *
+ * just-bash provides local sandboxed bash execution with:
+ * - Virtual filesystem (in-memory)
+ * - 60+ built-in commands (cat, grep, sed, awk, jq, etc.)
+ * - Python support via pyodide
+ * - No external dependencies or authentication required
+ */
+declare const justBash: (config: JustBashConfig) => _computesdk_provider.Provider<JustBashSandbox, any, any>;
+
+export { type JustBashConfig, type JustBashSandbox, justBash };

package/dist/index.js

@@ -0,0 +1,236 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  justBash: () => justBash
+});
+module.exports = __toCommonJS(index_exports);
+var import_just_bash = require("just-bash");
+var import_provider = require("@computesdk/provider");
+var activeSandboxes = /* @__PURE__ */ new Map();
+var justBash = (0, import_provider.defineProvider)({
+  name: "just-bash",
+  methods: {
+    sandbox: {
+      /**
+       * Create a new just-bash sandbox
+       */
+      create: async (config, options) => {
+        const sandboxId = options?.sandboxId || `just-bash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        if (options?.sandboxId && activeSandboxes.has(options.sandboxId)) {
+          const existing = activeSandboxes.get(options.sandboxId);
+          return { sandbox: existing, sandboxId: existing.id };
+        }
+        const bash = new import_just_bash.Bash({
+          files: config.files,
+          env: {
+            ...config.env,
+            ...options?.envs
+          },
+          cwd: config.cwd || "/home/user",
+          python: config.python ?? options?.runtime === "python",
+          fs: config.fs,
+          customCommands: config.customCommands,
+          network: config.network
+        });
+        const sandbox = {
+          bash,
+          id: sandboxId,
+          createdAt: /* @__PURE__ */ new Date(),
+          config
+        };
+        activeSandboxes.set(sandboxId, sandbox);
+        return { sandbox, sandboxId };
+      },
+      /**
+       * Get an existing just-bash sandbox by ID
+       */
+      getById: async (_config, sandboxId) => {
+        const sandbox = activeSandboxes.get(sandboxId);
+        if (!sandbox) return null;
+        return { sandbox, sandboxId };
+      },
+      /**
+       * List all active just-bash sandboxes
+       */
+      list: async (_config) => {
+        return Array.from(activeSandboxes.entries()).map(([sandboxId, sandbox]) => ({
+          sandbox,
+          sandboxId
+        }));
+      },
+      /**
+       * Destroy a just-bash sandbox
+       */
+      destroy: async (_config, sandboxId) => {
+        activeSandboxes.delete(sandboxId);
+      },
+      /**
+       * Execute code in the sandbox
+       *
+       * For Python: executes via the built-in python3 command (pyodide)
+       * For Node/JS: wraps code in a bash script that evaluates it
+       */
+      runCode: async (sandbox, code, runtime) => {
+        const effectiveRuntime = runtime || (code.includes("print(") || code.includes("import ") || code.includes("def ") || code.includes("sys.") || code.includes("json.") || code.includes("__") || code.includes('f"') || code.includes("f'") || code.includes("raise ") ? "python" : "node");
+        let result;
+        if (effectiveRuntime === "python") {
+          const tempFile = `/tmp/_computesdk_run_${Date.now()}.py`;
+          await sandbox.bash.writeFile(tempFile, code);
+          result = await sandbox.bash.exec(`python3 ${tempFile}`);
+        } else {
+          const tempFile = `/tmp/_computesdk_run_${Date.now()}.sh`;
+          await sandbox.bash.writeFile(tempFile, code);
+          result = await sandbox.bash.exec(`bash ${tempFile}`);
+        }
+        const output = result.stderr ? `${result.stdout}${result.stdout && result.stderr ? "\n" : ""}${result.stderr}` : result.stdout;
+        return {
+          output,
+          exitCode: result.exitCode,
+          language: effectiveRuntime
+        };
+      },
+      /**
+       * Execute a shell command in the sandbox
+       */
+      runCommand: async (sandbox, command, options) => {
+        const startTime = Date.now();
+        try {
+          const execOptions = {};
+          if (options?.env && Object.keys(options.env).length > 0) {
+            execOptions.env = options.env;
+          }
+          if (options?.cwd) {
+            execOptions.cwd = options.cwd;
+          }
+          const result = await sandbox.bash.exec(
+            command,
+            Object.keys(execOptions).length > 0 ? execOptions : void 0
+          );
+          return {
+            stdout: result.stdout || "",
+            stderr: result.stderr || "",
+            exitCode: result.exitCode,
+            durationMs: Date.now() - startTime
+          };
+        } catch (error) {
+          return {
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            exitCode: 127,
+            durationMs: Date.now() - startTime
+          };
+        }
+      },
+      /**
+       * Get sandbox information
+       */
+      getInfo: async (sandbox) => {
+        return {
+          id: sandbox.id,
+          provider: "just-bash",
+          runtime: sandbox.config.python ? "python" : "node",
+          status: "running",
+          createdAt: sandbox.createdAt,
+          timeout: 0,
+          // No timeout - local execution
+          metadata: {
+            type: "local",
+            cwd: sandbox.bash.getCwd()
+          }
+        };
+      },
+      /**
+       * Get URL for a port - not supported for local execution
+       */
+      getUrl: async (_sandbox, options) => {
+        throw new Error(
+          `just-bash is a local sandbox without network capabilities. Cannot expose port ${options.port}.`
+        );
+      },
+      /**
+       * Filesystem operations using the just-bash virtual filesystem
+       */
+      filesystem: {
+        readFile: async (sandbox, path, _runCommand) => {
+          return sandbox.bash.readFile(path);
+        },
+        writeFile: async (sandbox, path, content, _runCommand) => {
+          const parentDir = path.substring(0, path.lastIndexOf("/")) || "/";
+          if (parentDir !== "/") {
+            await sandbox.bash.exec(`mkdir -p ${parentDir}`);
+          }
+          await sandbox.bash.writeFile(path, content);
+        },
+        mkdir: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`mkdir -p ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
+          }
+        },
+        readdir: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`ls -la ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
+          }
+          const entries = [];
+          const lines = result.stdout.trim().split("\n");
+          for (const line of lines) {
+            if (!line || line.startsWith("total")) continue;
+            const parts = line.split(/\s+/);
+            if (parts.length < 9) continue;
+            const permissions = parts[0];
+            const name = parts.slice(8).join(" ");
+            if (name === "." || name === "..") continue;
+            entries.push({
+              name,
+              type: permissions.startsWith("d") ? "directory" : "file",
+              size: parseInt(parts[4], 10) || 0,
+              modified: /* @__PURE__ */ new Date()
+            });
+          }
+          return entries;
+        },
+        exists: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`test -f ${path} || test -d ${path}`);
+          return result.exitCode === 0;
+        },
+        remove: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`rm -rf ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to remove ${path}: ${result.stderr}`);
+          }
+        }
+      },
+      /**
+       * Get the native JustBashSandbox instance for advanced usage
+       */
+      getInstance: (sandbox) => {
+        return sandbox;
+      }
+    }
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  justBash
+});
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * just-bash Provider - Factory-based Implementation\n *\n * Local sandboxed bash execution using the just-bash package.\n * Provides a virtual filesystem and bash shell environment\n * without requiring any external services or containers.\n *\n * Features:\n * - Pure TypeScript bash interpreter (no real processes)\n * - In-memory virtual filesystem\n * - Python support via pyodide (optional)\n * - Shell command execution with 60+ built-in commands\n * - No authentication required - runs entirely locally\n */\n\nimport { Bash } from 'just-bash';\nimport type { BashExecResult, BashOptions } from 'just-bash';\nimport { defineProvider } from '@computesdk/provider';\nimport type {\n  CodeResult,\n  CommandResult,\n  SandboxInfo,\n  Runtime,\n  CreateSandboxOptions,\n  FileEntry,\n  RunCommandOptions,\n} from 'computesdk';\n\n/**\n * just-bash-specific configuration options\n */\nexport interface JustBashConfig {\n  /** Enable Python support via pyodide (disabled by default) */\n  python?: boolean;\n  /** Initial files to populate in the virtual filesystem */\n  files?: BashOptions['files'];\n  /** Initial environment variables */\n  env?: Record<string, string>;\n  /** Working directory (defaults to /home/user) */\n  cwd?: string;\n  /**\n   * Custom filesystem implementation.\n   * Defaults to InMemoryFs. Use OverlayFs for copy-on-write over a real directory,\n   * ReadWriteFs for direct disk access, or MountableFs to combine multiple filesystems.\n   */\n  fs?: BashOptions['fs'];\n  /**\n   * Custom commands to register alongside built-in commands.\n   * Created with `defineCommand()` from just-bash.\n   */\n  customCommands?: BashOptions['customCommands'];\n  /** Network configuration for commands like curl */\n  network?: BashOptions['network'];\n}\n\n/** Internal sandbox state */\ninterface JustBashSandbox {\n  bash: Bash;\n  id: string;\n  createdAt: Date;\n  config: JustBashConfig;\n}\n\n/** Active sandboxes registry */\nconst activeSandboxes = new Map<string, JustBashSandbox>();\n\n/**\n * Create a just-bash provider instance using the factory pattern\n *\n * just-bash provides local sandboxed bash execution with:\n * - Virtual filesystem (in-memory)\n * - 60+ built-in commands (cat, grep, sed, awk, jq, etc.)\n * - Python support via pyodide\n * - No external dependencies or authentication required\n */\nexport const justBash = defineProvider<JustBashSandbox, JustBashConfig>({\n  name: 'just-bash',\n  methods: {\n    sandbox: {\n      /**\n       * Create a new just-bash sandbox\n       */\n      create: async (config: JustBashConfig, options?: CreateSandboxOptions) => {\n        const sandboxId = options?.sandboxId || `just-bash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n\n        // Check if reconnecting to existing sandbox\n        if (options?.sandboxId && activeSandboxes.has(options.sandboxId)) {\n          const existing = activeSandboxes.get(options.sandboxId)!;\n          return { sandbox: existing, sandboxId: existing.id };\n        }\n\n        const bash = new Bash({\n          files: config.files,\n          env: {\n            ...config.env,\n            ...options?.envs,\n          },\n          cwd: config.cwd || '/home/user',\n          python: config.python ?? (options?.runtime === 'python'),\n          fs: config.fs,\n          customCommands: config.customCommands,\n          network: config.network,\n        });\n\n        const sandbox: JustBashSandbox = {\n          bash,\n          id: sandboxId,\n          createdAt: new Date(),\n          config,\n        };\n\n        activeSandboxes.set(sandboxId, sandbox);\n        return { sandbox, sandboxId };\n      },\n\n      /**\n       * Get an existing just-bash sandbox by ID\n       */\n      getById: async (_config: JustBashConfig, sandboxId: string) => {\n        const sandbox = activeSandboxes.get(sandboxId);\n        if (!sandbox) return null;\n        return { sandbox, sandboxId };\n      },\n\n      /**\n       * List all active just-bash sandboxes\n       */\n      list: async (_config: JustBashConfig) => {\n        return Array.from(activeSandboxes.entries()).map(([sandboxId, sandbox]) => ({\n          sandbox,\n          sandboxId,\n        }));\n      },\n\n      /**\n       * Destroy a just-bash sandbox\n       */\n      destroy: async (_config: JustBashConfig, sandboxId: string) => {\n        activeSandboxes.delete(sandboxId);\n      },\n\n      /**\n       * Execute code in the sandbox\n       *\n       * For Python: executes via the built-in python3 command (pyodide)\n       * For Node/JS: wraps code in a bash script that evaluates it\n       */\n      runCode: async (sandbox: JustBashSandbox, code: string, runtime?: Runtime): Promise<CodeResult> => {\n        const effectiveRuntime = runtime || (\n          code.includes('print(') ||\n          code.includes('import ') ||\n          code.includes('def ') ||\n          code.includes('sys.') ||\n          code.includes('json.') ||\n          code.includes('__') ||\n          code.includes('f\"') ||\n          code.includes(\"f'\") ||\n          code.includes('raise ')\n            ? 'python'\n            : 'node'\n        );\n\n        let result: BashExecResult;\n\n        if (effectiveRuntime === 'python') {\n          // Use python3 command (requires python: true in config)\n          // Write code to a temp file and execute it to avoid quoting issues\n          const tempFile = `/tmp/_computesdk_run_${Date.now()}.py`;\n          await sandbox.bash.writeFile(tempFile, code);\n          result = await sandbox.bash.exec(`python3 ${tempFile}`);\n        } else {\n          // For node/JS, execute as bash script\n          // just-bash doesn't have a real Node.js runtime,\n          // so we execute the code as a bash script\n          const tempFile = `/tmp/_computesdk_run_${Date.now()}.sh`;\n          await sandbox.bash.writeFile(tempFile, code);\n          result = await sandbox.bash.exec(`bash ${tempFile}`);\n        }\n\n        const output = result.stderr\n          ? `${result.stdout}${result.stdout && result.stderr ? '\\n' : ''}${result.stderr}`\n          : result.stdout;\n\n        return {\n          output,\n          exitCode: result.exitCode,\n          language: effectiveRuntime,\n        };\n      },\n\n      /**\n       * Execute a shell command in the sandbox\n       */\n      runCommand: async (sandbox: JustBashSandbox, command: string, options?: RunCommandOptions): Promise<CommandResult> => {\n        const startTime = Date.now();\n        try {\n          const execOptions: { env?: Record<string, string>; cwd?: string } = {};\n\n          if (options?.env && Object.keys(options.env).length > 0) {\n            execOptions.env = options.env;\n          }\n\n          if (options?.cwd) {\n            execOptions.cwd = options.cwd;\n          }\n\n          const result = await sandbox.bash.exec(\n            command,\n            Object.keys(execOptions).length > 0 ? execOptions : undefined\n          );\n\n          return {\n            stdout: result.stdout || '',\n            stderr: result.stderr || '',\n            exitCode: result.exitCode,\n            durationMs: Date.now() - startTime,\n          };\n        } catch (error) {\n          return {\n            stdout: '',\n            stderr: error instanceof Error ? error.message : String(error),\n            exitCode: 127,\n            durationMs: Date.now() - startTime,\n          };\n        }\n      },\n\n      /**\n       * Get sandbox information\n       */\n      getInfo: async (sandbox: JustBashSandbox): Promise<SandboxInfo> => {\n        return {\n          id: sandbox.id,\n          provider: 'just-bash',\n          runtime: sandbox.config.python ? 'python' : 'node',\n          status: 'running',\n          createdAt: sandbox.createdAt,\n          timeout: 0, // No timeout - local execution\n          metadata: {\n            type: 'local',\n            cwd: sandbox.bash.getCwd(),\n          },\n        };\n      },\n\n      /**\n       * Get URL for a port - not supported for local execution\n       */\n      getUrl: async (_sandbox: JustBashSandbox, options: { port: number; protocol?: string }): Promise<string> => {\n        throw new Error(\n          `just-bash is a local sandbox without network capabilities. Cannot expose port ${options.port}.`\n        );\n      },\n\n      /**\n       * Filesystem operations using the just-bash virtual filesystem\n       */\n      filesystem: {\n        readFile: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<string> => {\n          return sandbox.bash.readFile(path);\n        },\n\n        writeFile: async (sandbox: JustBashSandbox, path: string, content: string, _runCommand): Promise<void> => {\n          // Ensure parent directory exists\n          const parentDir = path.substring(0, path.lastIndexOf('/')) || '/';\n          if (parentDir !== '/') {\n            await sandbox.bash.exec(`mkdir -p ${parentDir}`);\n          }\n          await sandbox.bash.writeFile(path, content);\n        },\n\n        mkdir: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<void> => {\n          const result = await sandbox.bash.exec(`mkdir -p ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to create directory ${path}: ${result.stderr}`);\n          }\n        },\n\n        readdir: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<FileEntry[]> => {\n          const result = await sandbox.bash.exec(`ls -la ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to list directory ${path}: ${result.stderr}`);\n          }\n\n          const entries: FileEntry[] = [];\n          const lines = result.stdout.trim().split('\\n');\n\n          for (const line of lines) {\n            // Skip total line and empty lines\n            if (!line || line.startsWith('total')) continue;\n\n            const parts = line.split(/\\s+/);\n            if (parts.length < 9) continue;\n\n            const permissions = parts[0];\n            const name = parts.slice(8).join(' ');\n\n            // Skip . and ..\n            if (name === '.' || name === '..') continue;\n\n            entries.push({\n              name,\n              type: permissions.startsWith('d') ? 'directory' as const : 'file' as const,\n              size: parseInt(parts[4], 10) || 0,\n              modified: new Date(),\n            });\n          }\n\n          return entries;\n        },\n\n        exists: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<boolean> => {\n          const result = await sandbox.bash.exec(`test -f ${path} || test -d ${path}`);\n          return result.exitCode === 0;\n        },\n\n        remove: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<void> => {\n          const result = await sandbox.bash.exec(`rm -rf ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to remove ${path}: ${result.stderr}`);\n          }\n        },\n      },\n\n      /**\n       * Get the native JustBashSandbox instance for advanced usage\n       */\n      getInstance: (sandbox: JustBashSandbox): JustBashSandbox => {\n        return sandbox;\n      },\n    },\n  },\n});\n\n// Export types\nexport type { JustBashSandbox };\n"],"mappings":"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","names":[]}

package/dist/index.mjs

@@ -0,0 +1,211 @@
+// src/index.ts
+import { Bash } from "just-bash";
+import { defineProvider } from "@computesdk/provider";
+var activeSandboxes = /* @__PURE__ */ new Map();
+var justBash = defineProvider({
+  name: "just-bash",
+  methods: {
+    sandbox: {
+      /**
+       * Create a new just-bash sandbox
+       */
+      create: async (config, options) => {
+        const sandboxId = options?.sandboxId || `just-bash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        if (options?.sandboxId && activeSandboxes.has(options.sandboxId)) {
+          const existing = activeSandboxes.get(options.sandboxId);
+          return { sandbox: existing, sandboxId: existing.id };
+        }
+        const bash = new Bash({
+          files: config.files,
+          env: {
+            ...config.env,
+            ...options?.envs
+          },
+          cwd: config.cwd || "/home/user",
+          python: config.python ?? options?.runtime === "python",
+          fs: config.fs,
+          customCommands: config.customCommands,
+          network: config.network
+        });
+        const sandbox = {
+          bash,
+          id: sandboxId,
+          createdAt: /* @__PURE__ */ new Date(),
+          config
+        };
+        activeSandboxes.set(sandboxId, sandbox);
+        return { sandbox, sandboxId };
+      },
+      /**
+       * Get an existing just-bash sandbox by ID
+       */
+      getById: async (_config, sandboxId) => {
+        const sandbox = activeSandboxes.get(sandboxId);
+        if (!sandbox) return null;
+        return { sandbox, sandboxId };
+      },
+      /**
+       * List all active just-bash sandboxes
+       */
+      list: async (_config) => {
+        return Array.from(activeSandboxes.entries()).map(([sandboxId, sandbox]) => ({
+          sandbox,
+          sandboxId
+        }));
+      },
+      /**
+       * Destroy a just-bash sandbox
+       */
+      destroy: async (_config, sandboxId) => {
+        activeSandboxes.delete(sandboxId);
+      },
+      /**
+       * Execute code in the sandbox
+       *
+       * For Python: executes via the built-in python3 command (pyodide)
+       * For Node/JS: wraps code in a bash script that evaluates it
+       */
+      runCode: async (sandbox, code, runtime) => {
+        const effectiveRuntime = runtime || (code.includes("print(") || code.includes("import ") || code.includes("def ") || code.includes("sys.") || code.includes("json.") || code.includes("__") || code.includes('f"') || code.includes("f'") || code.includes("raise ") ? "python" : "node");
+        let result;
+        if (effectiveRuntime === "python") {
+          const tempFile = `/tmp/_computesdk_run_${Date.now()}.py`;
+          await sandbox.bash.writeFile(tempFile, code);
+          result = await sandbox.bash.exec(`python3 ${tempFile}`);
+        } else {
+          const tempFile = `/tmp/_computesdk_run_${Date.now()}.sh`;
+          await sandbox.bash.writeFile(tempFile, code);
+          result = await sandbox.bash.exec(`bash ${tempFile}`);
+        }
+        const output = result.stderr ? `${result.stdout}${result.stdout && result.stderr ? "\n" : ""}${result.stderr}` : result.stdout;
+        return {
+          output,
+          exitCode: result.exitCode,
+          language: effectiveRuntime
+        };
+      },
+      /**
+       * Execute a shell command in the sandbox
+       */
+      runCommand: async (sandbox, command, options) => {
+        const startTime = Date.now();
+        try {
+          const execOptions = {};
+          if (options?.env && Object.keys(options.env).length > 0) {
+            execOptions.env = options.env;
+          }
+          if (options?.cwd) {
+            execOptions.cwd = options.cwd;
+          }
+          const result = await sandbox.bash.exec(
+            command,
+            Object.keys(execOptions).length > 0 ? execOptions : void 0
+          );
+          return {
+            stdout: result.stdout || "",
+            stderr: result.stderr || "",
+            exitCode: result.exitCode,
+            durationMs: Date.now() - startTime
+          };
+        } catch (error) {
+          return {
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error),
+            exitCode: 127,
+            durationMs: Date.now() - startTime
+          };
+        }
+      },
+      /**
+       * Get sandbox information
+       */
+      getInfo: async (sandbox) => {
+        return {
+          id: sandbox.id,
+          provider: "just-bash",
+          runtime: sandbox.config.python ? "python" : "node",
+          status: "running",
+          createdAt: sandbox.createdAt,
+          timeout: 0,
+          // No timeout - local execution
+          metadata: {
+            type: "local",
+            cwd: sandbox.bash.getCwd()
+          }
+        };
+      },
+      /**
+       * Get URL for a port - not supported for local execution
+       */
+      getUrl: async (_sandbox, options) => {
+        throw new Error(
+          `just-bash is a local sandbox without network capabilities. Cannot expose port ${options.port}.`
+        );
+      },
+      /**
+       * Filesystem operations using the just-bash virtual filesystem
+       */
+      filesystem: {
+        readFile: async (sandbox, path, _runCommand) => {
+          return sandbox.bash.readFile(path);
+        },
+        writeFile: async (sandbox, path, content, _runCommand) => {
+          const parentDir = path.substring(0, path.lastIndexOf("/")) || "/";
+          if (parentDir !== "/") {
+            await sandbox.bash.exec(`mkdir -p ${parentDir}`);
+          }
+          await sandbox.bash.writeFile(path, content);
+        },
+        mkdir: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`mkdir -p ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
+          }
+        },
+        readdir: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`ls -la ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
+          }
+          const entries = [];
+          const lines = result.stdout.trim().split("\n");
+          for (const line of lines) {
+            if (!line || line.startsWith("total")) continue;
+            const parts = line.split(/\s+/);
+            if (parts.length < 9) continue;
+            const permissions = parts[0];
+            const name = parts.slice(8).join(" ");
+            if (name === "." || name === "..") continue;
+            entries.push({
+              name,
+              type: permissions.startsWith("d") ? "directory" : "file",
+              size: parseInt(parts[4], 10) || 0,
+              modified: /* @__PURE__ */ new Date()
+            });
+          }
+          return entries;
+        },
+        exists: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`test -f ${path} || test -d ${path}`);
+          return result.exitCode === 0;
+        },
+        remove: async (sandbox, path, _runCommand) => {
+          const result = await sandbox.bash.exec(`rm -rf ${path}`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to remove ${path}: ${result.stderr}`);
+          }
+        }
+      },
+      /**
+       * Get the native JustBashSandbox instance for advanced usage
+       */
+      getInstance: (sandbox) => {
+        return sandbox;
+      }
+    }
+  }
+});
+export {
+  justBash
+};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * just-bash Provider - Factory-based Implementation\n *\n * Local sandboxed bash execution using the just-bash package.\n * Provides a virtual filesystem and bash shell environment\n * without requiring any external services or containers.\n *\n * Features:\n * - Pure TypeScript bash interpreter (no real processes)\n * - In-memory virtual filesystem\n * - Python support via pyodide (optional)\n * - Shell command execution with 60+ built-in commands\n * - No authentication required - runs entirely locally\n */\n\nimport { Bash } from 'just-bash';\nimport type { BashExecResult, BashOptions } from 'just-bash';\nimport { defineProvider } from '@computesdk/provider';\nimport type {\n  CodeResult,\n  CommandResult,\n  SandboxInfo,\n  Runtime,\n  CreateSandboxOptions,\n  FileEntry,\n  RunCommandOptions,\n} from 'computesdk';\n\n/**\n * just-bash-specific configuration options\n */\nexport interface JustBashConfig {\n  /** Enable Python support via pyodide (disabled by default) */\n  python?: boolean;\n  /** Initial files to populate in the virtual filesystem */\n  files?: BashOptions['files'];\n  /** Initial environment variables */\n  env?: Record<string, string>;\n  /** Working directory (defaults to /home/user) */\n  cwd?: string;\n  /**\n   * Custom filesystem implementation.\n   * Defaults to InMemoryFs. Use OverlayFs for copy-on-write over a real directory,\n   * ReadWriteFs for direct disk access, or MountableFs to combine multiple filesystems.\n   */\n  fs?: BashOptions['fs'];\n  /**\n   * Custom commands to register alongside built-in commands.\n   * Created with `defineCommand()` from just-bash.\n   */\n  customCommands?: BashOptions['customCommands'];\n  /** Network configuration for commands like curl */\n  network?: BashOptions['network'];\n}\n\n/** Internal sandbox state */\ninterface JustBashSandbox {\n  bash: Bash;\n  id: string;\n  createdAt: Date;\n  config: JustBashConfig;\n}\n\n/** Active sandboxes registry */\nconst activeSandboxes = new Map<string, JustBashSandbox>();\n\n/**\n * Create a just-bash provider instance using the factory pattern\n *\n * just-bash provides local sandboxed bash execution with:\n * - Virtual filesystem (in-memory)\n * - 60+ built-in commands (cat, grep, sed, awk, jq, etc.)\n * - Python support via pyodide\n * - No external dependencies or authentication required\n */\nexport const justBash = defineProvider<JustBashSandbox, JustBashConfig>({\n  name: 'just-bash',\n  methods: {\n    sandbox: {\n      /**\n       * Create a new just-bash sandbox\n       */\n      create: async (config: JustBashConfig, options?: CreateSandboxOptions) => {\n        const sandboxId = options?.sandboxId || `just-bash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;\n\n        // Check if reconnecting to existing sandbox\n        if (options?.sandboxId && activeSandboxes.has(options.sandboxId)) {\n          const existing = activeSandboxes.get(options.sandboxId)!;\n          return { sandbox: existing, sandboxId: existing.id };\n        }\n\n        const bash = new Bash({\n          files: config.files,\n          env: {\n            ...config.env,\n            ...options?.envs,\n          },\n          cwd: config.cwd || '/home/user',\n          python: config.python ?? (options?.runtime === 'python'),\n          fs: config.fs,\n          customCommands: config.customCommands,\n          network: config.network,\n        });\n\n        const sandbox: JustBashSandbox = {\n          bash,\n          id: sandboxId,\n          createdAt: new Date(),\n          config,\n        };\n\n        activeSandboxes.set(sandboxId, sandbox);\n        return { sandbox, sandboxId };\n      },\n\n      /**\n       * Get an existing just-bash sandbox by ID\n       */\n      getById: async (_config: JustBashConfig, sandboxId: string) => {\n        const sandbox = activeSandboxes.get(sandboxId);\n        if (!sandbox) return null;\n        return { sandbox, sandboxId };\n      },\n\n      /**\n       * List all active just-bash sandboxes\n       */\n      list: async (_config: JustBashConfig) => {\n        return Array.from(activeSandboxes.entries()).map(([sandboxId, sandbox]) => ({\n          sandbox,\n          sandboxId,\n        }));\n      },\n\n      /**\n       * Destroy a just-bash sandbox\n       */\n      destroy: async (_config: JustBashConfig, sandboxId: string) => {\n        activeSandboxes.delete(sandboxId);\n      },\n\n      /**\n       * Execute code in the sandbox\n       *\n       * For Python: executes via the built-in python3 command (pyodide)\n       * For Node/JS: wraps code in a bash script that evaluates it\n       */\n      runCode: async (sandbox: JustBashSandbox, code: string, runtime?: Runtime): Promise<CodeResult> => {\n        const effectiveRuntime = runtime || (\n          code.includes('print(') ||\n          code.includes('import ') ||\n          code.includes('def ') ||\n          code.includes('sys.') ||\n          code.includes('json.') ||\n          code.includes('__') ||\n          code.includes('f\"') ||\n          code.includes(\"f'\") ||\n          code.includes('raise ')\n            ? 'python'\n            : 'node'\n        );\n\n        let result: BashExecResult;\n\n        if (effectiveRuntime === 'python') {\n          // Use python3 command (requires python: true in config)\n          // Write code to a temp file and execute it to avoid quoting issues\n          const tempFile = `/tmp/_computesdk_run_${Date.now()}.py`;\n          await sandbox.bash.writeFile(tempFile, code);\n          result = await sandbox.bash.exec(`python3 ${tempFile}`);\n        } else {\n          // For node/JS, execute as bash script\n          // just-bash doesn't have a real Node.js runtime,\n          // so we execute the code as a bash script\n          const tempFile = `/tmp/_computesdk_run_${Date.now()}.sh`;\n          await sandbox.bash.writeFile(tempFile, code);\n          result = await sandbox.bash.exec(`bash ${tempFile}`);\n        }\n\n        const output = result.stderr\n          ? `${result.stdout}${result.stdout && result.stderr ? '\\n' : ''}${result.stderr}`\n          : result.stdout;\n\n        return {\n          output,\n          exitCode: result.exitCode,\n          language: effectiveRuntime,\n        };\n      },\n\n      /**\n       * Execute a shell command in the sandbox\n       */\n      runCommand: async (sandbox: JustBashSandbox, command: string, options?: RunCommandOptions): Promise<CommandResult> => {\n        const startTime = Date.now();\n        try {\n          const execOptions: { env?: Record<string, string>; cwd?: string } = {};\n\n          if (options?.env && Object.keys(options.env).length > 0) {\n            execOptions.env = options.env;\n          }\n\n          if (options?.cwd) {\n            execOptions.cwd = options.cwd;\n          }\n\n          const result = await sandbox.bash.exec(\n            command,\n            Object.keys(execOptions).length > 0 ? execOptions : undefined\n          );\n\n          return {\n            stdout: result.stdout || '',\n            stderr: result.stderr || '',\n            exitCode: result.exitCode,\n            durationMs: Date.now() - startTime,\n          };\n        } catch (error) {\n          return {\n            stdout: '',\n            stderr: error instanceof Error ? error.message : String(error),\n            exitCode: 127,\n            durationMs: Date.now() - startTime,\n          };\n        }\n      },\n\n      /**\n       * Get sandbox information\n       */\n      getInfo: async (sandbox: JustBashSandbox): Promise<SandboxInfo> => {\n        return {\n          id: sandbox.id,\n          provider: 'just-bash',\n          runtime: sandbox.config.python ? 'python' : 'node',\n          status: 'running',\n          createdAt: sandbox.createdAt,\n          timeout: 0, // No timeout - local execution\n          metadata: {\n            type: 'local',\n            cwd: sandbox.bash.getCwd(),\n          },\n        };\n      },\n\n      /**\n       * Get URL for a port - not supported for local execution\n       */\n      getUrl: async (_sandbox: JustBashSandbox, options: { port: number; protocol?: string }): Promise<string> => {\n        throw new Error(\n          `just-bash is a local sandbox without network capabilities. Cannot expose port ${options.port}.`\n        );\n      },\n\n      /**\n       * Filesystem operations using the just-bash virtual filesystem\n       */\n      filesystem: {\n        readFile: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<string> => {\n          return sandbox.bash.readFile(path);\n        },\n\n        writeFile: async (sandbox: JustBashSandbox, path: string, content: string, _runCommand): Promise<void> => {\n          // Ensure parent directory exists\n          const parentDir = path.substring(0, path.lastIndexOf('/')) || '/';\n          if (parentDir !== '/') {\n            await sandbox.bash.exec(`mkdir -p ${parentDir}`);\n          }\n          await sandbox.bash.writeFile(path, content);\n        },\n\n        mkdir: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<void> => {\n          const result = await sandbox.bash.exec(`mkdir -p ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to create directory ${path}: ${result.stderr}`);\n          }\n        },\n\n        readdir: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<FileEntry[]> => {\n          const result = await sandbox.bash.exec(`ls -la ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to list directory ${path}: ${result.stderr}`);\n          }\n\n          const entries: FileEntry[] = [];\n          const lines = result.stdout.trim().split('\\n');\n\n          for (const line of lines) {\n            // Skip total line and empty lines\n            if (!line || line.startsWith('total')) continue;\n\n            const parts = line.split(/\\s+/);\n            if (parts.length < 9) continue;\n\n            const permissions = parts[0];\n            const name = parts.slice(8).join(' ');\n\n            // Skip . and ..\n            if (name === '.' || name === '..') continue;\n\n            entries.push({\n              name,\n              type: permissions.startsWith('d') ? 'directory' as const : 'file' as const,\n              size: parseInt(parts[4], 10) || 0,\n              modified: new Date(),\n            });\n          }\n\n          return entries;\n        },\n\n        exists: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<boolean> => {\n          const result = await sandbox.bash.exec(`test -f ${path} || test -d ${path}`);\n          return result.exitCode === 0;\n        },\n\n        remove: async (sandbox: JustBashSandbox, path: string, _runCommand): Promise<void> => {\n          const result = await sandbox.bash.exec(`rm -rf ${path}`);\n          if (result.exitCode !== 0) {\n            throw new Error(`Failed to remove ${path}: ${result.stderr}`);\n          }\n        },\n      },\n\n      /**\n       * Get the native JustBashSandbox instance for advanced usage\n       */\n      getInstance: (sandbox: JustBashSandbox): JustBashSandbox => {\n        return sandbox;\n      },\n    },\n  },\n});\n\n// Export types\nexport type { JustBashSandbox };\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@computesdk/just-bash",
+  "version": "0.1.0",
+  "description": "just-bash provider for ComputeSDK - local sandboxed bash execution with virtual filesystem",
+  "author": "ComputeSDK",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "computesdk": "2.3.0",
+    "@computesdk/provider": "1.0.28"
+  },
+  "peerDependencies": {
+    "just-bash": ">=2.0.0"
+  },
+  "devDependencies": {
+    "just-bash": "^2.11.5",
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "eslint": "^8.37.0",
+    "rimraf": "^5.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0",
+    "@computesdk/test-utils": "1.5.1"
+  },
+  "keywords": [
+    "computesdk",
+    "just-bash",
+    "sandbox",
+    "code-execution",
+    "bash",
+    "shell",
+    "virtual-filesystem",
+    "provider",
+    "local"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/computesdk/computesdk.git",
+    "directory": "packages/just-bash"
+  },
+  "homepage": "https://www.computesdk.com",
+  "bugs": {
+    "url": "https://github.com/computesdk/computesdk/issues"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint"
+  }
+}