mindcraft 0.1.4-0

package/src/mindcraft/public/settings_spec.json

@@ -0,0 +1,145 @@
+{
+    "profile": {
+        "type": "object",
+        "required": true,
+        "description": "The profile object to use, including name, prompts, and examples"
+    },
+    "data_dir": {
+        "type": "string",
+        "description": "Directory where bot memories, histories, screenshots, and generated code are written",
+        "default": "./bots"
+    },
+    "minecraft_version": {
+        "type": "string",
+        "description": "The version of Minecraft to use. Set to 'auto' to automatically detect the version.",
+        "default": "auto"
+    },
+    "host": {
+        "type": "string",
+        "description": "The minecraft server host address to connect to",
+        "default": "127.0.0.1"
+    },
+    "port": {
+        "type": "number",
+        "description": "The minecraft server port to connect to. -1 for auto-detect.",
+        "default": 55916
+    },
+    "auth": {
+        "type": "string",
+        "description": "The authentication method to use",
+        "default": "offline",
+        "options": ["offline", "microsoft"]
+    },
+    "base_profile": {
+        "type": "string",
+        "description": "Allowed values: survival, assistant, creative, god_mode. Each has fine tuned settings for different game modes.",
+        "default": "survival",
+        "options": ["survival", "assistant", "creative", "god_mode"]
+    },
+    "load_memory": {
+        "type": "boolean",
+        "description": "Whether to load bot's previous memory",
+        "default": false
+    },
+    "init_message": {
+        "type": "string",
+        "description": "The initial message to send to the bot",
+        "default": "Respond with hello world and your name"
+    },
+    "only_chat_with": {
+        "type": "array",
+        "description": "List of agents to only chat with. If empty, the bot will chat publicly",
+        "default": []
+    },
+    "speak": {
+        "type": "boolean",
+        "description": "Whether to enable text-to-speech reading on the host machine",
+        "default": false
+    },
+    "language": {
+        "type": "string",
+        "description": "The language to automatically translate to and from using google translate",
+        "default": "en"
+    },
+    "allow_vision": {
+        "type": "boolean",
+        "description": "Whether to allow vision capabilities",
+        "default": false
+    },
+    "blocked_actions": {
+        "type": "array",
+        "description": "List of actions that are blocked",
+        "default": ["!checkBlueprint", "!checkBlueprintLevel", "!getBlueprint", "!getBlueprintLevel"]
+    },
+    "relevant_docs_count": {
+        "type": "number",
+        "description": "Number of relevant function documents to include in the prompt for LLM code writing",
+        "default": 5
+    },
+    "max_messages": {
+        "type": "number",
+        "description": "Maximum number of recent messages to keep in context for LLM",
+        "default": 15
+    },
+    "num_examples": {
+        "type": "number",
+        "description": "Number of examples to select to help prompt better LLM responses",
+        "default": 2
+    },
+    "max_commands": {
+        "type": "number",
+        "description": "Maximum number of commands allowed in consecutive responses. -1 for no limit",
+        "default": -1
+    },
+    "narrate_behavior": {
+        "type": "boolean",
+        "description": "Whether to openly chat automatic behavior like 'Picking up item!'",
+        "default": true
+    },
+    "log_all_prompts": {
+        "type": "boolean",
+        "description": "Whether to log all prompts to file. Can be very verbose.",
+        "default": false
+    },
+    "show_command_syntax": {
+        "type": "string",
+        "description": "Whether to show \"full\" command syntax, \"shortened\" command syntax, or \"none\"",
+        "default": "full",
+        "options": ["full", "shortened", "none"]
+    },
+    "chat_ingame": {
+        "type": "boolean",
+        "description": "Whether to show bot's chat messages in game chat",
+        "default": true
+    },
+    "chat_bot_messages": {
+        "type": "boolean",
+        "description": "Whether to publicly chat messages to and from other bots",
+        "default": true
+    },
+    "render_bot_view": {
+        "type": "boolean",
+        "description": "Whether to render bot view for user observation. Does not give bot vision.",
+        "default": false
+    },
+    "allow_insecure_coding": {
+        "type": "boolean",
+        "description": "Whether to allow newAction command that let's LLM write/run code on host computer. Despite sandboxxing, it is potentially insecure.",
+        "default": false
+    },
+    "code_timeout_mins": {
+        "type": "number",
+        "description": "Number of minutes to allow code execution. -1 for no timeout",
+        "default": -1
+    },
+    "task": {
+        "type": "object",
+        "description": "The task object to give the agent on start. If null, the agent will not have a task.",
+        "default": null
+    },
+    "spawn_timeout": {
+        "type": "number",
+        "description": "Number of seconds allowed for the bot to spawn before throwing an error. Increase when spawning takes a while.",
+        "default": 30
+    }
+}

package/src/mindcraft/userconfig.js

@@ -0,0 +1,72 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, chmodSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// Persistence layer used by the web UI's setup wizard.
+// Keeps API keys, server config, and saved profiles across restarts.
+// Follows the XDG base-dir convention: $XDG_CONFIG_HOME/mindcraft, falling
+// back to ~/.config/mindcraft.
+
+const CONFIG_HOME = process.env.XDG_CONFIG_HOME || join(homedir(), '.config');
+const ROOT = join(CONFIG_HOME, 'mindcraft');
+const CONFIG_PATH = join(ROOT, 'config.json');
+const KEYS_PATH = join(ROOT, 'keys.json');
+const PROFILES_DIR = join(ROOT, 'profiles');
+const BOTS_DIR = join(ROOT, 'bots');
+
+export const paths = { ROOT, CONFIG_PATH, KEYS_PATH, PROFILES_DIR, BOTS_DIR };
+
+function readJson(path) {
+    if (!existsSync(path)) return null;
+    try { return JSON.parse(readFileSync(path, 'utf8')); }
+    catch { return null; }
+}
+
+function writeJson(path, data, mode) {
+    mkdirSync(ROOT, { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2));
+    if (mode) chmodSync(path, mode);
+}
+
+export function getConfig() {
+    return readJson(CONFIG_PATH);
+}
+
+export function saveConfig(config) {
+    writeJson(CONFIG_PATH, config);
+}
+
+export function hasKeys() {
+    const k = readJson(KEYS_PATH);
+    return !!k && Object.values(k).some(v => v);
+}
+
+export function loadKeysIntoEnv() {
+    const k = readJson(KEYS_PATH);
+    if (!k) return;
+    for (const [name, value] of Object.entries(k)) {
+        if (value && !process.env[name]) process.env[name] = value;
+    }
+}
+
+export function saveKeys(keys) {
+    const existing = readJson(KEYS_PATH) || {};
+    writeJson(KEYS_PATH, { ...existing, ...keys }, 0o600);
+    for (const [name, value] of Object.entries(keys)) {
+        if (value) process.env[name] = value;
+    }
+}
+
+export function listProfiles() {
+    if (!existsSync(PROFILES_DIR)) return [];
+    return readdirSync(PROFILES_DIR)
+        .filter(f => f.endsWith('.json'))
+        .map(f => readJson(join(PROFILES_DIR, f)))
+        .filter(p => p && p.name);
+}
+
+export function saveProfile(profile) {
+    if (!profile?.name) throw new Error('profile.name is required');
+    mkdirSync(PROFILES_DIR, { recursive: true });
+    writeJson(join(PROFILES_DIR, `${profile.name}.json`), profile);
+}

package/src/mindcraft-py/example.py

@@ -0,0 +1,27 @@
+import mindcraft
+import json
+import os
+
+# Initialize Mindcraft, starting the Node.js server
+# This will also connect to the MindServer via websockets
+mindcraft.init()
+
+# Get the directory of the current script
+script_dir = os.path.dirname(os.path.abspath(__file__))
+profile_path = os.path.abspath(os.path.join(script_dir, '..', '..', 'andy.json'))
+
+# Load agent settings from a JSON file
+try:
+    with open(profile_path, 'r') as f:
+        profile_data = json.load(f)
+    
+    settings = {"profile": profile_data}
+    mindcraft.create_agent(settings)
+
+    settings_copy = settings.copy()
+    settings_copy['profile']['name'] = 'andy2'
+    mindcraft.create_agent(settings_copy)
+except FileNotFoundError:
+    print(f"Error: Could not find andy.json at {profile_path}")
+
+mindcraft.wait()

package/src/mindcraft-py/init-mindcraft.js

@@ -0,0 +1,24 @@
+import * as Mindcraft from '../mindcraft/mindcraft.js';
+import settings from '../../settings.js';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+
+function parseArguments() {
+    return yargs(hideBin(process.argv))
+        .option('mindserver_port', {
+            type: 'number',
+            describe: 'Mindserver port',
+            default: settings.mindserver_port
+        })
+        .help()
+        .alias('help', 'h')
+        .parse();
+}
+
+const args = parseArguments();
+
+settings.mindserver_port = args.mindserver_port;
+
+Mindcraft.init(settings.mindserver_port);
+
+console.log(`Mindcraft initialized with MindServer at localhost:${settings.mindserver_port}`); 

package/src/mindcraft-py/mindcraft.py

@@ -0,0 +1,99 @@
+import subprocess
+import socketio
+import time
+import json
+import os
+import atexit
+import threading
+import sys
+import signal
+
+class Mindcraft:
+    def __init__(self):
+        self.sio = socketio.Client()
+        self.process = None
+        self.connected = False
+        self.log_thread = None
+
+    def _log_reader(self):
+        for line in iter(self.process.stdout.readline, ''):
+            sys.stdout.write(f'[Node.js] {line}')
+            sys.stdout.flush()
+
+    def init(self, port=8080):
+        if self.process:
+            return
+
+        self.port = port
+        
+        node_script_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'init-mindcraft.js'))
+        
+        self.process = subprocess.Popen([
+            'node',
+            node_script_path,
+            '--mindserver_port', str(self.port)
+        ], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, bufsize=1)
+        
+        self.log_thread = threading.Thread(target=self._log_reader)
+        self.log_thread.daemon = True
+        self.log_thread.start()
+
+        atexit.register(self.shutdown)
+        time.sleep(2) # Give server time to start before connecting
+
+        try:
+            self.sio.connect(f'http://localhost:{self.port}')
+            self.connected = True
+            print("Connected to MindServer. Mindcraft is initialized.")
+        except socketio.exceptions.ConnectionError as e:
+            print(f"Failed to connect to MindServer: {e}")
+            self.shutdown()
+            raise
+
+    def create_agent(self, settings_json):
+        if not self.connected:
+            raise Exception("Not connected to MindServer. Call init() first.")
+        
+        profile_data = settings_json.get('profile', {})
+        
+        def callback(response):
+            if response.get('success'):
+                print(f"Agent '{profile_data.get('name')}' created successfully")
+            else:
+                print(f"Error creating agent: {response.get('error', 'Unknown error')}")
+
+        self.sio.emit('create-agent', settings_json, callback=callback)
+
+    def shutdown(self):
+        if self.sio.connected:
+            self.sio.disconnect()
+            self.connected = False
+        if self.process:
+            self.process.terminate()
+            self.process.wait()
+            self.process = None
+        print("Mindcraft shut down.")
+
+    def wait(self):
+        """Block the main thread until Ctrl+C is pressed so the server stays up,"""
+        print("Server is running. Press Ctrl+C to exit.")
+        try:
+            while True:
+                time.sleep(1)
+        except KeyboardInterrupt:
+            print("\nCtrl+C detected. Exiting...")
+            self.shutdown()
+
+mindcraft_instance = Mindcraft()
+
+def init(port=8080):
+    mindcraft_instance.init(port)
+
+def create_agent(settings_json):
+    mindcraft_instance.create_agent(settings_json)
+    
+def shutdown():
+    mindcraft_instance.shutdown()
+
+def wait():
+    mindcraft_instance.wait()

package/src/models/_model_map.js

@@ -0,0 +1,89 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Dynamically discover model classes in this directory.
+// Each model class must export a static `prefix` string.
+const apiMap = await (async () => {
+    const map = {};
+    const files = (await fs.readdir(__dirname))
+        .filter(f => f.endsWith('.js') && f !== '_model_map.js' && f !== 'prompter.js');
+    for (const file of files) {
+        try {
+            const moduleUrl = pathToFileURL(path.join(__dirname, file)).href;
+            const mod = await import(moduleUrl);
+            for (const exported of Object.values(mod)) {
+                if (typeof exported === 'function' && Object.prototype.hasOwnProperty.call(exported, 'prefix')) {
+                    const prefix = exported.prefix;
+                    if (typeof prefix === 'string' && prefix.length > 0) {
+                        map[prefix] = exported;
+                    }
+                }
+            }
+        } catch (e) {
+            console.warn('Failed to load model module:', file, e?.message || e);
+        }
+    }
+    return map;
+})();
+
+export function selectAPI(profile) {
+    if (typeof profile === 'string' || profile instanceof String) {
+        profile = {model: profile};
+    }
+    // backwards compatibility with local->ollama
+    if (profile.api?.includes('local') || profile.model?.includes('local')) {
+        profile.api = 'ollama';
+        if (profile.model) {
+            profile.model = profile.model.replace('local', 'ollama');
+        }
+    }
+    if (!profile.api) {
+        const api = Object.keys(apiMap).find(key => profile.model?.startsWith(key));
+        if (api) {
+            profile.api = api;
+        }
+        else {
+            // check for some common models that do not require prefixes
+            if (profile.model.includes('gpt') || profile.model.includes('o1')|| profile.model.includes('o3'))
+                profile.api = 'openai';
+            else if (profile.model.includes('claude'))
+                profile.api = 'anthropic';
+            else if (profile.model.includes('gemini'))
+                profile.api = "google";
+            else if (profile.model.includes('grok'))
+                profile.api = 'xai';
+            else if (profile.model.includes('mistral'))
+                profile.api = 'mistral';
+            else if (profile.model.includes('deepseek'))
+                profile.api = 'deepseek';
+            else if (profile.model.includes('qwen'))
+                profile.api = 'qwen';
+        }
+        if (!profile.api) {
+            throw new Error('Unknown model:', profile.model);
+        }
+    }
+    if (!apiMap[profile.api]) {
+        throw new Error('Unknown api:', profile.api);
+    }
+    let model_name = profile.model.replace(profile.api + '/', ''); // remove prefix
+    profile.model = model_name === "" ? null : model_name; // if model is empty, set to null
+    return profile;
+}
+
+export function createModel(profile) {
+    if (!!apiMap[profile.model]) {
+        // if the model value is an api (instead of a specific model name)
+        // then set model to null so it uses the default model for that api
+        profile.model = null;
+    }
+    if (!apiMap[profile.api]) {
+        throw new Error('Unknown api:', profile.api);
+    }
+    const model = new apiMap[profile.api](profile.model, profile.url, profile.params);
+    return model;
+}

package/src/models/azure.js

@@ -0,0 +1,32 @@
+import { AzureOpenAI } from "openai";
+import { getKey, hasKey } from '../utils/keys.js';
+import { GPT } from './gpt.js'
+
+export class AzureGPT extends GPT {
+    static prefix = 'azure';
+    constructor(model_name, url, params) {
+        super(model_name, url)
+
+        this.model_name = model_name;
+        this.params = params || {};
+
+        const config = {};
+
+        if (url)
+            config.endpoint = url;
+
+        config.apiKey = hasKey('AZURE_OPENAI_API_KEY') ? getKey('AZURE_OPENAI_API_KEY') : getKey('OPENAI_API_KEY');
+
+        config.deployment = model_name;
+
+        if (this.params.apiVersion) {
+            config.apiVersion = this.params.apiVersion;
+            delete this.params.apiVersion; // remove from params for later use in requests
+        }
+        else {
+            throw new Error('apiVersion is required in params for azure!');
+        }
+
+        this.openai = new AzureOpenAI(config)
+    }
+}

package/src/models/cerebras.js

@@ -0,0 +1,61 @@
+import CerebrasSDK from '@cerebras/cerebras_cloud_sdk';
+import { strictFormat } from '../utils/text.js';
+import { getKey } from '../utils/keys.js';
+
+export class Cerebras {
+    static prefix = 'cerebras';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.url = url;
+        this.params = params;
+
+        // Initialize client with API key
+        this.client = new CerebrasSDK({ apiKey: getKey('CEREBRAS_API_KEY') });
+    }
+
+    async sendRequest(turns, systemMessage, stop_seq = '***') {
+        // Format messages array
+        const messages = strictFormat(turns);
+        messages.unshift({ role: 'system', content: systemMessage });
+
+        const pack = {
+            model: this.model_name || 'gpt-oss-120b',
+            messages,
+            stream: false,
+            ...(this.params || {}),
+        };
+
+        let res;
+        try {
+            const completion = await this.client.chat.completions.create(pack);
+            // OpenAI-compatible shape
+            res = completion.choices?.[0]?.message?.content || '';
+        } catch (err) {
+            console.error('Cerebras API error:', err);
+            res = 'My brain disconnected, try again.';
+        }
+        return res;
+    }
+
+    async sendVisionRequest(messages, systemMessage, imageBuffer) {
+        const imageMessages = [...messages];
+        imageMessages.push({
+            role: "user",
+            content: [
+                { type: "text", text: systemMessage },
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:image/jpeg;base64,${imageBuffer.toString('base64')}`
+                    }
+                }
+            ]
+        });
+        
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+    
+    async embed(text) {
+        throw new Error('Embeddings are not supported by Cerebras.');
+    }
+}

package/src/models/claude.js

@@ -0,0 +1,87 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { strictFormat } from '../utils/text.js';
+import { getKey } from '../utils/keys.js';
+
+export class Claude {
+    static prefix = 'anthropic';
+    constructor(model_name, url, params) {
+        this.model_name = model_name;
+        this.params = params || {};
+
+        let config = {};
+        if (url)
+            config.baseURL = url;
+        
+        config.apiKey = getKey('ANTHROPIC_API_KEY');
+
+        this.anthropic = new Anthropic(config);
+    }
+
+    async sendRequest(turns, systemMessage) {
+        const messages = strictFormat(turns);
+        let res = null;
+        try {
+            console.log(`Awaiting anthropic response from ${this.model_name}...`)
+            if (!this.params.max_tokens) {
+                if (this.params.thinking?.budget_tokens) {
+                    this.params.max_tokens = this.params.thinking.budget_tokens + 1000;
+                    // max_tokens must be greater than thinking.budget_tokens
+                } else {
+                    this.params.max_tokens = 4096;
+                }
+            }
+            const resp = await this.anthropic.messages.create({
+                model: this.model_name || "claude-sonnet-4-20250514",
+                system: systemMessage,
+                messages: messages,
+                ...(this.params || {})
+            });
+
+            console.log('Received.')
+            // get first content of type text
+            const textContent = resp.content.find(content => content.type === 'text');
+            if (textContent) {
+                res = textContent.text;
+            } else {
+                console.warn('No text content found in the response.');
+                res = 'No response from Claude.';
+            }
+        }
+        catch (err) {
+            if (err.message.includes("does not support image input")) {
+                res = "Vision is only supported by certain models.";
+            } else {
+                res = "My brain disconnected, try again.";
+            }
+            console.log(err);
+        }
+        return res;
+    }
+
+    async sendVisionRequest(turns, systemMessage, imageBuffer) {
+        const imageMessages = [...turns];
+        imageMessages.push({
+            role: "user",
+            content: [
+                {
+                    type: "text",
+                    text: systemMessage
+                },
+                {
+                    type: "image",
+                    source: {
+                        type: "base64",
+                        media_type: "image/jpeg",
+                        data: imageBuffer.toString('base64')
+                    }
+                }
+            ]
+        });
+
+        return this.sendRequest(imageMessages, systemMessage);
+    }
+
+    async embed(text) {
+        throw new Error('Embeddings are not supported by Claude.');
+    }
+}