openclaw-node-harness 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 moltyguibros-design
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,184 @@
+# openclaw-node
+
+Installable package for deploying an OpenClaw node. Includes the full infrastructure stack:
+
+- **Memory Daemon** — persistent background service managing session lifecycle, memory maintenance, and Obsidian sync
+- **Mission Control** — Next.js web dashboard (kanban, timeline, graph visualization, memory browser)
+- **Soul System** — multi-soul orchestration with trust registry and evolution
+- **Skill Library** — 100+ skills for AI agent capabilities
+- **Boot Compiler** — profile-aware boot artifact generation for multiple AI models
+- **ClawVault** — structured knowledge vault with search and handoffs
+
+## Quick Start (Ubuntu)
+
+```bash
+git clone https://github.com/moltyguibros-design/openclaw-node.git
+cd openclaw-node
+bash install.sh
+```
+
+The installer will:
+1. Check/install system dependencies (Node.js 18+, Python 3, Git, SQLite3, build-essential)
+2. Create the `~/.openclaw/` directory structure
+3. Install all scripts, identity files, souls, and skills
+4. Generate configuration from templates
+5. Install Mission Control and its dependencies
+6. Set up the memory daemon as a systemd user service
+7. Initialize the memory system
+
+## Post-Install
+
+1. **Edit your environment file** with API keys:
+   ```bash
+   nano ~/.openclaw/openclaw.env
+   ```
+
+2. **Regenerate configs** with your keys:
+   ```bash
+   bash install.sh --update
+   ```
+
+3. **Check daemon status:**
+   ```bash
+   systemctl --user status openclaw-memory-daemon
+   ```
+
+4. **Start Mission Control:**
+   ```bash
+   cd ~/.openclaw/workspace/projects/mission-control
+   npm run dev
+   # Dashboard at http://localhost:3000
+   ```
+
+## Updating
+
+Pull latest and re-run with `--update` to refresh scripts and configs without reinstalling system deps:
+
+```bash
+cd openclaw-node
+git pull
+bash install.sh --update
+```
+
+## Uninstalling
+
+```bash
+bash uninstall.sh          # Remove services and scripts (keep memory data)
+bash uninstall.sh --purge  # Remove everything including all data
+```
+
+## Directory Structure (installed)
+
+```
+~/.openclaw/
+├── openclaw.env              # Your API keys and config
+├── openclaw.json             # Generated runtime config
+├── config/                   # Daemon, transcript, sync configs
+├── souls/                    # Soul definitions (daedalus, specialists)
+├── services/                 # Service reference files
+├── workspace/
+│   ├── bin/                  # All scripts (daemon, maintenance, etc.)
+│   ├── skills/               # 100+ skill definitions
+│   ├── memory/               # Daily logs, active tasks, archive
+│   ├── memory-vault/         # ClawVault structured knowledge
+│   ├── .boot/                # Compiled boot profiles
+│   ├── .learnings/           # Corrections and lessons
+│   ├── .tmp/                 # Runtime state (logs, sessions)
+│   ├── projects/
+│   │   └── mission-control/  # Next.js dashboard
+│   ├── SOUL.md               # Identity
+│   ├── PRINCIPLES.md         # Decision heuristics
+│   ├── AGENTS.md             # Operational rules
+│   ├── CLAUDE.md             # Session init
+│   └── MEMORY.md             # Long-term memory
+```
+
+## Requirements
+
+- **Ubuntu 20.04+** (or any Linux with systemd)
+- **Node.js 18+** (installer will set up if missing)
+- **Python 3.8+** (usually pre-installed on Ubuntu)
+- **Git** (usually pre-installed)
+- **SQLite 3** (installer will set up if missing)
+
+Also works on macOS (uses launchd instead of systemd).
+
+### System dependencies installed automatically
+
+| Package | Purpose |
+|---|---|
+| `nodejs` (18+) | Runtime for daemon, MC, and Node.js scripts |
+| `python3` + `python3-pip` | Runtime for boot compiler, trust registry, evolution |
+| `build-essential` | Compiles `better-sqlite3` native module |
+| `git` | Version control |
+| `sqlite3` | Database engine |
+| `curl` | HTTP calls from scripts |
+| `jq` | JSON processing in test/workflow scripts |
+| `pyyaml` (pip) | Required by `bin/compile-boot` for YAML parsing |
+| `scrot` (Linux) | Screenshot capture (fallback: gnome-screenshot, flameshot) |
+
+### Skills with their own dependencies
+
+The installer auto-detects and installs these:
+- **memorylayer** — npm: `axios`
+- **moltbook-registry** — npm: `ethers`, `dotenv`
+- **prompt-guard** — pip: `pyyaml`
+- **crypto-price** — pip: `matplotlib`
+- **fast-browser-use** — Rust (requires manual `cargo build` if needed)
+
+## Obsidian Setup
+
+The installer deploys the vault scaffold with 22 domain folders and the **Local REST API** plugin pre-installed. On first Obsidian launch:
+
+1. Obsidian will auto-download 5 missing community plugins (dataview, templater, kanban, git, graph-analysis) — requires internet
+2. Generate an API key in the Local REST API plugin settings
+3. Save the key to `~/.openclaw/workspace/projects/arcane-vault/.obsidian-api-key`
+4. The memory daemon will sync workspace files to the vault every 30 minutes
+
+If not using Obsidian, the sync is disabled by default in `obsidian-sync.json` (set `"enabled": false`).
+
+## Mesh Network (Multi-Node)
+
+The installer detects Tailscale and optionally deploys a full mesh network across multiple machines. When enabled, nodes share files, execute remote commands, and broadcast session lifecycle events via NATS.
+
+### Setup
+
+1. Install [Tailscale](https://tailscale.com) on both machines and connect them
+2. Run `bash install.sh` — Step 15 auto-detects Tailscale and deploys the mesh
+3. Set `OPENCLAW_NATS=nats://<ubuntu-tailscale-ip>:4222` in `~/.openclaw/openclaw.env`
+4. Re-run `bash install.sh --update` to regenerate configs
+
+### Mesh commands
+
+```
+mesh status          # see online nodes
+mesh health --all    # check all nodes
+mesh repair --all    # fix broken services
+mesh exec "cmd"      # run command on remote node
+```
+
+### Architecture
+
+- **NATS** — message bus for commands, heartbeats, file sync (runs on Ubuntu)
+- **Agent v3** — polling-based shared folder sync over NATS (`~/openclaw/shared/`)
+- **Memory Bridge** — broadcasts session lifecycle events across nodes (`mesh-bridge.mjs`)
+- **Tailscale** — encrypted WireGuard tunnel between nodes
+
+The mesh is optional. Without Tailscale, everything runs as a standalone single node.
+
+## Environment Variables
+
+See `openclaw.env.example` for all available configuration. Key variables:
+
+| Variable | Required | Description |
+|---|---|---|
+| `OPENCLAW_NODE_ID` | Yes | Unique name for this node |
+| `OPENCLAW_TIMEZONE` | Yes | Timezone (e.g. `America/Montreal`) |
+| `ANTHROPIC_API_KEY` | Optional | For Claude-powered features |
+| `OPENAI_API_KEY` | Optional | For OpenAI-powered features |
+| `GOOGLE_API_KEY` | Optional | For Gemini + Mission Control TTS |
+| `DISCORD_BOT_TOKEN` | Optional | For Discord integration |
+| `TELEGRAM_BOT_TOKEN` | Optional | For Telegram integration |
+| `WEB_SEARCH_API_KEY` | Optional | For web search capability |
+| `OBSIDIAN_API_KEY` | Optional | For Obsidian vault sync |
+| `OPENCLAW_NATS` | Optional | NATS server URL for mesh (e.g. `nats://100.91.131.61:4222`) |

package/bin/discord-read.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+/**
+ * discord-read — CLI for querying Discord history via the mesh tool registry.
+ *
+ * Short-lived process: connects to NATS, sends request, prints result, exits.
+ *
+ * Usage:
+ *   discord-read history <channel-id> [--limit 50] [--before <msg-id>] [--after <msg-id>]
+ *   discord-read search <guild-id> <query> [--channel <id>] [--author <id>] [--limit 25]
+ *   discord-read channels <guild-id>
+ *   discord-read channel-info <channel-id>
+ *   discord-read tools                     — list registered mesh tools
+ */
+
+const { connect, StringCodec } = require('nats');
+
+const sc = StringCodec();
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
+
+async function natsConnect() {
+  try {
+    return await connect(natsConnectOpts({ timeout: 5000 }));
+  } catch (err) {
+    console.error(`Cannot connect to NATS at ${NATS_URL}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Find the node that provides the discord-history tool by scanning KV.
+ */
+async function findDiscordToolNode(nc) {
+  const js = nc.jetstream();
+  const kv = await js.views.kv('MESH_TOOLS');
+
+  const keys = await kv.keys();
+  for await (const key of keys) {
+    if (key.endsWith('.discord-history')) {
+      const entry = await kv.get(key);
+      if (entry && entry.value) {
+        const manifest = JSON.parse(sc.decode(entry.value));
+        return manifest.node_id;
+      }
+    }
+  }
+  return null;
+}
+
+async function callTool(nc, nodeId, methodName, args, timeoutMs = 15000) {
+  const subject = `mesh.tool.${nodeId}.discord-history.${methodName}`;
+  const payload = JSON.stringify({ args });
+
+  try {
+    const msg = await nc.request(subject, sc.encode(payload), { timeout: timeoutMs });
+    const response = JSON.parse(sc.decode(msg.data));
+    if (response.error) {
+      console.error(`Error: ${response.error}`);
+      process.exit(1);
+    }
+    return response.data;
+  } catch (err) {
+    if (err.code === '503' || err.message?.includes('503')) {
+      console.error('No responder — is mesh-tool-discord running?');
+    } else if (err.code === 'TIMEOUT') {
+      console.error('Request timed out.');
+    } else {
+      console.error(`Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+}
+
+function parseArgs(args) {
+  const flags = {};
+  const positional = [];
+  let i = 0;
+  while (i < args.length) {
+    if (args[i].startsWith('--') && args[i + 1] && !args[i + 1].startsWith('--')) {
+      flags[args[i].slice(2)] = args[i + 1];
+      i += 2;
+    } else {
+      positional.push(args[i]);
+      i++;
+    }
+  }
+  return { flags, positional };
+}
+
+function formatMessages(messages) {
+  for (const m of messages) {
+    const time = new Date(m.timestamp).toLocaleString('en-US', {
+      timeZone: 'America/Montreal', hour12: false,
+      year: 'numeric', month: '2-digit', day: '2-digit',
+      hour: '2-digit', minute: '2-digit',
+    });
+    const author = m.author.bot ? `[BOT] ${m.author.username}` : m.author.username;
+    const attachments = m.attachments?.length ? ` [${m.attachments.length} attachment(s)]` : '';
+    const reply = m.referencedMessage
+      ? `  ↳ replying to ${m.referencedMessage.author}: "${m.referencedMessage.content?.slice(0, 80)}..."\n`
+      : '';
+    console.log(`[${time}] ${author}: ${m.content}${attachments}`);
+    if (reply) process.stdout.write(reply);
+  }
+}
+
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+
+  if (!cmd || cmd === 'help' || cmd === '--help') {
+    console.log(`
+discord-read — Query Discord history via OpenClaw mesh
+
+USAGE:
+  discord-read history <channel-id> [--limit 50] [--before <msg-id>] [--after <msg-id>]
+  discord-read search <guild-id> <query> [--channel <id>] [--author <id>] [--limit 25]
+  discord-read channels <guild-id>
+  discord-read channel-info <channel-id>
+  discord-read tools                     — list registered mesh tools
+
+ENVIRONMENT:
+  OPENCLAW_NATS — NATS server URL (auto-detected from env or ~/.openclaw/openclaw.env)
+`);
+    process.exit(0);
+  }
+
+  const nc = await natsConnect();
+
+  if (cmd === 'tools') {
+    // List all mesh tools
+    const js = nc.jetstream();
+    const kv = await js.views.kv('MESH_TOOLS');
+    const keys = await kv.keys();
+    let found = false;
+    for await (const key of keys) {
+      const entry = await kv.get(key);
+      if (entry && entry.value) {
+        const manifest = JSON.parse(sc.decode(entry.value));
+        console.log(`${manifest.node_id}/${manifest.name} v${manifest.version}`);
+        console.log(`  ${manifest.description}`);
+        for (const m of (manifest.methods || [])) {
+          console.log(`  - ${m.name}: ${m.description}`);
+        }
+        console.log('');
+        found = true;
+      }
+    }
+    if (!found) console.log('No tools registered.');
+    await nc.close();
+    return;
+  }
+
+  // Find the discord-history tool provider
+  const nodeId = await findDiscordToolNode(nc);
+  if (!nodeId) {
+    console.error('Discord history tool not found in registry. Is mesh-tool-discord running?');
+    await nc.close();
+    process.exit(1);
+  }
+
+  const { flags, positional } = parseArgs(rest);
+
+  switch (cmd) {
+    case 'history': {
+      const channelId = positional[0];
+      if (!channelId) { console.error('Usage: discord-read history <channel-id>'); process.exit(1); }
+      const result = await callTool(nc, nodeId, 'readMessages', {
+        channelId,
+        limit: parseInt(flags.limit || '50'),
+        before: flags.before,
+        after: flags.after,
+      });
+      if (flags.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        formatMessages(result.reverse()); // Show oldest first
+      }
+      break;
+    }
+
+    case 'search': {
+      const guildId = positional[0];
+      const query = positional.slice(1).join(' ');
+      if (!guildId || !query) { console.error('Usage: discord-read search <guild-id> <query>'); process.exit(1); }
+      const result = await callTool(nc, nodeId, 'searchMessages', {
+        guildId,
+        query,
+        channelId: flags.channel,
+        authorId: flags.author,
+        limit: parseInt(flags.limit || '25'),
+      });
+      console.log(`Found ${result.totalResults} result(s):`);
+      formatMessages(result.messages);
+      break;
+    }
+
+    case 'channels': {
+      const guildId = positional[0];
+      if (!guildId) { console.error('Usage: discord-read channels <guild-id>'); process.exit(1); }
+      const result = await callTool(nc, nodeId, 'listChannels', { guildId });
+      for (const ch of result) {
+        const topic = ch.topic ? ` — ${ch.topic.slice(0, 60)}` : '';
+        console.log(`  #${ch.name} (${ch.id}) [${ch.type}]${topic}`);
+      }
+      break;
+    }
+
+    case 'channel-info': {
+      const channelId = positional[0];
+      if (!channelId) { console.error('Usage: discord-read channel-info <channel-id>'); process.exit(1); }
+      const result = await callTool(nc, nodeId, 'channelInfo', { channelId });
+      console.log(JSON.stringify(result, null, 2));
+      break;
+    }
+
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      console.error('Run "discord-read help" for usage.');
+      process.exit(1);
+  }
+
+  await nc.close();
+}
+
+main().catch(err => {
+  console.error(`discord-read error: ${err.message}`);
+  process.exit(1);
+});