@romiluz/clawmongo 0.1.0-rc.2 → 0.1.0-rc.4

package/dist/cli/branding.js

@@ -0,0 +1,129 @@
+/**
+ * ClawMongo CLI Branding
+ *
+ * ASCII art logo, colors, and branding elements.
+ *
+ * @module cli/branding
+ */
+/**
+ * ClawMongo ASCII art logo.
+ */
+export const LOGO = `
+\x1b[36m   _____ _                 __  __                         
+  / ____| |               |  \\/  |                        
+ | |    | | __ ___      __| \\  / | ___  _ __   __ _  ___  
+ | |    | |/ _\` \\ \\ /\\ / /| |\\/| |/ _ \\| '_ \\ / _\` |/ _ \\ 
+ | |____| | (_| |\\ V  V / | |  | | (_) | | | | (_| | (_) |
+  \\_____|_|\\__,_| \\_/\\_/  |_|  |_|\\___/|_| |_|\\__, |\\___/ 
+                                               __/ |      
+                                              |___/       \x1b[0m`;
+/**
+ * Tagline displayed under the logo.
+ */
+export const TAGLINE = "\x1b[33m  MongoDB is the brain, OpenClaw is the heart.\x1b[0m";
+/**
+ * Short tagline for compact displays.
+ */
+export const TAGLINE_SHORT = "\x1b[2mMongoDB-native agentic AI assistant\x1b[0m";
+/**
+ * Version banner with logo.
+ */
+export function getVersionBanner(version) {
+    return `${LOGO}
+${TAGLINE}
+
+  \x1b[2mVersion ${version}\x1b[0m
+`;
+}
+/**
+ * Welcome message for first-run experience.
+ */
+export function getWelcomeMessage(version) {
+    return `${LOGO}
+${TAGLINE}
+
+  \x1b[32m✨ Welcome to ClawMongo v${version}!\x1b[0m
+
+  ClawMongo is a MongoDB-native fork of OpenClaw that leverages
+  MongoDB's capabilities (Atlas Search, Vector Search, \$rankFusion)
+  while maintaining full parity with OpenClaw's features.
+
+  \x1b[36m📚 Quick Start:\x1b[0m
+  
+    \x1b[33mclawmongo init\x1b[0m        Set up your configuration
+    \x1b[33mclawmongo chat\x1b[0m        Start interactive chat
+    \x1b[33mclawmongo send\x1b[0m        Send a one-shot message
+    \x1b[33mclawmongo health\x1b[0m      Check system status
+
+  \x1b[36m🔧 Configuration:\x1b[0m
+  
+    Set these environment variables:
+    
+    \x1b[2mANTHROPIC_API_KEY\x1b[0m     Your Anthropic API key
+    \x1b[2mCLAWMONGO_MONGODB_URI\x1b[0m MongoDB connection string (optional)
+    \x1b[2mVOYAGE_API_KEY\x1b[0m        Voyage AI key for embeddings (optional)
+
+  \x1b[36m📖 Documentation:\x1b[0m
+  
+    https://github.com/romiluz13/ClawMongo
+
+  \x1b[2mRun 'clawmongo --help' for all available commands.\x1b[0m
+`;
+}
+/**
+ * Compact header for command output.
+ */
+export function getCompactHeader(version) {
+    return `\x1b[36m🐾 ClawMongo\x1b[0m v${version}`;
+}
+/**
+ * Success message with emoji.
+ */
+export function successMessage(text) {
+    return `\x1b[32m✓\x1b[0m ${text}`;
+}
+/**
+ * Error message with emoji.
+ */
+export function errorMessage(text) {
+    return `\x1b[31m✗\x1b[0m ${text}`;
+}
+/**
+ * Warning message with emoji.
+ */
+export function warnMessage(text) {
+    return `\x1b[33m⚠\x1b[0m ${text}`;
+}
+/**
+ * Info message with emoji.
+ */
+export function infoMessage(text) {
+    return `\x1b[36mℹ\x1b[0m ${text}`;
+}
+/**
+ * Step indicator for multi-step processes.
+ */
+export function stepIndicator(current, total, text) {
+    return `\x1b[36m[${current}/${total}]\x1b[0m ${text}`;
+}
+/**
+ * Progress bar.
+ */
+export function progressBar(percent, width = 30) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    const bar = "\x1b[32m" + "█".repeat(filled) + "\x1b[2m" + "░".repeat(empty) + "\x1b[0m";
+    return `${bar} ${percent.toFixed(0)}%`;
+}
+/**
+ * Box drawing for important messages.
+ */
+export function boxMessage(title, lines) {
+    const maxLen = Math.max(title.length, ...lines.map(l => l.length));
+    const top = `┌${"─".repeat(maxLen + 2)}┐`;
+    const titleLine = `│ \x1b[1m${title.padEnd(maxLen)}\x1b[0m │`;
+    const sep = `├${"─".repeat(maxLen + 2)}┤`;
+    const content = lines.map(l => `│ ${l.padEnd(maxLen)} │`).join("\n");
+    const bottom = `└${"─".repeat(maxLen + 2)}┘`;
+    return `${top}\n${titleLine}\n${sep}\n${content}\n${bottom}`;
+}

package/dist/cli/commands/init.js

@@ -0,0 +1,173 @@
+/**
+ * ClawMongo Init Command
+ *
+ * Interactive setup wizard for first-time configuration.
+ *
+ * @module cli/commands/init
+ */
+import * as readline from "readline";
+import * as fs from "fs";
+import * as path from "path";
+import { ExitCode } from "./types.js";
+import { createOutput } from "./output.js";
+import { LOGO, TAGLINE, successMessage, errorMessage, stepIndicator, boxMessage } from "../branding.js";
+/**
+ * Prompt user for input with optional default.
+ */
+async function prompt(rl, question, defaultValue, isSecret = false) {
+    const defaultHint = defaultValue ? ` \x1b[2m(${isSecret ? "****" : defaultValue})\x1b[0m` : "";
+    return new Promise((resolve) => {
+        rl.question(`  ${question}${defaultHint}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+/**
+ * Prompt for yes/no confirmation.
+ */
+async function confirm(rl, question, defaultYes = true) {
+    const hint = defaultYes ? "[Y/n]" : "[y/N]";
+    return new Promise((resolve) => {
+        rl.question(`  ${question} ${hint}: `, (answer) => {
+            const a = answer.trim().toLowerCase();
+            if (a === "")
+                resolve(defaultYes);
+            else
+                resolve(a === "y" || a === "yes");
+        });
+    });
+}
+/**
+ * Select from a list of options using arrow keys.
+ */
+async function select(rl, question, options, defaultIndex = 0) {
+    console.log(`\n  ${question}\n`);
+    let selectedIndex = defaultIndex;
+    // For simplicity, use numbered selection (arrow keys require raw mode)
+    options.forEach((opt, i) => {
+        const marker = i === defaultIndex ? "\x1b[36m→\x1b[0m" : " ";
+        console.log(`  ${marker} ${i + 1}. ${opt.label}`);
+    });
+    return new Promise((resolve) => {
+        rl.question(`\n  Enter number (1-${options.length}): `, (answer) => {
+            const num = parseInt(answer.trim(), 10);
+            if (num >= 1 && num <= options.length) {
+                const selected = options[num - 1];
+                resolve(selected ? selected.value : options[0]?.value ?? "");
+            }
+            else {
+                const defaultOpt = options[defaultIndex];
+                resolve(defaultOpt ? defaultOpt.value : options[0]?.value ?? "");
+            }
+        });
+    });
+}
+/**
+ * Write config to .env file.
+ */
+function writeEnvFile(config, filePath) {
+    const lines = [
+        "# ClawMongo Configuration",
+        "# Generated by 'clawmongo init'",
+        "",
+    ];
+    if (config.anthropicApiKey) {
+        lines.push(`ANTHROPIC_API_KEY=${config.anthropicApiKey}`);
+    }
+    if (config.mongodbUri) {
+        lines.push(`CLAWMONGO_MONGODB_URI=${config.mongodbUri}`);
+    }
+    if (config.voyageApiKey) {
+        lines.push(`VOYAGE_API_KEY=${config.voyageApiKey}`);
+    }
+    if (config.openaiApiKey) {
+        lines.push(`OPENAI_API_KEY=${config.openaiApiKey}`);
+    }
+    lines.push("");
+    fs.writeFileSync(filePath, lines.join("\n"));
+}
+/**
+ * Init command - interactive setup wizard.
+ */
+export const initCommand = {
+    name: "init",
+    aliases: ["setup", "configure"],
+    description: "Interactive setup wizard",
+    usage: "clawmongo init [--force]",
+    async execute(ctx) {
+        const out = createOutput({ json: ctx.json });
+        const envPath = path.join(process.cwd(), ".env");
+        // Check if .env already exists
+        if (fs.existsSync(envPath) && !ctx.flags.force) {
+            out.writeln(errorMessage(".env file already exists. Use --force to overwrite."));
+            return ExitCode.ERROR;
+        }
+        // Show welcome banner
+        console.log(LOGO);
+        console.log(TAGLINE);
+        console.log("\n  \x1b[1m✨ Welcome to ClawMongo Setup!\x1b[0m\n");
+        console.log("  This wizard will help you configure ClawMongo.");
+        console.log("  Press Enter to accept defaults, or type your values.\n");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const config = {};
+        try {
+            // Step 1: Anthropic API Key
+            console.log(stepIndicator(1, 4, "\x1b[1mAnthropic API Key\x1b[0m"));
+            console.log("  \x1b[2mRequired for Claude AI. Get yours at https://console.anthropic.com\x1b[0m\n");
+            config.anthropicApiKey = await prompt(rl, "ANTHROPIC_API_KEY", process.env.ANTHROPIC_API_KEY, true);
+            // Step 2: MongoDB URI
+            console.log("\n" + stepIndicator(2, 4, "\x1b[1mMongoDB Connection\x1b[0m"));
+            console.log("  \x1b[2mOptional. Enables persistent storage, Atlas Search, and vector search.\x1b[0m\n");
+            const useMongo = await confirm(rl, "Configure MongoDB?", true);
+            if (useMongo) {
+                config.mongodbUri = await prompt(rl, "CLAWMONGO_MONGODB_URI", process.env.CLAWMONGO_MONGODB_URI);
+            }
+            // Step 3: Embedding Provider
+            console.log("\n" + stepIndicator(3, 4, "\x1b[1mEmbedding Provider\x1b[0m"));
+            console.log("  \x1b[2mOptional. Enables semantic search and RAG capabilities.\x1b[0m\n");
+            const embeddingProvider = await select(rl, "Select embedding provider:", [
+                { value: "none", label: "None (skip for now)" },
+                { value: "voyage", label: "Voyage AI (recommended)" },
+                { value: "openai", label: "OpenAI" }
+            ], 0);
+            if (embeddingProvider === "voyage") {
+                config.voyageApiKey = await prompt(rl, "VOYAGE_API_KEY", process.env.VOYAGE_API_KEY, true);
+            }
+            else if (embeddingProvider === "openai") {
+                config.openaiApiKey = await prompt(rl, "OPENAI_API_KEY", process.env.OPENAI_API_KEY, true);
+            }
+            // Step 4: Confirm and write
+            console.log("\n" + stepIndicator(4, 4, "\x1b[1mConfirm Configuration\x1b[0m\n"));
+            const summary = [
+                `Anthropic API Key: ${config.anthropicApiKey ? "✓ Set" : "✗ Not set"}`,
+                `MongoDB URI: ${config.mongodbUri ? "✓ Set" : "✗ Not set"}`,
+                `Voyage API Key: ${config.voyageApiKey ? "✓ Set" : "✗ Not set"}`,
+                `OpenAI API Key: ${config.openaiApiKey ? "✓ Set" : "✗ Not set"}`
+            ];
+            console.log(boxMessage("Configuration Summary", summary));
+            console.log("");
+            const shouldWrite = await confirm(rl, "Write configuration to .env?", true);
+            if (shouldWrite) {
+                writeEnvFile(config, envPath);
+                console.log("\n" + successMessage(`Configuration saved to ${envPath}`));
+                console.log("\n  \x1b[36m🚀 You're all set! Try these commands:\x1b[0m\n");
+                console.log("    \x1b[33mclawmongo health\x1b[0m    Check system status");
+                console.log("    \x1b[33mclawmongo chat\x1b[0m      Start interactive chat");
+                console.log("    \x1b[33mclawmongo send\x1b[0m      Send a message\n");
+            }
+            else {
+                console.log("\n" + errorMessage("Setup cancelled."));
+            }
+            rl.close();
+            return ExitCode.SUCCESS;
+        }
+        catch (err) {
+            rl.close();
+            out.error(err instanceof Error ? err.message : String(err));
+            return ExitCode.ERROR;
+        }
+    }
+};

package/dist/cli/commands/registry.js

@@ -74,15 +74,26 @@ export function generateHelp(command, prefix = "") {
 export function generateGlobalHelp(registry, version) {
     const commands = registry.list();
     const lines = [];
-    lines.push(`ClawMongo v${version}`);
-    lines.push("MongoDB-native agentic AI assistant");
+    // ASCII Logo
+    lines.push("\x1b[36m   _____ _                 __  __                         ");
+    lines.push("  / ____| |               |  \\/  |                        ");
+    lines.push(" | |    | | __ ___      __| \\  / | ___  _ __   __ _  ___  ");
+    lines.push(" | |    | |/ _` \\ \\ /\\ / /| |\\/| |/ _ \\| '_ \\ / _` |/ _ \\ ");
+    lines.push(" | |____| | (_| |\\ V  V / | |  | | (_) | | | | (_| | (_) |");
+    lines.push("  \\_____|_|\\__,_| \\_/\\_/  |_|  |_|\\___/|_| |_|\\__, |\\___/ ");
+    lines.push("                                               __/ |      ");
+    lines.push("                                              |___/       \x1b[0m");
+    lines.push("");
+    lines.push("\x1b[33m  MongoDB is the brain, OpenClaw is the heart.\x1b[0m");
+    lines.push("");
+    lines.push(`  \x1b[2mVersion ${version}\x1b[0m`);
     lines.push("");
     lines.push("Usage: clawmongo <command> [options]");
     lines.push("");
     lines.push("Commands:");
     for (const cmd of commands) {
         const aliasStr = cmd.aliases ? ` (${cmd.aliases.join(", ")})` : "";
-        lines.push(`  ${cmd.name.padEnd(12)}${aliasStr.padEnd(8)} ${cmd.description}`);
+        lines.push(`  \x1b[33m${cmd.name.padEnd(12)}\x1b[0m${aliasStr.padEnd(8)} ${cmd.description}`);
     }
     lines.push("");
     lines.push("Options:");
@@ -91,6 +102,6 @@ export function generateGlobalHelp(registry, version) {
     lines.push("  --json          Output as JSON");
     lines.push("  -V, --verbose   Verbose output");
     lines.push("");
-    lines.push("Run 'clawmongo <command> --help' for command-specific help.");
+    lines.push("\x1b[2mRun 'clawmongo <command> --help' for command-specific help.\x1b[0m");
     return lines.join("\n");
 }

package/dist/main.js

@@ -19,13 +19,17 @@ import { cronCommand } from "./cli/commands/cron.js";
 import { backupCommand } from "./cli/commands/backup.js";
 import { securityCommand } from "./cli/commands/security.js";
 import { benchmarkCommand } from "./cli/commands/benchmark.js";
-const VERSION = "0.1.0-rc.2";
+import { initCommand } from "./cli/commands/init.js";
+// Import branding
+import { getVersionBanner, getWelcomeMessage } from "./cli/branding.js";
+const VERSION = "0.1.0-rc.4";
 /**
  * Build the command registry.
  */
 function buildRegistry() {
     const registry = createRegistry();
     // Register all commands
+    registry.register(initCommand); // Setup wizard first
     registry.register(healthCommand);
     registry.register(statusCommand);
     registry.register(doctorCommand);
@@ -51,7 +55,12 @@ async function main() {
     const out = createOutput({ json: hasFlag(parsed.flags, "json") });
     // Handle --version
     if (hasFlag(parsed.flags, "version") || hasFlag(parsed.flags, "v")) {
-        out.writeln(`clawmongo ${VERSION}`);
+        out.writeln(getVersionBanner(VERSION));
+        return;
+    }
+    // Handle no command - show welcome message
+    if (!parsed.command && !hasFlag(parsed.flags, "help")) {
+        out.writeln(getWelcomeMessage(VERSION));
         return;
     }
     // Handle --help with no command

package/dist/modules/tool-runtime/executors/bash.js

@@ -0,0 +1,234 @@
+/**
+ * Bash Session Tool
+ *
+ * Persistent bash shell sessions with restart capability.
+ * Ported from OpenClaw's computer-use-demo/tools/bash.py.
+ *
+ * Features:
+ * - Persistent sessions that maintain state
+ * - Automatic session creation
+ * - Restart capability for stuck sessions
+ * - Timeout handling
+ * - Tenant-scoped session management
+ *
+ * @module tool-runtime/executors/bash
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMEOUT_MS = 120_000; // 2 minutes
+const OUTPUT_DELAY_MS = 200;
+const SENTINEL = "<<exit>>";
+/**
+ * Session registry - maps tenant to their active bash session
+ */
+const sessionRegistry = new Map();
+/**
+ * Get or create a bash session for a tenant
+ */
+function getSession(tenantId) {
+    return sessionRegistry.get(tenantId);
+}
+/**
+ * Create a new bash session
+ */
+async function createSession(tenantId) {
+    // Kill existing session if any
+    const existing = sessionRegistry.get(tenantId);
+    if (existing?.process) {
+        existing.process.kill();
+    }
+    const sessionId = `bash-${randomUUID().slice(0, 8)}`;
+    const proc = spawn("/bin/bash", [], {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    const session = {
+        id: sessionId,
+        process: proc,
+        tenantId,
+        started: true,
+        timedOut: false,
+        stdout: "",
+        stderr: "",
+        createdAt: new Date()
+    };
+    sessionRegistry.set(tenantId, session);
+    return session;
+}
+/**
+ * Run a command in a bash session
+ */
+async function runCommand(session, command, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    if (!session.started) {
+        return { stdout: "", stderr: "", error: "Session has not started" };
+    }
+    if (session.process.exitCode !== null) {
+        return {
+            stdout: "",
+            stderr: "",
+            error: `Bash has exited with return code ${session.process.exitCode}. Tool must be restarted.`
+        };
+    }
+    if (session.timedOut) {
+        return {
+            stdout: "",
+            stderr: "",
+            error: `Session timed out and must be restarted`
+        };
+    }
+    // Clear buffers
+    session.stdout = "";
+    session.stderr = "";
+    // Setup output collection
+    const stdoutHandler = (data) => {
+        session.stdout += data.toString();
+    };
+    const stderrHandler = (data) => {
+        session.stderr += data.toString();
+    };
+    session.process.stdout?.on("data", stdoutHandler);
+    session.process.stderr?.on("data", stderrHandler);
+    // Send command with sentinel
+    session.process.stdin?.write(`${command}; echo '${SENTINEL}'\n`);
+    // Wait for output with sentinel
+    try {
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                session.timedOut = true;
+                reject(new Error(`Bash timed out after ${timeoutMs}ms and must be restarted`));
+            }, timeoutMs);
+            const checkInterval = setInterval(() => {
+                if (session.stdout.includes(SENTINEL)) {
+                    clearTimeout(timeout);
+                    clearInterval(checkInterval);
+                    resolve();
+                }
+            }, OUTPUT_DELAY_MS);
+        });
+    }
+    catch (err) {
+        session.process.stdout?.removeListener("data", stdoutHandler);
+        session.process.stderr?.removeListener("data", stderrHandler);
+        return {
+            stdout: "",
+            stderr: "",
+            error: err instanceof Error ? err.message : String(err)
+        };
+    }
+    session.process.stdout?.removeListener("data", stdoutHandler);
+    session.process.stderr?.removeListener("data", stderrHandler);
+    // Strip sentinel from output
+    let output = session.stdout;
+    const sentinelIdx = output.indexOf(SENTINEL);
+    if (sentinelIdx !== -1) {
+        output = output.slice(0, sentinelIdx);
+    }
+    if (output.endsWith("\n")) {
+        output = output.slice(0, -1);
+    }
+    let stderr = session.stderr;
+    if (stderr.endsWith("\n")) {
+        stderr = stderr.slice(0, -1);
+    }
+    return { stdout: output, stderr };
+}
+/**
+ * Validate bash tool parameters
+ */
+function validateBashParams(params) {
+    const command = params.command;
+    const restart = params.restart;
+    if (restart === true) {
+        return { restart: true };
+    }
+    if (typeof command !== "string" || command.trim().length === 0) {
+        return { error: "command is required (or set restart: true)" };
+    }
+    return { command: command.trim(), restart: false };
+}
+/**
+ * Bash tool executor
+ */
+export async function bashToolExecutor(params, context) {
+    const startTime = performance.now();
+    const tenantId = context.tenantId ?? "default";
+    // Handle restart
+    if (params.restart) {
+        await createSession(tenantId);
+        return {
+            ok: true,
+            output: { system: "Tool has been restarted.", stdout: "", stderr: "" },
+            durationMs: Math.round(performance.now() - startTime),
+            sideEffects: [`bash:restart:${context.toolCallId}`]
+        };
+    }
+    // Get or create session
+    let session = getSession(tenantId);
+    if (!session) {
+        session = await createSession(tenantId);
+    }
+    // Run command
+    const result = await runCommand(session, params.command ?? "");
+    if (result.error) {
+        return {
+            ok: false,
+            output: null,
+            error: result.error,
+            durationMs: Math.round(performance.now() - startTime),
+            sideEffects: []
+        };
+    }
+    return {
+        ok: true,
+        output: { stdout: result.stdout, stderr: result.stderr },
+        durationMs: Math.round(performance.now() - startTime),
+        sideEffects: [`bash:exec:${context.toolCallId}`]
+    };
+}
+/**
+ * Create bash executor with validated params
+ */
+export function createBashExecutor(rawParams, context) {
+    const validation = validateBashParams(rawParams);
+    if ("error" in validation) {
+        return {
+            ok: false,
+            output: null,
+            error: validation.error,
+            durationMs: 0,
+            sideEffects: []
+        };
+    }
+    return bashToolExecutor(validation, context);
+}
+/**
+ * Cleanup bash sessions for a tenant
+ */
+export function cleanupBashSessions(tenantId) {
+    const session = sessionRegistry.get(tenantId);
+    if (session?.process) {
+        session.process.kill();
+    }
+    sessionRegistry.delete(tenantId);
+}
+/**
+ * Tool definition for the bash tool
+ */
+export const bashToolDefinition = {
+    name: "bash",
+    description: "Run commands in a persistent bash shell. The session persists between calls. " +
+        "Set restart: true to restart the shell if it times out or exits.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            command: {
+                type: "string",
+                description: "The bash command to run."
+            },
+            restart: {
+                type: "boolean",
+                description: "Set to true to restart the bash session."
+            }
+        }
+    }
+};

package/dist/modules/tool-runtime/executors/index.js

@@ -8,3 +8,7 @@ export { createExecExecutor, execToolExecutor } from "./exec.js";
 export { cleanupTenantProcesses, createProcessExecutor, getProcessCount, processToolExecutor } from "./process.js";
 export { createEditExecutor, createReadExecutor, createWriteExecutor, editToolExecutor, readToolExecutor, writeToolExecutor } from "./filesystem.js";
 export { createSessionsListExecutor, createSessionStatusExecutor, sessionsListExecutor, sessionStatusExecutor } from "./session.js";
+// New tools for OpenClaw parity
+export { createThinkExecutor, thinkToolExecutor, thinkToolDefinition } from "./think.js";
+export { createBashExecutor, bashToolExecutor, bashToolDefinition, cleanupBashSessions } from "./bash.js";
+export { createCodeExecutionServerTool, createWebSearchServerTool, getDefaultServerTools, getServerToolBetaHeader, isServerTool, SERVER_TOOL_TYPES } from "./server-tools.js";

package/dist/modules/tool-runtime/executors/server-tools.js

@@ -0,0 +1,70 @@
+/**
+ * Server Tools - Anthropic Server-Side Tool Definitions
+ *
+ * These are special tools executed by Anthropic's servers, not locally.
+ * They use a different registration format and don't need local executors.
+ *
+ * Ported from OpenClaw's anthropic-quickstarts:
+ * - code_execution.py → CodeExecutionServerTool
+ * - web_search.py → WebSearchServerTool
+ *
+ * @module tool-runtime/executors/server-tools
+ */
+export function createCodeExecutionServerTool(options = {}) {
+    const name = options.name ?? "code_execution";
+    return {
+        type: "code_execution_20250522",
+        name
+    };
+}
+export function createWebSearchServerTool(options = {}) {
+    const name = options.name ?? "web_search";
+    const tool = {
+        type: "web_search_20250305",
+        name
+    };
+    if (options.maxUses !== undefined) {
+        tool.max_uses = options.maxUses;
+    }
+    if (options.allowedDomains !== undefined) {
+        tool.allowed_domains = options.allowedDomains;
+    }
+    if (options.blockedDomains !== undefined) {
+        tool.blocked_domains = options.blockedDomains;
+    }
+    if (options.userLocation !== undefined) {
+        tool.user_location = options.userLocation;
+    }
+    return tool;
+}
+/**
+ * Server tool type constants
+ */
+export const SERVER_TOOL_TYPES = {
+    CODE_EXECUTION: "code_execution_20250522",
+    WEB_SEARCH: "web_search_20250305"
+};
+/**
+ * Check if a tool definition is a server tool
+ */
+export function isServerTool(toolDef) {
+    const type = toolDef.type;
+    return (type === SERVER_TOOL_TYPES.CODE_EXECUTION ||
+        type === SERVER_TOOL_TYPES.WEB_SEARCH);
+}
+/**
+ * Get required beta header for server tools
+ */
+export function getServerToolBetaHeader() {
+    // The code execution tool requires this beta header
+    return "code-execution-2025-05-22";
+}
+/**
+ * Default server tools preset - both code execution and web search
+ */
+export function getDefaultServerTools() {
+    return [
+        createCodeExecutionServerTool(),
+        createWebSearchServerTool()
+    ];
+}

package/dist/modules/tool-runtime/executors/think.js

@@ -0,0 +1,79 @@
+/**
+ * Think Tool Executor
+ *
+ * Internal reasoning tool for the agent to think through problems
+ * without executing external actions. Ported from OpenClaw's think.py.
+ *
+ * This tool allows the model to:
+ * - Reason about complex problems step by step
+ * - Store intermediate thoughts in conversation history
+ * - Plan before taking actions
+ *
+ * @module tool-runtime/executors/think
+ */
+/**
+ * Validate think tool parameters
+ */
+function validateThinkParams(params) {
+    const thought = params.thought;
+    if (typeof thought !== "string" || thought.trim().length === 0) {
+        return { error: "thought is required and must be a non-empty string" };
+    }
+    return { thought: thought.trim() };
+}
+/**
+ * Think tool executor
+ *
+ * Simply acknowledges the thought, allowing the model to use it
+ * for chain-of-thought reasoning without external side effects.
+ */
+export const thinkToolExecutor = async (params, _context) => {
+    const startTime = performance.now();
+    // The think tool doesn't do anything external -
+    // it just acknowledges the thought so the model can reason
+    const result = {
+        message: "Thinking complete!",
+        thought: params.thought
+    };
+    return {
+        ok: true,
+        output: result,
+        durationMs: Math.round(performance.now() - startTime),
+        sideEffects: [] // No side effects - purely internal reasoning
+    };
+};
+/**
+ * Create think executor with validated params
+ */
+export function createThinkExecutor(rawParams, context) {
+    const validation = validateThinkParams(rawParams);
+    if ("error" in validation) {
+        return {
+            ok: false,
+            output: null,
+            error: validation.error,
+            durationMs: 0,
+            sideEffects: []
+        };
+    }
+    return thinkToolExecutor(validation, context);
+}
+/**
+ * Tool definition for the think tool (for registration)
+ */
+export const thinkToolDefinition = {
+    name: "think",
+    description: "Use this tool to think about something. It will not obtain new information " +
+        "or change the database, but just append the thought to the log. " +
+        "Use it when complex reasoning or some cache memory is needed.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            thought: {
+                type: "string",
+                description: "A thought to think about."
+            }
+        },
+        required: ["thought"]
+    }
+};

package/dist/modules/tool-runtime/mcp/connection.js

@@ -0,0 +1,178 @@
+/**
+ * MCP Connection Manager
+ *
+ * Manages connections to MCP (Model Context Protocol) tool servers.
+ * Supports both STDIO and SSE connection types.
+ *
+ * @module tool-runtime/mcp/connection
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+/**
+ * MCP Connection - manages a single MCP server connection
+ */
+export class MCPConnection {
+    id;
+    config;
+    process = null;
+    connected = false;
+    tools = [];
+    error;
+    constructor(config) {
+        this.id = `mcp-${randomUUID().slice(0, 8)}`;
+        this.config = config;
+    }
+    /**
+     * Connect to the MCP server
+     */
+    async connect() {
+        if (this.connected)
+            return;
+        try {
+            if (this.config.type === "stdio") {
+                await this.connectStdio();
+            }
+            else if (this.config.type === "sse") {
+                await this.connectSSE();
+            }
+            this.connected = true;
+            this.error = undefined;
+        }
+        catch (err) {
+            this.error = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+    }
+    /**
+     * Connect via STDIO
+     */
+    async connectStdio() {
+        const config = this.config;
+        this.process = spawn(config.command, config.args ?? [], {
+            env: { ...process.env, ...config.env },
+            stdio: ["pipe", "pipe", "pipe"]
+        });
+        // Wait for connection to be established
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error("MCP connection timeout"));
+            }, 10000);
+            this.process?.stdout?.once("data", () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+            this.process?.on("error", (err) => {
+                clearTimeout(timeout);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Connect via SSE (placeholder - full implementation needs SSE client)
+     */
+    async connectSSE() {
+        // SSE implementation would use EventSource or similar
+        // For now, throw not implemented
+        throw new Error("SSE MCP connections not yet implemented - use STDIO");
+    }
+    /**
+     * Disconnect from the MCP server
+     */
+    disconnect() {
+        if (this.process) {
+            this.process.kill();
+            this.process = null;
+        }
+        this.connected = false;
+    }
+    /**
+     * List available tools from the server
+     */
+    async listTools() {
+        if (!this.connected) {
+            throw new Error("Not connected to MCP server");
+        }
+        // In full implementation, this would send list_tools request
+        // For now, return cached tools
+        return this.tools;
+    }
+    /**
+     * Call a tool on the MCP server
+     */
+    async callTool(name, args) {
+        if (!this.connected) {
+            throw new Error("Not connected to MCP server");
+        }
+        // In full implementation, this would:
+        // 1. Send JSON-RPC request to server
+        // 2. Wait for response
+        // 3. Parse and return result
+        // Placeholder response
+        return {
+            content: [{
+                    type: "text",
+                    text: `MCP tool ${name} called with args: ${JSON.stringify(args)}`
+                }]
+        };
+    }
+    /**
+     * Get current connection state
+     */
+    getState() {
+        return {
+            id: this.id,
+            config: this.config,
+            connected: this.connected,
+            tools: this.tools,
+            error: this.error
+        };
+    }
+}
+/**
+ * MCP Connection Manager - manages multiple MCP connections
+ */
+export class MCPConnectionManager {
+    connections = new Map();
+    /**
+     * Create and connect to an MCP server
+     */
+    async connect(config) {
+        const connection = new MCPConnection(config);
+        await connection.connect();
+        this.connections.set(connection.id, connection);
+        return connection;
+    }
+    /**
+     * Disconnect from an MCP server
+     */
+    disconnect(connectionId) {
+        const connection = this.connections.get(connectionId);
+        if (connection) {
+            connection.disconnect();
+            this.connections.delete(connectionId);
+        }
+    }
+    /**
+     * Disconnect all MCP servers
+     */
+    disconnectAll() {
+        for (const connection of this.connections.values()) {
+            connection.disconnect();
+        }
+        this.connections.clear();
+    }
+    /**
+     * Get a connection by ID
+     */
+    get(connectionId) {
+        return this.connections.get(connectionId);
+    }
+    /**
+     * List all connections
+     */
+    list() {
+        return Array.from(this.connections.values()).map(c => c.getState());
+    }
+}
+// Singleton manager instance
+export const mcpManager = new MCPConnectionManager();

package/dist/modules/tool-runtime/mcp/index.js

@@ -0,0 +1,11 @@
+/**
+ * MCP (Model Context Protocol) Module
+ *
+ * Enables ClawMongo to connect to external MCP tool servers.
+ * Provides full parity with OpenClaw's MCP tool integration.
+ *
+ * @module tool-runtime/mcp
+ */
+export * from "./types.js";
+export { MCPConnection, MCPConnectionManager, mcpManager } from "./connection.js";
+export { createMCPTool, createMCPToolExecutor, mcpToolToDefinition } from "./tool.js";

package/dist/modules/tool-runtime/mcp/tool.js

@@ -0,0 +1,72 @@
+/**
+ * MCP Tool - Wrapper for MCP server tools
+ *
+ * Creates executable tool instances from MCP server tool definitions.
+ * Ported from OpenClaw's mcp_tool.py.
+ *
+ * @module tool-runtime/mcp/tool
+ */
+/**
+ * Create an MCP tool from a server tool definition
+ */
+export function createMCPTool(definition, connection) {
+    return {
+        name: definition.name,
+        description: definition.description ?? `MCP tool: ${definition.name}`,
+        inputSchema: definition.inputSchema,
+        connection,
+        async execute(args) {
+            try {
+                const result = await connection.callTool(definition.name, args);
+                // Extract text content from result
+                if (result.content && result.content.length > 0) {
+                    for (const item of result.content) {
+                        if (item.type === "text" && item.text) {
+                            return item.text;
+                        }
+                    }
+                }
+                return "No text content in MCP tool response";
+            }
+            catch (err) {
+                return `Error executing MCP tool ${definition.name}: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        }
+    };
+}
+/**
+ * Create an executor for an MCP tool
+ */
+export function createMCPToolExecutor(tool) {
+    return async (params, context) => {
+        const startTime = performance.now();
+        try {
+            const result = await tool.execute(params);
+            return {
+                ok: true,
+                output: result,
+                durationMs: Math.round(performance.now() - startTime),
+                sideEffects: [`mcp:${tool.name}:${context.toolCallId}`]
+            };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                output: null,
+                error: err instanceof Error ? err.message : String(err),
+                durationMs: Math.round(performance.now() - startTime),
+                sideEffects: []
+            };
+        }
+    };
+}
+/**
+ * Convert MCP tool to standard tool definition format
+ */
+export function mcpToolToDefinition(tool) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        input_schema: tool.inputSchema
+    };
+}

package/dist/modules/tool-runtime/mcp/types.js

@@ -0,0 +1,9 @@
+/**
+ * MCP (Model Context Protocol) Types
+ *
+ * Type definitions for MCP tool integration.
+ * Enables ClawMongo to connect to external MCP tool servers.
+ *
+ * @module tool-runtime/mcp/types
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@romiluz/clawmongo",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.4",
   "private": false,
   "type": "module",
   "description": "MongoDB-native OpenClaw-inspired assistant runtime",