Microsandbox

https://github.com/zerocore-ai/microsandbox
Admin
Microsandbox provides an easy, secure, and fast hardware-isolated execution environment for...
Tokens:70,951
Snippets:645
Trust Score:6.5
License:Apache-2.0
Update:10 months ago
Show doc for...
Tokens:
Raw
### Setup Microsandbox Julia Project

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/julia/DEVELOPMENT.md

Clones the Microsandbox repository, navigates to the Julia SDK directory, and starts the Julia REPL, activating the project environment and installing dependencies.

```bash
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/julia
julia --project=.

# Press ']' to enter Pkg mode
# Activate and install dependencies
activate .
instantiate
```

--------------------------------

### Quick Start

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

A quick example to start the microsandbox server in development mode.

```APIDOC
## Quick Start

### Description
Starts the microsandbox server in development mode.

### Method
Shell command

### Command
```bash
msb server start --dev
```
```

--------------------------------

### Setup Python Development Environment with uv

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/python/DEVELOPMENT.md

This snippet details how to clone the repository, set up a Python virtual environment using uv, and install the package in development mode with its associated development dependencies.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/python

# Install dependencies using uv
uv venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install the package in development mode
uv pip install -e ".[dev]"
```

--------------------------------

### Install Microsandbox Go SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/go/README.md

Instructions for installing the Microsandbox Go SDK using the go get command.

```bash
go get github.com/microsandbox/microsandbox/sdk/go
```

--------------------------------

### Python SDK Installation and Sandbox Execution

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Installs the Python SDK using pip and demonstrates creating a Python sandbox to execute code, print a message, and retrieve the output.

```bash
pip install microsandbox
```

```python
import asyncio
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="my-first-sandbox") as sb:
        # Execute some Python code
        exec = await sb.run("name = 'World'")
        exec = await sb.run("print(f'Hello {name}!')")

        # Get the output
        output = await exec.output()
        print(output)  # prints: Hello World!

asyncio.run(main())
```

--------------------------------

### Setup and Dependency Management for C# SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/csharp/DEVELOPMENT.md

This snippet details the initial setup process for the Microsandbox C# SDK. It includes cloning the repository, navigating to the SDK directory, and restoring project dependencies using `dotnet restore`.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/csharp

# Restore dependencies
dotnet restore
```

--------------------------------

### Setup Microsandbox Dart SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/dart/DEVELOPMENT.md

Clones the Microsandbox repository and navigates to the Dart SDK directory, then fetches project dependencies using 'dart pub get'. Ensure you have Git and Dart SDK installed.

```bash
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/dart
dart pub get
```

--------------------------------

### JavaScript SDK Installation and Sandbox Execution

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Installs the JavaScript SDK using npm and demonstrates creating a Node.js sandbox to execute JavaScript code, log a message, and capture the output.

```bash
npm install microsandbox
```

```javascript
import { NodeSandbox } from "microsandbox";

async function main() {
  const sb = await NodeSandbox.create({ name: "my-first-sandbox" });

  try {
    // Execute some JavaScript code
    let exec = await sb.run("var name = 'World'");
    exec = await sb.run("console.log(`Hello ${name}!`)");

    // Get the output
    const output = await exec.output();
    console.log(output); // prints: Hello World!
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);
```

--------------------------------

### Sandboxfile YAML Configuration Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/PROJECTS.md

Example of a Sandboxfile in YAML format, defining sandbox configurations including image, memory, CPU, and start scripts.

```yaml
# Sandbox configurations
sandboxes:
  app:
    image: python
    memory: 1024
    cpus: 1
    scripts:
      start: python -c "print(\"hello\")"
```

--------------------------------

### Setup Nim SDK Development Environment

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/nim/DEVELOPMENT.md

This section details the steps to clone the repository, navigate to the Nim SDK directory, and install necessary dependencies using nimble. Ensure you have Git and Nimble installed.

```bash
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/nim
nimble install
```

--------------------------------

### Run Microsandbox Java Example (Bash)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/java/README.md

These bash commands outline the process for building and running an example application using the Microsandbox Java SDK with Maven. It includes steps for cleaning, installing the project, and executing a Java application.

```bash
# Build the project
mvn clean install

# Run the example
mvn exec:java
```

--------------------------------

### Sandboxfile Configuration Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/README.md

An example of the `Sandboxfile` structure, defining a sandbox named 'app'. It specifies the Docker image to use, memory and CPU limits, and a start script to execute when the sandbox begins.

```yaml
sandboxes:
  app:
    image: python
    memory: 1024
    cpus: 1
    scripts:
      start: python -c "print(\"hello\")"
```

--------------------------------

### Quick Start: Execute Python Code in Sandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/python-sdk.md

A basic example demonstrating how to create a Python sandbox, run a simple Python script ('print('Hello, World!')'), and retrieve its output using the microsandbox Python SDK.

```python
import asyncio
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="my-sandbox") as sb:
        exec = await sb.run("print('Hello, World!')")
        print(await exec.output())

asyncio.run(main())
```

--------------------------------

### Verify Python Package Installation from TestPyPI

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/python/DEVELOPMENT.md

This sequence of commands creates a new virtual environment, activates it, and installs the package from TestPyPI, using both TestPyPI and the main PyPI index to resolve dependencies.

```bash
# Create a new environment for testing
uv venv test_env
source test_env/bin/activate  # On Windows: test_env\Scripts\activate

# Install from TestPyPI
uv pip install --index-url https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ your-package-name
```

--------------------------------

### Microsandbox Server Start Command Options

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

Demonstrates various ways to start the microsandbox server using the `msb server start` command with different options like host, port, path, detach, and key management.

```bash
# Start server in development mode
msb server start --dev

# Start server on custom port
msb server start --port 8080

# Start server on custom host
msb server start --host 0.0.0.0

# Start server in background with custom namespace path
msb server start --detach --path /custom/namespaces

# Start server with a specific key
msb server start --key mySecretKey123
```

--------------------------------

### Clone, Build, and Install C++ SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/DEVELOPMENT.md

Steps to clone the Monocore repository, navigate to the C++ SDK directory, set up a build environment using CMake, and compile the project.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/cpp

# Create a build directory
mkdir build && cd build

# Configure and build
cmake ..
make
```

--------------------------------

### Quick Start: Execute Node.js Code in Sandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/python-sdk.md

A basic example demonstrating how to create a Node.js sandbox, run a simple JavaScript script ('console.log('Hello from Node.js!');'), and retrieve its output using the microsandbox NodeSandbox.

```javascript
from microsandbox import NodeSandbox

async with NodeSandbox.create(name="js-sandbox") as sb:
    exec = await sb.run("console.log('Hello from Node.js!');")
    print(await exec.output())
```

--------------------------------

### Quick Start Node.js Sandbox in Rust

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/rust-sdk.md

A basic example of initializing, starting, running a simple JavaScript snippet, and stopping a Node.js sandbox using the microsandbox Rust SDK. It mirrors the Python quick start but for Node.js.

```rust
use microsandbox::NodeSandbox;

let mut sb = NodeSandbox::create("js-sandbox").await?;
sb.start(None).await?;

let exec = sb.run("console.log('Hello from Node.js!');").await?;
println!("{}", exec.output().await?);

sb.stop().await?;

```

--------------------------------

### Clone and Install Microsandbox SDK (JavaScript)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/javascript/DEVELOPMENT.md

This snippet details the process of cloning the Microsandbox repository, navigating to the JavaScript SDK directory, and installing its dependencies using npm. Ensure you have Git and Node.js installed.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/javascript

# Install dependencies
npm install
```

--------------------------------

### Microsandbox SDK Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/swift/README.md

A basic example demonstrating how to import and use the Microsandbox SDK in Swift. It shows calling the `greet` function with a string argument.

```swift
import Microsandbox

// Print a greeting
Microsandbox.greet("World")
```

--------------------------------

### Start Sandbox with Custom Resources (Go)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/go/README.md

Initiates a sandbox instance with specified Docker image, memory, and CPU cores. If memory or CPU are set to 0, default values will be used. An error is returned if the sandbox fails to start.

```go
// Start with custom resources
err := sandbox.Start(
    "custom-image:latest", // Docker image (empty = language default)
    1024,                  // Memory in MB (0 = default 512MB)
    2,                     // CPU cores (0 = default 1)
)

```

--------------------------------

### Start Microsandbox Server with Custom Port

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Provides a bash command to start the microsandbox server with a custom port. This is useful for resolving port conflicts if the default port is already in use by another service.

```bash
msb server start --dev --port 8080
```

--------------------------------

### Setup Microsandbox R SDK Development Environment

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/r/README.md

Steps to set up the development environment for the Microsandbox R SDK. This involves cloning the repository and installing necessary development dependencies.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/r

# Install development dependencies
R -e "install.packages(c('devtools', 'roxygen2', 'testthat', 'knitr'))"
```

--------------------------------

### Clone and Build Microsandbox Swift SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/swift/DEVELOPMENT.md

Clones the Microsandbox Swift SDK repository from GitHub and builds the Swift package. This is the initial setup step for development.

```bash
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/swift
swift build
```

--------------------------------

### Setup Development Environment for Microsandbox OCaml SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/ocaml/README.md

Sets up the development environment for the Microsandbox OCaml SDK. This involves cloning the repository and optionally creating a local opam switch with dependencies. Requires Git and opam installed.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/ocaml

# Create a local opam switch (optional)
opam switch create . --deps-only --with-test

```

--------------------------------

### Start Microsandbox Server

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/index.md

This command starts the microsandbox server in development mode. Ensure the server is running before attempting to execute code.

```bash
msb server start --dev
```

--------------------------------

### Quick Start Python Sandbox in Rust

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/rust-sdk.md

A basic example demonstrating how to initialize, start, run a simple Python script, and stop a Python sandbox using the microsandbox Rust SDK. It utilizes tokio for asynchronous operations.

```rust
use microsandbox::{PythonSandbox, SandboxOptions};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut sb = PythonSandbox::create("my-sandbox").await?;
    sb.start(None).await?;

    let exec = sb.run("print('Hello, World!')").await?;
    println!("{}", exec.output().await?);

    sb.stop().await?;
    Ok(())
}

```

--------------------------------

### Create and Run Bash Scripts (Python, JavaScript, Rust)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Illustrates how to create a bash script file within the sandbox and then execute it. This involves writing the script content to a file and using the 'bash' command to run it, capturing its output. Useful for automating tasks within the sandbox.

```python
import asyncio
from textwrap import dedent
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="bash-test") as sb:
        # Create and run a bash script
        await sb.run(
            dedent("""
            with open("hello.sh", "w") as f:
                f.write("#!/bin/bash\n")
                f.write("echo Hello World\n")
                f.write("date\n")
        """)

        # Execute the script
        result = await sb.command.run("bash", ["hello.sh"])
        print("Script output:")
        print(await result.output())

asyncio.run(main())
```

```javascript
import { PythonSandbox } from "microsandbox";

async function main() {
  const sb = await PythonSandbox.create({ name: "bash-test" });

  try {
    // Create and run a bash script
    await sb.run(`
with open("hello.sh", "w") as f:
    f.write("#!/bin/bash\n")
    f.write("echo Hello World\n")
    f.write("date\n")
    `);

    // Execute the script
    const result = await sb.command.run("bash", ["hello.sh"]);
    console.log("Script output:");
    console.log(await result.output());
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);
```

```rust
use microsandbox::{BaseSandbox, PythonSandbox};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut sb = PythonSandbox::create("bash-test").await?;
    sb.start(None).await?;

    // Create and run a bash script
    sb.run(r#"#
with open("hello.sh", "w") as f:
    f.write("#!/bin/bash\n")
    f.write("echo Hello World\n")
    f.write("date\n")
"#, None).await?;

    // Execute the script
    let cmd = sb.command().await?;
    let result = cmd.run("bash", Some(vec!["hello.sh"]), None).await?;
    println!("Script output:");
    println!("{}", result.output().await?);

    sb.stop().await?;
    Ok(())
}
```

--------------------------------

### Setup Microsandbox Elm SDK Development Environment

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/elm/README.md

Commands to set up the development environment for the Microsandbox Elm SDK. This includes cloning the repository, navigating to the SDK directory, and installing the Elm compiler via npm.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/elm

# Install Elm if not already installed
npm install -g elm
```

--------------------------------

### Install Microsandbox Python SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/python/README.md

Instructions for installing the Microsandbox Python SDK using pip from PyPI or from source after cloning the repository. It also includes steps for local installation from a cloned repository.

```bash
# Install from PyPI
pip install microsandbox

# Or install from source
git clone https://github.com/microsandbox/microsandbox.git
cd microsandbox/sdk/python
pip install -e .
```

--------------------------------

### Install Microsandbox F# SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/fsharp/README.md

Instructions for installing the Microsandbox F# SDK using the .NET CLI or the NuGet Package Manager. This is the first step to using the SDK in your project.

```bash
dotnet add package Microsandbox.FSharp
```

```powershell
Install-Package Microsandbox.FSharp
```

--------------------------------

### Installation

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

Instructions to install the microsandbox CLI using curl.

```APIDOC
## Installation

### Description
Installs the microsandbox CLI.

### Method
Shell command

### Command
```bash
curl -sSL https://get.microsandbox.dev | sh
```
```

--------------------------------

### Example Usage of Microsandbox Elixir SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/elixir/README.md

A simple example showcasing how to call the `greet` function from the Microsandbox SDK. This illustrates a basic interaction with the library.

```elixir
# Print a greeting
Microsandbox.greet("World")
```

--------------------------------

### Erlang SDK Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/erlang/README.md

A basic Erlang code example demonstrating how to use the Microsandbox SDK to print a greeting. It shows calling the `greet` function and formatting the output.

```erlang
% Print a greeting
{ok, Greeting} = microsandbox:greet("World"),
io:format("~s~n", [Greeting]).
```

--------------------------------

### Install a Sandbox as System Executable (Shell)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/PROJECTS.md

Installs a sandbox as a system-wide executable, allowing it to be launched from anywhere by its name. This command sets up a launcher for the sandbox.

```shell
msb install --image alpine
```

```shell
msb i alpine
```

```shell
msi alpine
```

--------------------------------

### Reference Swift SDK using Exact Tag

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/swift/DEVELOPMENT.md

Example of how a user would reference the Swift SDK from a monorepo using an exact prefixed tag in their Swift Package Manager configuration.

```swift
.package(url: "https://github.com/yourusername/monorepo.git", .exact("sdk/swift/0.1.0"))
```

--------------------------------

### Install Microsandbox CLI

Source: https://github.com/zerocore-ai/microsandbox/blob/main/SELF_HOSTING.md

Installs the `msb` command-line interface tool, which is essential for managing local Microsandbox environments. This command fetches and executes the installation script.

```sh
curl -sSL https://get.microsandbox.dev | sh
```

--------------------------------

### Microsandbox CLI Commands for Project Management

Source: https://github.com/zerocore-ai/microsandbox/blob/main/MSB_V_DOCKER.md

This snippet showcases essential Microsandbox CLI commands for project initialization, sandbox management, execution, and system command installation. These commands streamline the development workflow by providing quick access to sandboxed environments and project setup.

```bash
msb init                                       # Create new Sandboxfile project
msb add app -i python:3.11                     # Add a sandbox
msb run app                                    # Run the default script
msb exe python                                 # Quick temporary sandbox
msi alpine my-tool                             # Install as a system command
```

--------------------------------

### Microsandbox Scala SDK Basic Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/scala/README.md

A simple example demonstrating how to import and use the Microsandbox.greet function from the Scala SDK. This function takes a name and returns a greeting message.

```scala
import com.microsandbox.Microsandbox

// Print a greeting
val message = Microsandbox.greet("World")
```

--------------------------------

### Start Python Sandbox with Defaults in Rust

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/rust-sdk.md

Shows how to start a Python sandbox using default settings. This is useful when no specific resource constraints or image configurations are needed.

```rust
// Start with defaults
sb.start(None).await?;

```

--------------------------------

### Define Multi-stage Build and Sandbox Configuration (Sandboxfile)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/MSB_V_DOCKER.md

This snippet demonstrates a YAML-based Sandboxfile defining a multi-stage build process for an API and its runtime sandbox configuration. It includes build steps, artifact exports, sandbox dependencies, environment variables, and scripts. The build stage uses a Python image to install dependencies and freeze requirements, exporting packages and a lockfile. The runtime sandbox stage imports these artifacts, mounts local code, exposes a port, and defines start and test scripts.

```yaml
builds:
  api_base:
    image: "python:3"
    memory: 2048
    cpus: 2
    volumes:
      - "./api/requirements.txt:/build/requirements.txt"
    workdir: "/build"
    steps:
      start: |
        pip install -r requirements.txt && \
        pip freeze > requirements.lock && \
        pip install -r requirements.txt -t /build/dist/packages
    exports:
      packages: "/build/dist/packages"
      lockfile: "/build/requirements.lock"

sandboxes:
  api:
    image: "python:3"
    memory: 1024
    cpus: 1
    volumes:
      - "./api:/app/src"
    ports:
      - "8000:8000"
    envs:
      - "DEBUG=false"
      - "API_PORT=8000"
    depends_on:
      - "database"
    workdir: "/app"
    scripts:
      start: "python -m uvicorn src.main:app --host 0.0.0.0 --port 8000"
      test: "pytest src/tests/"
    scope: "public"
    # Import artifacts from the build stage
    imports:
      api_base:
        packages: "/app/packages"
```

--------------------------------

### Create and Start Python Sandbox Instance

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/typescript-sdk.md

Shows how to create a new PythonSandbox instance and start it with optional resource constraints like Docker image, memory, and CPU limits. The `start` method is crucial for initializing the sandbox environment before running code.

```typescript
const sandbox = new PythonSandbox({ name: "resource-limited" });
await sandbox.start("microsandbox/python", 1024, 2.0);
```

--------------------------------

### Install Microsandbox SDK using Conan

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/README.md

Installs the Microsandbox SDK using the Conan package manager. This command fetches the specified version of the SDK.

```bash
conan install microsandbox/0.0.1
```

--------------------------------

### Start Python Sandbox with Resource Constraints

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/python-sdk.md

Illustrates how to start a Python sandbox with specific resource limitations for memory and CPU. This is useful for controlling the execution environment's resource consumption.

```python
import aiohttp

# Assuming 'sandbox' is an instance of PythonSandbox
sandbox = PythonSandbox(name="resource-limited")
sandbox._session = aiohttp.ClientSession()
await sandbox.start(memory=1024, cpus=2.0)
```

--------------------------------

### Install Microsandbox SDK using vcpkg

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/README.md

Installs the Microsandbox SDK using the vcpkg package manager. This is a convenient method for managing dependencies.

```bash
vcpkg install microsandbox
```

--------------------------------

### Setup Monocore SDK PHP

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/php/DEVELOPMENT.md

Clones the Monocore repository and installs PHP dependencies using Composer. Ensure you have Git and Composer installed.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/php

# Install dependencies
composer install
```

--------------------------------

### Develop Microsandbox F# SDK: Setup and Build

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/fsharp/README.md

Commands for setting up the development environment for the Microsandbox F# SDK. Includes cloning the repository, restoring dependencies, building the release configuration, and packing the NuGet package.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/fsharp

# Restore dependencies
dotnet restore
```

```bash
dotnet build --configuration Release
```

```bash
dotnet pack --configuration Release
```

--------------------------------

### Development Setup and Compilation (Bash)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/erlang/README.md

These bash commands outline the initial steps for setting up the development environment for the Erlang SDK, including cloning the repository and compiling the project using Rebar3.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/erlang

# Compile the project
rebar3 compile
```

--------------------------------

### Conan Center Index conandata.yml Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/DEVELOPMENT.md

Example of a conandata.yml file used for the Conan Center Index, specifying source archive details for a package version.

```yaml
# conandata.yml
sources:
  "0.1.0":
    url: "https://github.com/yourusername/monocore/archive/refs/tags/v0.1.0.tar.gz"
    sha256: "<SHA256 of your source archive>"
```

--------------------------------

### Haskell SDK Development Setup and Build

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/haskell/README.md

Commands for setting up the development environment and building the Microsandbox Haskell SDK. This includes cloning the repository and using 'cabal' or 'stack' for building.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/haskell

# Build the package
cabal build

# Or with Stack
stack build
```

--------------------------------

### Basic F# Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/fsharp/README.md

A simple F# code snippet demonstrating how to use the Greeter module from the Microsandbox SDK. It shows how to import the SDK and print a greeting message.

```fsharp
open Microsandbox

// Print a greeting
let message = Greeter.greet "World"
printfn "%s" message
```

--------------------------------

### msb init

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

Initializes a new project with a custom sandbox file location.

```APIDOC
## msb init

### Description
Initializes a project with a custom sandbox file location.

### Method
CLI Command

### Endpoint
msb init --file <path>

### Parameters
#### Query Parameters
- **file** (string) - Required - Path to the sandbox file.

### Request Example
```bash
msb init --file ./path/to/Sandboxfile
```

### Response
#### Success Response (0)
- **message** (string) - Confirmation message.

#### Response Example
```
Project initialized successfully.
```
```

--------------------------------

### Execute Python Code with PythonSandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/sandboxes.md

Demonstrates how to execute Python code and install packages using the PythonSandbox. It requires the 'microsandbox' library and supports asynchronous operations. The sandbox provides a persistent environment for package installations.

```python
import asyncio
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="python-demo") as sb:
        # Execute Python code directly
        exec = await sb.run("print('Hello from Python!')")
        print(await exec.output())

        # Install and use packages
        await sb.run("pip install requests")
        exec = await sb.run("""
import requests
response = requests.get('https://httpbin.org/json')
print(response.status_code)
        """)
        print(await exec.output())

asyncio.run(main())
```

```javascript
import { PythonSandbox } from "microsandbox";

async function main() {
  const sb = await PythonSandbox.create({ name: "python-demo" });

  try {
    // Execute Python code directly
    const exec = await sb.run("print('Hello from Python!')");
    console.log(await exec.output());

    // Install and use packages
    await sb.run("pip install requests");
    const packageExec = await sb.run(`
import requests
response = requests.get('https://httpbin.org/json')
print(response.status_code)
    `);
    console.log(await packageExec.output());
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);
```

```rust
use microsandbox::{BaseSandbox, PythonSandbox};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut sb = PythonSandbox::create("python-demo").await?;
    sb.start(None).await?;

    // Execute Python code directly
    let exec = sb.run("print('Hello from Python!')").await?;
    println!("{}", exec.output().await?);

    // Install and use packages
    sb.run("pip install requests").await?;
    let package_exec = sb
        .run(
            r#"#
import requests
response = requests.get('https://httpbin.org/json')
print(response.status_code)
"#,
        )
        .await?;
    println!("{}", package_exec.output().await?);

    sb.stop().await?;
    Ok(())
}
```

--------------------------------

### Basic Usage of Microsandbox OCaml SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/ocaml/README.md

Demonstrates the basic usage of the Microsandbox OCaml SDK. This includes importing the module and calling the `greet` function. Assumes the SDK has been installed and is accessible.

```ocaml
(* Import the module *)
open Microsandbox

(* Print a greeting *)
let message = greet "World"

```

--------------------------------

### Build Microsandbox Documentation

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/julia/DEVELOPMENT.md

Adds the Documenter package and uses it to build the documentation for the Microsandbox Julia package. This requires the Documenter package to be installed.

```julia
using Pkg
Pkg.add("Documenter")
using Documenter, Microsandbox
makedocs(modules=[Microsandbox])
```

--------------------------------

### Get Project Dependencies with Mix

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/elixir/README.md

Demonstrates how to fetch and install project dependencies after updating the `mix.exs` file. This command is essential for any Mix-based Elixir project.

```bash
mix deps.get
```

--------------------------------

### Initialize New Microsandbox Project

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

Demonstrates the `msb init` command for initializing a new microsandbox project. Shows how to initialize in the current directory or specify a path.

```bash
# Initialize project in current directory
msb init


# Initialize project in a specific directory
msb init --file /path/to/project/
```

--------------------------------

### Microsandbox Project Sandboxfile Configuration

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/projects.md

An example of a 'Sandboxfile' content after adding a sandbox. This YAML file defines the configurations for different sandboxes within the project.

```yaml
# Sandbox configurations
sandboxes:
  myapp:
    image: python
    memory: 1024
    cpus: 1
    scripts:
      start: python app.py
```

--------------------------------

### Run Microsandbox Project Sandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/projects.md

Executes the default 'start' script of a specified sandbox within your microsandbox project. Supports a shorthand command and explicit script execution.

```bash
msb run --sandbox myapp
```

```bash
msr myapp
```

```bash
msr myapp~start
```

--------------------------------

### Add Sandbox to Microsandbox Project

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/projects.md

Registers a new sandbox within your microsandbox project. It allows specifying the container image, CPU and memory limits, and the start script.

```bash
msb add myapp \
    --image python \
    --cpus 1 \
    --memory 1024 \
    --start 'python app.py'
```

--------------------------------

### Conan Package Management for C++

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/DEVELOPMENT.md

Commands for managing the Microsandbox C++ package using Conan, including profile detection, local packaging, uploading to remotes, and installation by users.

```bash
# Create default profile based on your system
conan profile detect

# Create the package in your local cache
conan create .

# To your own repository (first add your remote)
conan remote add myrepo [your-repository-url]
conan upload microsandbox/0.1.0 --remote=myrepo

# Or to Conan Center (requires additional verification)
conan upload microsandbox/0.1.0 --remote=conancenter

# Users can then install your package with:
conan install --requires=microsandbox/0.1.0
```

--------------------------------

### Use Microsandbox Kotlin SDK to Greet

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/kotlin/README.md

This Kotlin code example demonstrates the basic usage of the Microsandbox Kotlin SDK. It imports the HelloWorld class and calls its greet function to print a message. This requires the SDK to be correctly added as a dependency.

```kotlin
import dev.microsandbox.HelloWorld

fun main() {
    // Print a greeting
    HelloWorld.greet("World")
}
```

--------------------------------

### Set up Microsandbox SDK Development Environment (Bash)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/objc/README.md

This bash script guides you through setting up the development environment for the Microsandbox SDK. It involves cloning the repository, navigating to the Objective-C SDK directory, and opening the Xcode project.

```bash
# Clone the repository
git clone https://github.com/yourusername/monocore.git
cd monocore/sdk/objc

# Open the project in Xcode
open Microsandbox.xcodeproj
```

--------------------------------

### Implement Error Handling in Microsandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/sandboxes.md

Shows how to handle errors when executing code within a sandbox. The example checks if an execution resulted in an error and prints either the error message or the successful output.

```python
exec = await sb.run("invalid_code_here")
if exec.has_error():
    print("Error occurred:", await exec.error())
else:
    print("Success:", await exec.output())

```

--------------------------------

### Rust Crate Addition and Sandbox Execution

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Adds the 'microsandbox' crate to a Rust project using Cargo and demonstrates creating a Python sandbox via Rust to execute Python code and retrieve its output.

```bash
cargo add microsandbox
```

```rust
use microsandbox::{SandboxOptions, PythonSandbox};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut sb = PythonSandbox::create(
        SandboxOptions::builder()
            .name("my-first-sandbox")
            .build()
    ).await?;

    // Execute some Python code
    let exec = sb.run(r#"name = "World""#).await?;
    let exec = sb.run(r#"print(f"Hello {name}!")"#).await?;

    // Get the output
    let output = exec.output().await?;
    println!("{}", output); // prints: Hello World!

    sb.stop().await?;
    Ok(())
}
```

--------------------------------

### Configure Sandbox with Options (Go)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/go/README.md

Shows advanced configuration of a sandbox using various options provided by the Go SDK. This includes setting the sandbox name, server URL, namespace, API key, custom logger, and HTTP client with a specific timeout.

```go
// Comprehensive configuration
sandbox := msb.NewNodeSandbox(
    msb.WithName("advanced-sandbox"),
    msb.WithServerUrl("http://localhost:5555"),
    msb.WithNamespace("production"),
    msb.WithApiKey("your-api-key"),
    msb.WithLogger(msb.NewDefaultSlogAdapter()),
    msb.WithHTTPClient(&http.Client{
        Timeout: 30 * time.Second,
    }),
)
```

--------------------------------

### Microsandbox C++ SDK Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/README.md

A basic C++ program demonstrating the usage of the Microsandbox SDK. It includes the necessary header and calls the greet function.

```cpp
#include <iostream>
#include <microsandbox/microsandbox.hpp>

int main() {
    // Print a greeting
    std::string message = microsandbox::greet("World");
    std::cout << message << std::endl;
    return 0;
}
```

--------------------------------

### Reference Swift SDK using Revision

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/swift/DEVELOPMENT.md

Example of how to reference the Swift SDK from a monorepo using a specific commit hash (revision) in Swift Package Manager. Useful for tight integration or testing specific commits.

```swift
.package(url: "https://github.com/yourusername/monorepo.git", .revision("commit-hash"))
```

--------------------------------

### Execute JavaScript and Use Node.js Modules with Microsandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/sandboxes.md

Demonstrates executing JavaScript code and utilizing Node.js built-in modules like 'fs' and 'os' within a Node.js sandbox environment. This example is provided for Python, JavaScript, and Rust clients, showing how to interact with the microsandbox API.

```python
import asyncio
from microsandbox import NodeSandbox

async def main():
    async with NodeSandbox.create(name="node-demo") as sb:
        # Execute JavaScript code
        exec = await sb.run("console.log('Hello from Node.js!');")
        print("Output:", await exec.output())

        # Use Node.js built-in modules
        node_code = """
const fs = require('fs');
const os = require('os');

# Write and read a file
fs.writeFileSync('/tmp/test.txt', 'Hello from Node.js!');
const content = fs.readFileSync('/tmp/test.txt', 'utf8');
console.log('File content:', content);

# Get system info
console.log('Platform:', os.platform());
console.log('Node.js version:', process.version);
        """
        exec = await sb.run(node_code)
        print(await exec.output())

asyncio.run(main())

```

```javascript
import { NodeSandbox } from "microsandbox";

async function main() {
  const sb = await NodeSandbox.create({ name: "node-demo" });

  try {
    // Execute JavaScript code
    const exec = await sb.run("console.log('Hello from Node.js!');");
    console.log("Output:", await exec.output());

    // Use Node.js built-in modules
    const nodeCode = `
const fs = require('fs');
const os = require('os');

// Write and read a file
fs.writeFileSync('/tmp/test.txt', 'Hello from Node.js!');
const content = fs.readFileSync('/tmp/test.txt', 'utf8');
console.log('File content:', content);

// Get system info
console.log('Platform:', os.platform());
console.log('Node.js version:', process.version);
    `;
    const nodeExec = await sb.run(nodeCode);
    console.log(await nodeExec.output());
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);

```

```rust
use microsandbox::{BaseSandbox, NodeSandbox};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut sb = NodeSandbox::create("node-demo").await?;
    sb.start(None).await?;

    // Execute JavaScript code
    let exec = sb.run("console.log('Hello from Node.js!');").await?;
    println!("Output: {}", exec.output().await?);

    // Use Node.js built-in modules
    let node_code = r#"#
const fs = require('fs');
const os = require('os');

// Write and read a file
fs.writeFileSync('/tmp/test.txt', 'Hello from Node.js!');
const content = fs.readFileSync('/tmp/test.txt', 'utf8');
console.log('File content:', content);

// Get system info
console.log('Platform:', os.platform());
console.log('Node.js version:', process.version);
"#;
    let node_exec = sb.run(node_code).await?;
    println!("{}", node_exec.output().await?);

    sb.stop().await?;
    Ok(())
}

```

--------------------------------

### Initialize a Sandbox Project (Shell)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/PROJECTS.md

Initializes a new sandbox project by creating a 'Sandboxfile' in the current directory. This file acts as the manifest for defining sandbox environments.

```shell
msb init
```

--------------------------------

### Execute Commands in Sandbox (Python, JavaScript, Rust)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/guides/getting-started.md

Demonstrates how to run shell commands and execute Python scripts within a sandboxed environment. This involves creating a sandbox instance, running commands like 'ls', and executing a dynamically created Python script. It handles command execution and output retrieval.

```python
import asyncio
from microsandbox import PythonSandbox

async def main():
    async with PythonSandbox.create(name="command-test") as sb:
        # Run shell commands
        result = await sb.command.run("ls", ["-la", "/"])
        print("Directory listing:")
        print(await result.output())

        # Create and execute a script
        await sb.run("""
with open("test.py", "w") as f:
    f.write("print('Hello from sandbox!')")
        """)

        result = await sb.command.run("python", ["test.py"])
        print("Script output:")
        print(await result.output())

asyncio.run(main())
```

```javascript
import { PythonSandbox } from "microsandbox";

async function main() {
  const sb = await PythonSandbox.create({ name: "command-test" });

  try {
    // Run shell commands
    const result = await sb.command.run("ls", ["-la", "/"]);
    console.log("Directory listing:");
    console.log(await result.output());

    // Create and execute a script
    await sb.run(`
with open("test.py", "w") as f:
    f.write("print('Hello from sandbox!')")
    `);

    const scriptResult = await sb.command.run("python", ["test.py"]);
    console.log("Script output:");
    console.log(await scriptResult.output());
  } finally {
    await sb.stop();
  }
}

main().catch(console.error);
```

```rust
use microsandbox::{BaseSandbox, PythonSandbox};
use std::error::Error;

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut sb = PythonSandbox::create("command-test").await?;
    sb.start(None).await?;

    let cmd = sb.command().await?;

    // Run shell commands
    let result = cmd.run("ls", Some(vec!["-la", "/"]), None).await?;
    println!("Directory listing:");
    println!("{}", result.output().await?);

    // Create and execute a script
    sb.run(r#"#
with open("test.py", "w") as f:
    f.write("print('Hello from sandbox!')")
"#, None).await?;

    let script_result = cmd.run("python", Some(vec!["test.py"]), None).await?;
    println!("Script output:");
    println!("{}", script_result.output().await?);

    sb.stop().await?;
    Ok(())
}
```

--------------------------------

### Configure Sandbox Logging (Go)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/go/README.md

Demonstrates how to enable and configure logging for the Microsandbox SDK in Go. It shows how to use the default structured logging adapter and how to integrate a custom logger, such as a slog logger.

```go
// Enable structured logging
logger := msb.NewDefaultSlogAdapter()
sandbox := msb.NewPythonSandbox(
    msb.WithLogger(logger),
)

// Or use a custom logger
customLogger := msb.NewSlogAdapter(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
```

--------------------------------

### Install Microsandbox SDK using CocoaPods

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/objc/README.md

This code snippet shows how to add the Microsandbox SDK to your project's Podfile for installation using CocoaPods. Ensure you have CocoaPods installed and then run 'pod install' in your project directory.

```ruby
pod 'Microsandbox', '~> 0.0.1'
```

--------------------------------

### Install Microsandbox R SDK

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/r/README.md

Instructions for installing the Microsandbox R SDK. Users can install from CRAN for the stable version or from GitHub for the development version.

```r
install.packages("microsandbox")
```

```r
# Install the development version from GitHub
# install.packages("devtools")
devtools::install_github("yourusername/monocore/sdk/r")
```

--------------------------------

### Haskell SDK Basic Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/haskell/README.md

A simple Haskell program demonstrating the basic usage of the Microsandbox SDK. It imports the SDK and uses the 'greet' function to print a greeting message.

```haskell
import Microsandbox

main :: IO ()
main = do
  -- Print a greeting
  greeting <- greet "World"
  putStrLn greeting
```

--------------------------------

### CMake: Create and Install Package Configuration

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/cpp/CMakeLists.txt

This snippet demonstrates how to create and install package configuration files for the microsandbox library using CMake. It configures the package name and version, and installs the generated configuration files, allowing CMake to find and use the installed library.

```cmake
# Create and install package configuration
include(CMakePackageConfigHelpers)
configure_package_config_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/cmake/microsandboxConfig.cmake.in
    ${CMAKE_CURRENT_BINARY_DIR}/microsandboxConfig.cmake
    INSTALL_DESTINATION lib/cmake/microsandbox
)

write_basic_package_version_file(
    ${CMAKE_CURRENT_BINARY_DIR}/microsandboxConfigVersion.cmake
    VERSION ${PROJECT_VERSION}
    COMPATIBILITY SameMajorVersion
)

install(FILES
    ${CMAKE_CURRENT_BINARY_DIR}/microsandboxConfig.cmake
    ${CMAKE_CURRENT_BINARY_DIR}/microsandboxConfigVersion.cmake
    DESTINATION lib/cmake/microsandbox
)
```

--------------------------------

### Monitor Sandbox Resources (Go)

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/go/README.md

Illustrates how to retrieve resource metrics (CPU, Memory, Disk) from a Microsandbox environment using the Go SDK. It shows how to fetch all metrics at once or individual metrics.

```go
// Get comprehensive metrics
metrics, err := sandbox.Metrics().All()
if err != nil {
    log.Fatal(err)
}

fmt.Printf("CPU: %.2f%%, Memory: %d MiB, Disk: %d bytes\n",
    metrics.CPU, metrics.MemoryMiB, metrics.DiskBytes)

// Or get individual metrics
cpu, err := sandbox.Metrics().CPU()
memory, err := sandbox.Metrics().MemoryMiB()
```

--------------------------------

### Start Microsandbox Server in Development Mode

Source: https://github.com/zerocore-ai/microsandbox/blob/main/docs/references/cli.md

Starts the microsandbox server with the `--dev` flag, enabling development mode. This is a common starting point for local development and testing.

```bash
# Start the server in development mode
msb server start --dev
```

--------------------------------

### Basic Java SDK Usage Example

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/java/README.md

This Java code snippet illustrates a basic usage of the Microsandbox SDK. It imports the HelloWorld class and calls its greet method to print a message to the console.

```java
import dev.microsandbox.HelloWorld;

public class Example {
    public static void main(String[] args) {
        // Print a greeting
        HelloWorld.greet("World");
    }
}
```

--------------------------------

### Install Microsandbox OCaml SDK using OPAM

Source: https://github.com/zerocore-ai/microsandbox/blob/main/sdk/ocaml/README.md

Installs the Microsandbox OCaml SDK using the opam package manager. Ensure opam is installed and configured before running this command.

```bash
opam install microsandbox
```

--------------------------------

### Run System-Wide Sandboxes with Microsandbox

Source: https://github.com/zerocore-ai/microsandbox/blob/main/README.md

This demonstrates how to run sandboxes as system-wide executables using the `msi` or `msb install --image` commands. It allows for easy access to frequently used sandboxes by using an alias, defaulting to the image name if no alias is provided. An error occurs if a sandbox with a similar name already exists.

```sh
msi python py-data # or `msb install --image alpine py-data`

py-data # From any directory, run the sandbox
```
Tokens:
Raw