WebX11 Docs

🔧 Module Development API

Ext Module Structure

Modules are ES6 classes with 3 required and 1 optional method:

class MyModule {
  constructor() { this.commands = {}; this.terminal = null; }
  requirements() { return { met: true, missing: [] }; }
  getHelpInfo() { return { 'mycmd': 'mycmd — What it does' }; }
  registerCommands() { this.commands['mycmd'] = (args) => { /* ... */ }; }
}
// Auto-register:
if (typeof window.webx11 !== 'undefined' && window.webx11) {
  webx11.moduleManager.registerModule(new MyModule(), 'url');
}

VFS (Virtual FileSystem) API

Access via this.terminal.fs:

AI Tool Definition Format

Add tools to module-aiassist.js in getToolDefinitions() (around line 300):

{
  type: 'function',
  function: {
    name: 'my_tool',
    description: 'What it does — AI reads this to decide when to call it.',
    parameters: { type: 'object', properties: {
      paramName: { type: 'string', description: 'What this param does' }
    }, required: ['paramName'] }
  }
}

Then add a case 'my_tool': handler in runTool() (around line 1000). Return JSON.stringify(...).

Skill Format

Skills are markdown files with YAML frontmatter, stored in /skills/ in VFS:

---
name: my-skill
description: Brief description
tags: [tag1, tag2]
---
# Skill Body

Instructions, examples, and workflows here.

OllamaManager API

window.webx11 Global

The terminal instance is exposed globally as window.webx11 (aliased as webx11). This gives access to everything:

webx11.fs                    // VFS instance
webx11.moduleManager        // Module registry
webx11.ollamaManager        // Ollama connection
webx11.security             // Security manager
webx11.executeCommand(cmd)  // Run a terminal command programmatically
webx11.print(text, type)    // Print to terminal output
webx11.tutorialModule       // Tutorial progress (if active)
webx11.inputField           // DOM input element

⛅ Overview

WebX11 v4.5.24 is a browser-based Unix-like terminal — dynamic modules, AI assistant (Ollama), persistent virtual filesystem, web search, voice input, code editor, and a full skill system. Everything runs client-side in your browser.

🚀 Quick Start

1. Open index.html in Chrome/Edge
2. Watch the splash screen load modules
3. Type help + Enter
4. Use the quick-action buttons above the input area

First Commands

# List VFS files
ls

# List files faster
ll

# Connect to Ollama AI
ollamaconnect

# Chat with AI
ai what's in this directory?

# Create a file
put hello.txt Hello World

# Edit a file
edit hello.txt

# Search the web
search quantum computing

# Find files
find hello

# Compare two files
diff a.txt b.txt

📖 Full Command Reference

System

AI Assistant

Debug Supervisor

Skills

Config

📁 Filesystem

All VFS files persist in localStorage. ls, cd, pwd work like a real terminal. Clickable output — tap a file to cat, tap a dir to cd.

🤖 AI Assistant

How It Works

1. Type ai <request>
2. AI loads relevant skills + recent session memory
3. Decides which tools to call (up to 8 turns)
4. Destructive tools trigger an inline confirm bar — no dark overlay
5. 120s countdown: yellow → bold red at 30s → pulsing at 10s
6. Type ai-allow / ai-deny or tap the buttons
7. After complex tasks, AI suggests creating a skill

Available Tools

Sound Notification

A short "ding" plays via WebAudio when AI finishes. Toggle with the 🔊 Sound button in quick-actions. Persists in localStorage.

🔄 Agent Loop Studio

Commands

Default Profiles

System Prompt Layering

Self-Improvement

After each AI run, _postRunReview() detects anomalies: near-max-turns, high token usage, tool failures, and above-benchmark consumption. Lessons are auto-saved as VFS skills under /skills/loop-lesson-*.

AI Tools

The AI can also manage profiles via tools: agent_loop_list, agent_loop_switch, agent_loop_create, agent_loop_benchmark.

📚 Skills System

Terminal Commands

# List all skills
skill-list

# Create a skill
skill-create my-skill "Does X" "Steps to do X" "tag1,tag2"

# View / patch / delete
skill-view my-skill
skill-patch my-skill "Updated steps"
skill-delete my-skill

# Export / Import
skill-export my-skill
skill-import

Auto-Creation

When the AI encounters the same tool error 3+ times, a workaround skill is auto-created. Every 20 messages, skills are audited for staleness.

🤖 Ollama

Setup

# Install & pull a model
curl -fsSL https://ollama.com/install.sh | sh
ollama pull llama2

# Start Ollama
ollama serve

# In WebX11
ollamaconnect

Commands

🌐 Search & Web

The AI agent also has web_search and web_fetch tools using the same APIs.

🎤 Voice & Sound

• Tap 🎤 to start listening — button pulses green
• Say your command — recognized text fills the input
• Tap again or wait to stop
• Red flash indicates failure

Sound

Toggle AI response "ding" with the 🔊 Sound button. Persists in localStorage.

⚙️ Configuration

All config values stored as webx11_config_* in localStorage. Use the ⚙ Config button or CLI commands.

Notable Keys

Persisted State

🔒 Secret Vault

🧠 VaultMind AI

Setup

1. Store your Hyperliquid private key: secret-set hyperliquid_key 0x...
2. Ask the AI to connect: ai connect to vaultmind or use the vaultmind_connect tool
3. Check status: ai check vaultmind status or vaultmind_status

AI Tools

API Endpoints (proxied via nginx)

🧩 Module System

Commands

Boot Order

1. Splash screen with ⚙ gear
2. Foundation: virtual-fs.js → module-manager.js → ollama-manager.js → terminal.js
3. Built-in modules loaded async
4. Ext modules loaded if selected
5. Splash hides, terminal ready

Code Editor

The AI can edit_module(name) to copy source into the Code Editor modal. Edit inline, then 💾 Save & Test to load live from /_mods/. Use test_module without reloading the page.

You can also type edit modules/ext/foo.js — the editor now mirrors saves to _mods/<name>.js so test_module works from either path.

🧰 Extended Modules

WebDAV Sync

Calculator & Cron

Theme, WPM & Mindmap

Server Monitor

Aliases

Built-in: ll = ls, h = help, cls = clear. Define custom: alias x=ls -la. Remove: unalias x. Persists in localStorage.

🔧 BusyBox Utilities

All file-reading commands (cut, uniq, expand) work with shell pipes: cat data.csv | cut -f2 -d, | uniq.

🪟 Floating UI Elements

Usage Examples

# Simple button — click to run a command
floating-add btn quick ls -la

# Menu with sub-buttons (btn:Label:command)
floating-add menu tools Tools btn:Status:status btn:Help:help btn:Check:health-check

# Panel with info text
floating-add panel info "Server: production | Uptime: 12d"

# You can drag buttons and menu headers to reposition them
# Position persists across page reloads

🔍 Runtime Debug — /sys/

Path Reference

# Overview
cat /sys/info

# Memory
cat /sys/heap/stats
cat /sys/heap/breakdown

# AI Internal Logs
cat /sys/logs/tool-calls
cat /sys/logs/errors
cat /sys/logs/commands

# VFS Stats
cat /sys/vfs/stats
cat /sys/vfs/largest

# Module Info
ls /sys/modules/
cat /sys/modules/calc/info

# DOM / Config
cat /sys/dom/node-count
cat /sys/config/ai
cat /sys/config/version

Also available: mem-debug (one-shot text output), reset-mem (clear AI internal logs without touching VFS or config), and the DebugSupervisorModule (debug-stats, debug-history, debug-analyze, debug-trends, debug-fix, debug-health) for persistent error tracking and root-cause analysis.

🐚 Shell

Pipes |

Chain commands by piping stdout to the next command's stdin. Pipe-aware commands (grep, head, tail, sort, wc, cut, uniq, expand) auto-read from pipe when no file argument is given.

# Filter file listing
ls | grep .md

# Count lines matching pattern
cat notes.txt | grep error | wc

# Pipeline: filter → sort → head
cat data.csv | grep 2026 | sort | head -5

Redirects > >> <

# Write output to file
cal > /tmp/calendar.txt

# Append to file
echo "new line" >> log.txt

# Read file as stdin
grep error < log.txt

Command Chaining

# AND: next runs only if previous succeeds
touch test.txt && echo "created"

# OR: next runs only if previous fails
rm nonexistent || echo "failed"

# Sequence: runs in order regardless
cd /skills; ls

Variables

# Set a variable
export GREET=hello

# Reference in any command
echo $GREET

# List all vars
set

# Remove a var
unset GREET

Scripts

VFS files with .sh extension can be executed line by line. Variables persist across lines.

# Create a script in VFS
echo 'export NAME=WebX11' > greet.sh
echo 'echo "Hello, $NAME!"' >> greet.sh

# Run it
script greet.sh
sh greet.sh

Shell Commands

🪄 Floating UI

# Create a button
floating-add btn files "📁 Files" ls

# Create a collapsible menu
floating-add menu tools "🔧 Tools" btn:Help|help btn:Clear|clear

# Create a status panel
floating-add panel status "📊 Status" "Ready"

# List all elements
floating-list

# Hide without removing
floating-toggle files

🔒 Security & Guardrails

Guardrail Policy

Pre-execution guardrails intercept AI tool calls and block or warn on patterns matching dangerous operations:

Commands

Confidence Escalation

When the AI requests destructive actions, it must declare Confidence: N% in its reasoning. Below 90%, manual approval is required. If no confidence is declared, manual approval is required by default. This prevents the AI from making low-confidence destructive changes.

💬 Sessions

Sessions persist AI conversation logs in VFS /memory/. The AI auto-loads recent sessions at start for continuity.

AI Tools

The terminal auto-saves session state every 60s and auto-restores on page reload.

💾 Storage

# Clear all WebX11 data
localStorage.clear()
location.reload()

# Back up / restore VFS
vfs-export
vfs-import

~5–10MB per domain. Only URLs (not code) are stored for modules.

☁️ WebDAV

Cloud sync with your WebX11 space. File-tree browser UI with bulk actions.

Browser Features

• Checkbox select + Select All toggle
• Bulk action bar: Delete, Move, Download selected files
• Inline rename: double-click filename
• Right-click context menu with all operations
• Breadcrumb navigation
• Create-directory button
• Keyboard shortcuts: j/k navigate, Space select, Enter open

🤖 Agent Orchestration

Register, list, and delegate tasks to AI agents with lease-based lifecycle management.

📜 A2A Contracts

Define and enforce agent-to-agent contracts with input/output schema validation. Contracts are stored in /.contracts/ and validated during orchestrator delegation.

🧠 Neural VFS

Semantic concept-indexing layer over the hierarchical VFS. Scans files and builds a concept → path mapping using filenames, tags, and headers.

📊 Server Monitor

Uptime monitoring for external services + self-optimization telemetry tracking tool latency and error rates.

🔧 Debug Panel

Toggle the debug overlay to monitor system internals in real-time.

Debug Panel Shows

• Memory — localStorage usage, VFS size, session context size
• Events — registered event listeners, module event bindings
• Errors — recent JS errors with stack traces
• Modules — loaded count, broken references, cache state

Useful for troubleshooting module load failures, VFS corruption, and AI context bloat.

🧪 Sandboxed Execution

WebWorkers provide isolated contexts for task execution. Each worker gets a VFS snapshot so operations don't interfere with the main terminal.

orchestrate --sandboxed <task> routes delegation through the sandbox for full isolation.

🧠 Memory Graph

Cross-session persistent graph database tracking files, concepts, tasks, and tools. Nodes store metadata, edges record relationships with weighted strength. Survives page reloads via VFS persistence.

Context is automatically injected into AI prompts for cross-session awareness.

🌐 World Model

System self-awareness engine. Synthesizes data from memory graph, module system, skills index, telemetry, and agent pool into a unified model at /system/world-model.json. Auto-refreshes every 5 minutes.

🔒 Security

Security Levels

🔧 Troubleshooting

Debug

# Console
F12 → Console

# View AI state
ai-system
ai-context

# Module status
listmods

⚡ Quick Reference

📋 Changelog