# craftos-mcp (npm · craftos-mcp)

CC:Tweaked (ComputerCraft) emulator: run, test and screenshot Lua programs, monitors and turtles.

- Trust score: 68/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- npm · `craftos-mcp`: 68/100 (this document), [markdown](https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp.md), [page](https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp)

## Channel facts

- Registry: `npm`
- Package: `craftos-mcp`
- Version: `0.7.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 48/100
  - Malware scan not yet available for this package.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 92 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Akkiruk/craftos-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 79/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Tool/resource definitions use about 9446 tokens (~42/item across 221 items; 32 tools + 189 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 17/100
  - Stability observed for 5 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 84/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 51% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 34 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the craftos-mcp server?

craftos-mcp runs locally as an npm package, launched with npx -y craftos-mcp serve. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add akkiruk-craftos-mcp -- npx -y craftos-mcp serve
```

### Cursor

```json
{
  "mcpServers": {
    "akkiruk-craftos-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "craftos-mcp",
        "serve"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "akkiruk-craftos-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "craftos-mcp",
        "serve"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add akkiruk-craftos-mcp -- npx -y craftos-mcp serve
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "akkiruk-craftos-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "craftos-mcp",
        "serve"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add akkiruk-craftos-mcp --command npx --arg -y --arg craftos-mcp --arg serve
```

### Hermes

```yaml
mcp_servers:
  akkiruk-craftos-mcp:
    command: "npx"
    args: ["-y", "craftos-mcp", "serve"]
```

### Netclaw

```json
{
  "McpServers": {
    "akkiruk-craftos-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "craftos-mcp",
        "serve"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add akkiruk-craftos-mcp -t stdio -c npx -a -y craftos-mcp serve
```

### Other

```json
{
  "mcpServers": {
    "akkiruk-craftos-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "craftos-mcp",
        "serve"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-21 (score 68, −14)

- [security regression] Malware scan: pass → unverified
- [functional] Package version: 0.6.1 → 0.7.0

### 2026-11-20 (score 82, +11)

- [security improvement] Known CVEs: unverified → pass
- [functional improvement] Dependency health: unverified → 0.84

### 2026-11-19 (score 71, +5)

- [security regression] Known CVEs: pass → unverified
- [security improvement] Malware scan: unverified → pass
- [functional regression] Dependency health: 0.84 → unverified
- [functional] Package version: 0.5.0 → 0.6.1
- [functional] Package version: 0.5.0 → 0.6.0

### 2026-11-18 (score 66, +11)

- [security improvement] Malware scan: unverified → pass
- [security improvement] Known CVEs: unverified → pass
- [functional regression] Schema quality: 38 → 42
- [functional regression] Schema quality: 8221 → 9113
- [functional improvement] Dependency health: unverified → 0.84
- [functional improvement] Dependency health: unverified → 0.85
- [functional] Package version: 0.4.0 → 0.5.0
- [functional] Package version: 0.4.0 → 0.4.1

### 2026-11-17 (score 55, −10)

- [security regression] Known CVEs: pass → unverified
- [security regression] Malware scan: pass → unverified
- [security improvement] Provenance: fail → pass
- [security] The attested source repository moved: Akkiruk/craftos-mcp
- [functional regression] Dependency health: 0.85 → unverified
- [functional improvement] Tool coverage: 46% → 52%
- [functional improvement] Tool coverage: 46% → 51%
- [functional improvement] Schema quality: fail → pass
- [functional] First check of Schema quality: 100
- [functional] Destructive annotations: All 3 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
- [functional] Package version: 0.2.0 → 0.4.0
- [functional] Package version: 0.2.0 → 0.3.0

### 2026-11-16 (score 65)

First indexed and scored.

## MCP tools (32)

### `craftos_info` (~32 tokens)

Report engine, ROM and workspace status. Check this first; it lists anything missing (engine build, pinned ROM).

### `craftos_write_file` (~56 tokens)

Write a Lua/text file in the workspace (copied to the root of every emulated computer, so paths match a real deployment). Paths are workspace-relative.

Input parameters:

- `content` (string, required)
- `path` (string, required)

### `craftos_read_file` (~22 tokens)

Read a workspace file.

Input parameters:

- `path` (string, required)

### `craftos_list_files` (~24 tokens)

List files in the workspace recursively.

Input parameters:

- `path` (string)

### `craftos_run` (~665 tokens)

Run a workspace program in a fresh emulated CC:Tweaked computer, optionally with monitors attached, and return its exit status (completed, program_failed, timed_out) plus the final text of the terminal and every monitor; a failed program also gets error {kind, message, file, line}. Set screenshots to also get PNG images. Pass snapshot to compare the screens against a golden file. timeoutMs covers copying the workspace too; a run that outlasts it comes back with status timed_out (normal for a program that waits for input forever). The computer gets a copy of the workspace (without .git, node_modules, .runtime and what .gitignore ignores); for a big workspace give world.deploy to copy only some folders.

Input parameters:

- `args` (array): The program's arguments.
- `fullScreens` (boolean): Keep every line, trailing blank ones too (default: lines stop at the last non-blank one).
- `monitors` (array): Monitors attached before it starts.
- `program` (string, required): Workspace-relative path, e.g. "hello.lua" (as on the computer, so a deploy list's target path).
- `scale` (integer): PNG pixels per screen pixel.
- `screenshots` (boolean): Also return a PNG of every screen.
- `snapshot` (object): Compare final screens with __snapshots__/<name>.json (created on first use).
- `timeScale` (number): Virtual clock speed. 10 makes sleep(), os.clock() and os.epoch() run 10x faster than real time, so slow scripts finish quickly. timeoutMs stays in real time.
- `timeoutMs` (integer): Real time before the run stops as timed_out.
- `world` (object): The world around the computer (an object). Fields: addons, version, simProgram, craftosPcApis, motd, players, host, interacting, autoApprove, economyAvailable, holdInteraction, vhcctweaks, economyDel…
- `worldFile` (string): A saved world: a name in the worlds folder (e.g. "advanced-peripherals-demo") or a workspace path to a .json file (e.g. "door.world.json"). Fields in `world` override it.

### `craftos_test` (~644 tokens)

Run *.test.lua files. Inside a test file use the global `ccunit`: test(name, fn [, {timeout}]), eq, neq, near, contains, truthy, raises(fn, pattern), skip, and run(program, {seconds|script, args}) / screen(monitor?) / touch(monitor, x, y) to drive a program and read its screens (craftos_help {topic:"ccunit"}). Each file runs in its own fresh computer; peripherals can be attached with "monitors". timeoutMs is per file and covers copying the workspace; a file that hangs keeps the tests it finished and names the one it was in. The reply gives each file its status, a count of passing tests (named too in runs of up to 50 tests), and every failing test with its error and line. The computer gets a copy of the workspace (without .git, node_modules, .runtime and what .gitignore ignores); for a big workspace give world.deploy to copy only some folders.

Input parameters:

- `budgetMs` (integer): Real time for the whole call (default 10 min). When it runs out, running files stop keeping their finished tests, and notRun lists the rest.
- `monitors` (array)
- `paths` (array): Files or directories; empty runs every *.test.lua.
- `timeScale` (number): Virtual clock speed. 10 makes sleep(), os.clock() and os.epoch() run 10x faster than real time, so slow scripts finish quickly. timeoutMs stays in real time.
- `timeoutMs` (integer)
- `world` (object): The world around the computer (an object). Fields: addons, version, simProgram, craftosPcApis, motd, players, host, interacting, autoApprove, economyAvailable, holdInteraction, vhcctweaks, economyDel…
- `worldFile` (string): A saved world: a name in the worlds folder (e.g. "advanced-peripherals-demo") or a workspace path to a .json file (e.g. "door.world.json"). Fields in `world` override it.

### `craftos_session_create` (~537 tokens)

Start a persistent emulated computer you can type into, click on and watch. Monitors are attached before the shell starts. Workspace files are at the computer's root. Returns once the computer has booted, with front: "shell" (the prompt is up) or "program" (startup.lua started a program that is in front, so there is no prompt). The computer gets a copy of the workspace (without .git, node_modules, .runtime and what .gitignore ignores); for a big workspace give world.deploy to copy only some folders.

Input parameters:

- `liveFiles` (boolean): Give the computer the workspace folder itself instead of a copy: what the program writes lands in the workspace, and files you change there are seen at once. Only when the person asks for it; default…
- `monitors` (array)
- `timeScale` (number): Virtual clock speed. 10 makes sleep(), os.clock() and os.epoch() run 10x faster than real time, so slow scripts finish quickly. timeoutMs stays in real time.
- `world` (object): The world around the computer (an object). Fields: addons, version, simProgram, craftosPcApis, motd, players, host, interacting, autoApprove, economyAvailable, holdInteraction, vhcctweaks, economyDel…
- `worldFile` (string): A saved world: a name in the worlds folder (e.g. "advanced-peripherals-demo") or a workspace path to a .json file (e.g. "door.world.json"). Fields in `world` override it.

### `craftos_network_create` (~208 tokens)

Start several computers on one network, each a normal session (every session tool works on the ids returned) with its own full world. Give each world a different computerId, a position and modem peripherals. Modems follow the real rules: 64 blocks low down, rising to 384 at the top of the world; ender modems reach everything; wired modems link through network, or through block plus the cables of `wired`. rednet from the unmodified ROM works over them. The computer gets a copy of the workspace (without .git, node_modules, .runtime and what .gitignore ignores); for a big workspace give world.deploy to copy only some folders.

Input parameters:

- `computers` (array, required)
- `timeScale` (number): Virtual clock speed. 10 makes sleep(), os.clock() and os.epoch() run 10x faster than real time, so slow scripts finish quickly. timeoutMs stays in real time.
- `wired` (array)

### `craftos_network_update` (~145 tokens)

Change a network from craftos_network_create while it runs: move a computer, right-click a wired modem to switch its computer on or off the network, or unload/load a computer's chunk (loaded).

Input parameters:

- `computer` (string, required): The computer's name.
- `loaded` (boolean): false unloads the computer's chunk (it stops; on 2.2.36 linked computers get peripheral_detach for its peripherals), true loads it again (it boots afresh).
- `modem` (string): Wired modem's peripheral name.
- `network` (string, required): Id from craftos_network_create.
- `on` (boolean)
- `position` (object)

### `craftos_sim_command` (~636 tokens)

Change the simulated world while a session runs. Commands: addPlayer {name}, join/leave {player}, setPlayerPos {player, x, y, z, dimension?}, setComputerPos {x?, y?, z?, dimension?} (move this computer, modems included; on a network use craftos_network_update), unload / load (the computer's chunk unloads and it stops; load boots it afresh), chat {player, message} (fires a chat event), playerClick {player}, setItem {peripheral, slot, item|null}, setEnergy {peripheral, energy} (what a generic energy_storage holds), setFluid {peripheral, tank? (1-based, default 1), fluid {name, amount}|null} (what one tank holds), setEnergyTransferRate {peripheral, rate}, setRedstoneInput {peripheral, side, level}, completeCraft {peripheral, name?} (finish an ME/RS crafting job), setNetworkConnected {peripheral, connected}, setEnvironment {values:{time, raining, thunder, ...}}, addEntity {entity}, attachPeripheral / detachPeripheral / resizeMonitor, insertDisk {peripheral, disk} / ejectDisk {peripheral} (a player puts a floppy into a drive or takes it out: disk / disk_eject), Mekanism QIO: qioSetPowered {block, powered}, qioSetDrive {block, slot, drive|null}, qioSetSecurity {block, mode}, qioSetUpgrades {block, speed}, qioInsert/qioExtract {frequency, item}, Quantum Entangloporter: qeInsert {frequency, item, public?, owner?}, qeExtract {frequency, count?}, qeSetLoaded {block, loaded} (see docs/mekanism-qio.md), seed {value} (pin math.random), advance {seconds} (jump the virtual clock and fire due timers). With the vhcctweaks addon also: interact {player} (right-click the computer), approve {player?, nonce?} (click [APPROVE]), revoke {player?}, setBalance {player, balance}, setHost {player?}, setEconomy {available}, rcExec {player, code}, setVaultLevel / setEquipment / setOnOtherServer (2.2.36), setGearPower / setTemper / setReputation / setGreedTier / setSkills / setStats (2.2.37), internalError {function, times?}, setEconomyDelay {ticks}, refuseTransfers {times?}; craftos_help {topic…

Input parameters:

- `command` (object, required): A command object, e.g. {cmd:'interact', player:'Alice'}.
- `delta` (boolean): Return only what changed since the previous call.
- `id` (string, required): Id returned by craftos_session_create.

### `craftos_sim_state` (~156 tokens)

Read the simulated world state of a session: chat messages, the computer's own redstone (redstone.outputs per side, inputs, bundledOutputs), virtual inventory contents, peripheral state (speakers, detectors, ME/RS bridges, QIO), the turtle and its block world; with the vhcctweaks addon also token balances, the transaction ledger, the host and who is authenticated. delta:true returns only what changed since the previous sim call (changed values as {from,to}, new chat and ledger entries as `appended`), which is usually a few lines.

Input parameters:

- `delta` (boolean): Return only what changed since the previous call.
- `id` (string, required): Id returned by craftos_session_create.

### `craftos_session_list` (~71 tokens)

List live sessions: `sessions` are yours; `others` (only when there are any) are computers someone else started, such as a person in the viewer, with who owns each. You can look at and drive those too, but craftos_session_destroy leaves them running unless you pass force.

### `craftos_session_destroy` (~77 tokens)

Stop a session and delete its scratch data. A session someone else started (craftos_session_list's `others`) is left running with an error naming its owner, unless force is true.

Input parameters:

- `force` (boolean): Stop it even if someone else started it.
- `id` (string, required): Id returned by craftos_session_create.

### `craftos_type` (~55 tokens)

Type text into the computer, like a player at the keyboard. enter presses Enter afterwards.

Input parameters:

- `enter` (boolean)
- `id` (string, required): Id returned by craftos_session_create.
- `text` (string, required)

### `craftos_key` (~150 tokens)

Press a key by name (enter, backspace, up, down, left, right, tab, escape, f1..f12, a..z, ...), with ctrl:true or shift:true held around it. A tap of ctrl+t does not terminate, as in the game: pass holdMs to hold the key down instead (key repeats every tick), and holding ctrl+t for 1000 ms or more sends `terminate`.

Input parameters:

- `ctrl` (boolean)
- `holdMs` (integer): Hold the key this long instead of tapping it.
- `id` (string, required): Id returned by craftos_session_create.
- `key` (string, required)
- `shift` (boolean)

### `craftos_touch_monitor` (~93 tokens)

Click a monitor cell (1-based x,y), producing a monitor_touch event like a player right-clicking it. player names who touches (default: the interacting player); an unknown name is an error.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `monitor` (string, required)
- `player` (string)
- `x` (integer, required)
- `y` (integer, required)

### `craftos_ui` (~197 tokens)

Describe every screen as data instead of a picture: solid rectangles (buttons, cards, panels) and, for text-mode screens, text runs with colours, plus what the program is waiting for. Works for any script. Default format is compact: each rectangle is one string "NAME #colour x,y WxH @cx,cy" where NAME is a label you set with craftos_labels and @cx,cy is the cell to touch. delta:true returns only what changed since the previous craftos_ui / craftos_script view (use it after every action). format:"full" gives the raw objects. Use instead of craftos_screenshot to find and verify things.

Input parameters:

- `delta` (boolean): Return only what changed since the previous call.
- `format` (string)
- `id` (string, required): Id returned by craftos_session_create.
- `minArea` (integer): Smallest rectangle area (cells) to report.

### `craftos_expect` (~178 tokens)

Assert instead of look. Waits for the program to settle, checks the expectations and returns only {pass, failures}. A failure carries the reason and the closest things that do exist (nearest rectangles by colour, nearby text, the actual sim value), and the session saves PNGs plus a JSON dump to disk (`evidence`) that you open only if the text is not enough. Costs a few lines; prefer it over craftos_ui when you know what you expect.

Input parameters:

- `evidence` (boolean)
- `expect` (array, required)
- `id` (string, required): Id returned by craftos_session_create.
- `settle` (boolean)
- `timeoutMs` (integer)
- `waitMs` (integer): Keep re-checking for this long before failing: games animate with timers, so a screen can be still between frames.

### `craftos_script` (~194 tokens)

Run many steps in one call and get one compact result: [{touch:{name:"HIT"}}, {expect:[{text:"You win"}]}, {advance:30}, ...]. Every touch/key/text waits until the program consumed it and the screen settled; a step fails if the program ignored the input (unless lenient). Stops at the first failure (stopOnFail:false to continue), returns only the failing steps with reasons and nearest matches, saves evidence files, and ends with a compact delta of the screens (ui:"none"|"delta"|"full"). One call replaces dozens of act/ui round trips.

Input parameters:

- `evidence` (boolean)
- `id` (string, required): Id returned by craftos_session_create.
- `quietMs` (integer)
- `steps` (array, required)
- `stopOnFail` (boolean)
- `timeoutMs` (integer)
- `ui` (string)

### `craftos_labels` (~186 tokens)

Name UI elements by colour (and optionally monitor and region) so every later call can say touch {name:"DOUBLE"} or expect {rect:{name:"HIT"}} instead of coordinates. Pixel-font text cannot be read, so read a label off one screenshot once, then label it. set: {NAME: {color:"#f15c5c", peripheral?, region?:{x1,y1,x2,y2}}}. save/load persist them in worlds/labels/<file>.json so they survive sessions. craftos_ui shows the names inline. Call with nothing to list.

Input parameters:

- `clear` (boolean)
- `id` (string, required): Id returned by craftos_session_create.
- `load` (string): Load labels saved earlier.
- `remove` (array)
- `save` (string): Save the labels as this name.
- `set` (object)

### `craftos_trace` (~118 tokens)

What happened since the last call, without screenshots: events the program was handed (keys, touches, chat, ...), everything it printed, errors (uncaught Lua errors and printError), how many screen updates occurred, engine stderr, and whether it is still running. Call it right after something unexpected to see why. Output is capped to the newest lines.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `maxLines` (integer)
- `reset` (boolean): Discard what has accumulated and return nothing.

### `craftos_seed` (~85 tokens)

Pin math.random to a seed on a running session, and make the program's own math.randomseed calls no-ops, so shuffles, dice and loot are reproducible. For a fixed seed from boot pass world.seed to craftos_session_create / craftos_run.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `value` (integer, required)

### `craftos_advance` (~106 tokens)

Jump the virtual clock forward by N seconds and fire every timer that falls due in that window (earliest first), so sleep(), timeouts, countdowns and inactivity logic pass instantly and deterministically. os.clock()/os.epoch() move too. Timers due later keep their real deadline. Then waits for the program to settle.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `seconds` (number, required)
- `timeoutMs` (integer)

### `craftos_clock` (~228 tokens)

The clock of every computer at once (the same controls as the browser app's bar): pause (every computer stops at its next yield, then the clock stands still; no 'too long without yielding'), resume (timers go on where they were, nothing fires in a burst), step (pause and run `ticks` ticks of 1/20 s), speed (1-1000 times faster, or "max": skip idle time to the next timer), jump (`amount` ahead, e.g. "90s", "5m", "2h", "1d" = a Minecraft day; the timers on the way fire one at a time, in order, and the programs run between them, so a sleep loop runs every round that fits), time (set the time of day, "18:00"), status. Returns paused, speed and the world's time of day. For one computer's own jump use craftos_advance.

Input parameters:

- `action` (string, required)
- `amount` (string)
- `speed`
- `ticks` (integer)

### `craftos_world_snapshot` (~189 tokens)

Save the whole world (every session's files and label, players, items, chat, peripherals, a turtle's blocks, the time of day) under a name, list the saved ones, restore one (each computer reboots into it; sessions that are gone are made again, the viewer's computers made after it are closed, other sessions are left alone; a computer on a person's folder, live, has that folder put back exactly: changed files written back, files made since removed, a copy of each in `folders[].backup`), delete one, or move one as a .craftos-world file: export writes it to `file`, import reads `file`. The browser app's Snapshots button uses the same ones.

Input parameters:

- `action` (string, required)
- `file` (string): export/import: a path, relative to the workspace
- `name` (string)

### `craftos_settle` (~67 tokens)

Wait until the program is blocked waiting for input and nothing on screen has changed for quietMs. Replaces fixed sleeps after any action.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `quietMs` (integer)
- `timeoutMs` (integer)

### `craftos_act` (~126 tokens)

Send one input (touch a monitor cell, press a key, or type text), wait until the program actually consumed it, then wait for the screen to settle. Returns `consumed` (false = the program was not listening for that input) and the new waiting state; follow with craftos_ui to read the result.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `key` (string)
- `quietMs` (integer)
- `text` (string)
- `timeoutMs` (integer)
- `touch` (object)

### `craftos_send_event` (~61 tokens)

Queue an arbitrary Lua event, e.g. name 'timer' with params [3], or 'redstone'.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `name` (string, required)
- `params` (array)

### `craftos_wait_for_text` (~77 tokens)

Wait until text appears on the terminal (window 0) or a monitor window.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `text` (string, required)
- `timeoutMs` (integer)
- `window` (integer): 0 = terminal; see craftos_session_list for monitor windows.

### `craftos_read_terminal` (~106 tokens)

Read the current text of the terminal and every monitor. delta:true gives a screen that has not changed since the previous read_terminal of this session as just {window, peripheral?, unchanged: true}.

Input parameters:

- `delta` (boolean): Return only what changed since the previous call.
- `fullScreens` (boolean): Keep every line, trailing blank ones too (default: lines stop at the last non-blank one).
- `id` (string, required): Id returned by craftos_session_create.

### `craftos_screenshot` (~44 tokens)

Take PNG screenshots of the terminal and every monitor of a session.

Input parameters:

- `id` (string, required): Id returned by craftos_session_create.
- `scale` (integer)

### `craftos_help` (~84 tokens)

How to use this server, on request: topic "guide" (the workflow and the facts that bite), "world" (the full JSON Schema of `world`, every field described), "ccunit" (the test API), "worlds" (saved worlds for worldFile), "docs" (docs and examples to read).

Input parameters:

- `topic` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp#diagnostics

## Score history

- 2026-11-21: 68
- 2026-11-20: 82
- 2026-11-19: 71
- 2026-11-18: 66
- 2026-11-17: 55
- 2026-11-16: 65

## Common questions

### What is the craftos-mcp server?

craftos-mcp is listed in the public MCP registry as io.github.Akkiruk/craftos-mcp. CC:Tweaked (ComputerCraft) emulator: run, test and screenshot Lua programs, monitors and turtles. This page covers its npm package (craftos-mcp).

### Is the craftos-mcp server safe to use?

craftos-mcp scores 68 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the craftos-mcp server expose?

craftos-mcp exposes 32 tools: craftos_info, craftos_write_file, craftos_read_file, craftos_list_files, craftos_run, and 27 more. Their descriptions and schemas cost roughly 5,617 tokens of context every time the server is loaded.

### Is the craftos-mcp server still maintained?

craftos-mcp is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the craftos-mcp server under?

craftos-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the craftos-mcp server?

VerifyMCP ran 15 checks on craftos-mcp, covering Known CVEs, Install scripts, Dependency health, Source repository and 11 more. One item could not be completed, a gap on our side rather than a finding about craftos-mcp: Malware scan. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/craftos-mcp
- Socket report: https://socket.dev/npm/package/craftos-mcp
- Repository: https://github.com/Akkiruk/craftos-mcp
- Changelog RSS feed: https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp.json
- HTML version of this page: https://verifymcp.io/servers/akkiruk-craftos-mcp/craftos-mcp
