# image-crop-rotate

Adopt this skill: https://proskills.md/skills/other/instavm-coderunner-skills-public-image-crop-rotate

Page: https://proskills.md/skills/other/instavm-coderunner-skills-public-image-crop-rotate
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/public/image-crop-rotate/SKILL.md
size: 2401
upstream: https://github.com/instavm/coderunner/blob/main/skills/public/image-crop-rotate/SKILL.md

````text
---
name: image-crop-rotate
description: Image processing skill for cropping images to 50% from center and rotating them 90 degrees clockwise. This skill should be used when users request image cropping to center, image rotation, or both operations combined on image files.
---

# Image Crop and Rotate

## Overview

This skill provides functionality to crop images to 50% of their original size from the center and rotate them 90 degrees clockwise. It uses a reliable Python script with PIL/Pillow for consistent, high-quality image processing.

## When to Use This Skill

Use this skill when the user requests:
- Cropping an image to 50% from the center
- Rotating an image 90 degrees (clockwise)
- Both cropping and rotating an image
- Image processing tasks that combine center cropping with rotation

## How to Use This Skill

### Overview

The skill provides a single script that performs both operations: cropping to 50% from center and rotating 90 degrees clockwise.

### Process

1. **Identify the input image**: Locate the user's uploaded image file in `/mnt/user-data/uploads/`

2. **Execute the script**: Run the `crop_and_rotate.py` script with input and output paths:
   ```bash
   python scripts/crop_and_rotate.py <input_path> <output_path>
   ```

3. **Provide the result**: Move the processed image to `/mnt/user-data/outputs/` and share it with the user

### Script Details

**`scripts/crop_and_rotate.py`**

This script performs two operations in sequence:
1. Crops the image to 50% of its original size, centered
2. Rotates the cropped image 90 degrees clockwise

**Usage:**
```bash
python scripts/crop_and_rotate.py input.jpg output.jpg
```

**Arguments:**
- First argument: Path to input image
- Second argument: Path to save processed image

**Supported formats:** Any format supported by PIL/Pillow (JPEG, PNG, GIF, BMP, TIFF, etc.)

**Output:** The script prints processing details including original size, cropped size, and final size

### Example Workflow

```bash
# Process an uploaded image
python /mnt/user-data/skills/image-crop-rotate/scripts/crop_and_rotate.py \
    /mnt/user-data/uploads/photo.jpg \
    /mnt/user-data/outputs/photo_processed.jpg
```

The script will:
1. Open the input image
2. Crop it to 50% from the center (e.g., 1000x800 → 500x400)
3. Rotate the cropped image 90° clockwise (e.g., 500x400 → 400x500)
4. Save the result to the output path
````

## File: README.md
upstream: https://github.com/instavm/coderunner/blob/main/README.md

````text

<div align="center">

[![Start](https://img.shields.io/github/stars/instavm/coderunner?color=yellow&style=flat&label=%E2%AD%90%20stars)](https://github.com/instavm/coderunner/stargazers)
[![License](http://img.shields.io/:license-Apache%202.0-green.svg?style=flat)](https://github.com/instavm/coderunner/blob/master/LICENSE)
</div>

# CodeRunner: A local sandbox for your AI agents

CodeRunner helps you sandbox your AI agents and its actions inside a sandbox. 

**Key use case:** Run AI agent code in a sandbox with explicitly chosen host mounts and network access. Isolation reduces risk; it does not prevent all data loss or exfiltration.

For cloud managed VMs for agents, we have launched - [InstaVM - Instant computers for AI agents](https://instavm.io)

## Quick Start

**Prerequisites:** Mac with macOS and Apple Silicon (M1/M2/M3/M4), Python 3.10+

### Credentials

The installer generates the sandbox token in `~/.coderunner/api-token` (or saves
the `CODERUNNER_API_TOKEN` you exported). Clients send it as
`Authorization: Bearer <token>`; `cat ~/.coderunner/api-token` prints it. Only
`GET /health` is public, and a missing or weak token fails closed. The Claude
Desktop proxy and the examples read the token from that file when the variable
is not set. See [authentication and network boundaries](AUTHENTICATION.md).

```bash
git clone https://github.com/instavm/coderunner.git
cd coderunner
chmod +x install.sh
./install.sh
```

### Stop and resume

Stop the sandbox when you are done:

```bash
container stop coderunner
```

Resume the same sandbox later, preserving its filesystem. Python kernel state is
volatile and does not survive a VM or server restart:

```bash
container start coderunner
```

To start over with a clean sandbox, delete the container and run the installer again:

```bash
container delete coderunner && ./install.sh
```

### Resource limits and workspace mounts

CPU and memory limits can be set with installer options or the `CODERUNNER_CPUS` and `CODERUNNER_MEMORY` environment variables:

```bash
./install.sh --cpus 4 --memory 8g
```

Additional host directories must be mounted under `/workspace`. They are read-only by default; add `:rw` only when the sandbox needs to write to the host:

```bash
./install.sh \
  --mount "$HOME/projects/api:/workspace/api" \
  --mount "$HOME/projects/output:/workspace/output:rw"
```

Extra mounts default to none. Resource and mount settings are fixed when the container is created; delete the container before changing them.

### Disable outbound network access

By default, code running in the sandbox has unrestricted network access. To run it on a host-only network with no internet access:

```bash
CODERUNNER_NETWORK=none ./install.sh
```

In this mode, the MCP server is available at `http://127.0.0.1:8222/mcp`. The setting is fixed when the container is created; the installer refuses to resume a container with a different network mode.

### With Claude Code

Claude Code runs commands on your machine, as you, with permission prompts as the only boundary. Pointing it at
CodeRunner's tools instead runs the code it writes in the VM: it can only touch the folders you mounted under
`/workspace`, the network you allowed, and the sandbox's own filesystem, whatever it was told to do. Use the
sandbox for code that handles untrusted input or that you would not run by hand, and for several agents that
must not share state (named sessions). It does not protect anything you mount read-write.

## Run Claude Code inside a Sandbox

`./install.sh` (if not already done)

`container exec -it coderunner /bin/bash`

`root@coderunner:/app# npm install -g @anthropic-ai/claude-code`

<img width="741" height="410" alt="image" src="https://github.com/user-attachments/assets/620490cb-4e85-4c37-bc57-ab2fa1762c78" />

## Other Integration Options

MCP server will be available at: `http://coderunner.local:8222/mcp`

The installer creates `~/.coderunner/venv` for the Claude Desktop proxy. For the other Python examples, install their dependencies in your own virtualenv:

```bash
pip install -r examples/requirements.txt
```

#### 1. Claude Desktop Integration

<details>
<summary>Configure Claude Desktop to use CodeRunner as an MCP server:</summary>

![demo1](images/demo.png)

![demo2](images/demo2.png)

![demo4](images/demo4.png)

1. **Copy the example configuration:**
   ```bash
   cd examples
   cp claude_desktop/claude_desktop_config.example.json claude_desktop/claude_desktop_config.json
   ```

2. **Edit the configuration file** and replace the placeholder paths:
   - Replace `/path/to/your/python` with `$HOME/.coderunner/venv/bin/python` using the full path to your home directory
   - Replace `/path/to/coderunner` with the actual path to your cloned repository

   Example after editing:
   ```json
   {
     "mcpServers": {
       "coderunner": {
         "command": "/Users/yourname/.coderunner/venv/bin/python",
         "args": ["/Users/yourname/coderunner/examples/claude_desktop/mcpproxy.py"]
       }
     }
   }
   ```

3. **Update Claude Desktop configuration:**
   - Open Claude Desktop
   - Go to Settings → Developer
   - Add the MCP server configuration
   - Restart Claude Desktop

4. **Start using CodeRunner in Claude:**
   Code Claude writes now runs in the sandbox.

   If the tool shows as "Disabled" in the chat's tool menu although the server is listed as running: quit Claude
   Desktop fully (Cmd-Q) and open it again, make sure `command` is the venv python the installer printed (it
   has `fastmcp`), and read `~/Library/Logs/Claude/mcp-server-coderunner.log` for the proxy's error. The proxy
   needs the sandbox running (`container list`) and the token file `~/.coderunner/api-token`.
</details>

#### 2. Claude Code CLI

<details>
<summary>Use CodeRunner with Claude Code CLI for terminal-based AI assistance:</summary>

**Quick Start:**

```bash
# 1. Install and start CodeRunner (one-time setup; run as yourself, it asks for sudo when it needs it)
git clone https://github.com/instavm/coderunner.git
cd coderunner
./install.sh

# 2. Add the sandbox with its token (the installer prints this command)
claude mcp add --transport http coderunner http://coderunner.local:8222/mcp \
  --header "Authorization: Bearer $(cat ~/.coderunner/api-token)"

# 3. Reconnect to MCP servers
/mcp
```

The Claude Code plugin (`claude plugin marketplace add https://github.com/instavm/coderunner-plugin`) predates
the token and gets 401 until it sends the same header; use the command above until the plugin is updated.

**Installation Steps:**

1. Navigate to Plugin Marketplace:

   ![Navigate to Plugin Marketplace](images/gotoplugin.png)

2. Add the InstaVM repository:

   ![Add InstaVM Repository](images/addrepo.png)

3. Execute Python code with Claude Code:

   ![Execute Python Code](images/runcode.png)

That's it! Claude Code now has access to all CodeRunner tools:
- **execute_python_code** - Run Python code in persistent Jupyter kernel
- **start_python_session** - Reserve an isolated kernel for a named session
- **list_python_sessions** - List active named sessions
- **stop_python_session** - Stop a session and discard its kernel state
- **navigate_and_get_all_visible_text** - Web scraping with Playwright
- **list_skills** - List available skills (docx, xlsx, pptx, pdf, image processing, etc.)
- **get_skill_info** - Get documentation for specific skills
- **get_skill_file** - Read skill files and examples

Pass the returned `session_id` to `execute_python_code` to keep state isolated between agents. Up to five named sessions can run concurrently.

**Learn more:** See the [plugin repository](https://github.com/instavm/coderunner-plugin) for detailed documentation.

</details>

#### 3. OpenCode Configuration

<details>
<summary>Configure OpenCode to use CodeRunner as an MCP server:</summary>

![OpenCode Example](images/opencode-example.png)

Create or edit `~/.config/opencode/opencode.json`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mc
````
