openclaw-node-harness 2.0.2 → 2.0.3

package/bin/fleet-deploy.js

@@ -23,7 +23,7 @@ const os = require('os');
 
 const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const sc = StringCodec();
-const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(os.homedir(), 'openclaw-node');
+const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(os.homedir(), 'openclaw');
 const NODE_ID = process.env.OPENCLAW_NODE_ID ||
   os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 

package/bin/mesh-agent.js

@@ -117,7 +117,7 @@ function buildInitialPrompt(task) {
     parts.push('');
   }
 
-  if (task.success_criteria.length > 0) {
+  if (task.success_criteria && task.success_criteria.length > 0) {
     parts.push('## Success Criteria');
     for (const c of task.success_criteria) {
       parts.push(`- ${c}`);
@@ -132,7 +132,7 @@ function buildInitialPrompt(task) {
     parts.push('');
   }
 
-  if (task.scope.length > 0) {
+  if (task.scope && task.scope.length > 0) {
     parts.push('## Scope');
     parts.push('Only modify these files/paths:');
     for (const s of task.scope) {
@@ -192,7 +192,7 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
     parts.push('');
   }
 
-  if (task.scope.length > 0) {
+  if (task.scope && task.scope.length > 0) {
     parts.push('## Scope');
     for (const s of task.scope) {
       parts.push(`- ${s}`);

package/bin/mesh-deploy-listener.js

@@ -26,7 +26,7 @@ const os = require('os');
 const NODE_ID = process.env.OPENCLAW_NODE_ID ||
   os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 const REPO_DIR = process.env.OPENCLAW_REPO_DIR ||
-  path.join(os.homedir(), 'openclaw-node');
+  path.join(os.homedir(), 'openclaw');
 const DEPLOY_SCRIPT = path.join(REPO_DIR, 'bin', 'mesh-deploy.js');
 
 const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');

package/bin/mesh-deploy.js

@@ -32,7 +32,7 @@
  *
  * ENVIRONMENT:
  *   OPENCLAW_DEPLOY_BRANCH   — git branch (default: main)
- *   OPENCLAW_REPO_DIR        — repo location (default: ~/openclaw-node)
+ *   OPENCLAW_REPO_DIR        — repo location (default: ~/openclaw)
  *   OPENCLAW_NATS            — NATS server URL (from env or openclaw.env)
  */
 
@@ -47,7 +47,7 @@ const crypto = require('crypto');
 const IS_MAC = os.platform() === 'darwin';
 const HOME = os.homedir();
 const DEPLOY_BRANCH = process.env.OPENCLAW_DEPLOY_BRANCH || 'main';
-const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(HOME, 'openclaw-node');
+const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(HOME, 'openclaw');
 
 // Standard directory layout
 const DIRS = {
@@ -884,7 +884,7 @@ async function main() {
 
     if (!fs.existsSync(REPO_DIR)) {
       fail(`Repo not found at ${REPO_DIR}`);
-      console.log(`  Clone it: git clone https://github.com/moltyguibros-design/openclaw-node.git ${REPO_DIR}`);
+      console.log(`  Clone it: git clone https://github.com/moltyguibros-design/openclaw-node.git "${REPO_DIR}"`);
       process.exit(1);
     }
 

package/bin/mesh-health-publisher.js

@@ -29,7 +29,7 @@ const HEALTH_BUCKET = "MESH_NODE_HEALTH";
 const KV_TTL_MS = 120_000; // entries expire after 2 minutes if node dies
 
 const REPO_DIR = process.env.OPENCLAW_REPO_DIR ||
-  path.join(os.homedir(), 'openclaw-node');
+  path.join(os.homedir(), 'openclaw');
 
 const sc = StringCodec();
 const IS_MAC = os.platform() === "darwin";

package/bin/mesh.js

@@ -29,23 +29,44 @@ const path = require('path');
 const os = require('os');
 
 // ─── Config ──────────────────────────────────────────
-// NATS URL resolved via shared lib (env var → openclaw.env → .mesh-config → localhost fallback)
-const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
+// ── NATS URL resolution: env var → ~/.openclaw/openclaw.env → fallback IP ──
+const NATS_FALLBACK = 'nats://100.91.131.61:4222';
+function resolveNatsUrl() {
+  if (process.env.OPENCLAW_NATS) return process.env.OPENCLAW_NATS;
+  try {
+    const envFile = path.join(os.homedir(), '.openclaw', 'openclaw.env');
+    if (fs.existsSync(envFile)) {
+      const content = fs.readFileSync(envFile, 'utf8');
+      const match = content.match(/^\s*OPENCLAW_NATS\s*=\s*(.+)/m);
+      if (match && match[1].trim()) return match[1].trim();
+    }
+  } catch {}
+  return NATS_FALLBACK;
+}
+const NATS_URL = resolveNatsUrl();
 const SHARED_DIR = path.join(os.homedir(), 'openclaw', 'shared');
 const LOCAL_NODE = os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 const sc = StringCodec();
 
 // ─── Known nodes (for --node shortcuts) ──────────────
-// Load from ~/.openclaw/mesh-aliases.json if it exists, otherwise empty.
-let NODE_ALIASES = {};
-try {
-  const aliasFile = path.join(os.homedir(), '.openclaw', 'mesh-aliases.json');
-  if (fs.existsSync(aliasFile)) {
-    NODE_ALIASES = JSON.parse(fs.readFileSync(aliasFile, 'utf8'));
-  }
-} catch {
-  // File missing or malformed — proceed with no aliases
+const NODE_ALIASES_DEFAULTS = {
+  'ubuntu': 'calos-vmware-virtual-platform',
+  'linux': 'calos-vmware-virtual-platform',
+  'mac': 'moltymacs-virtual-machine-local',
+  'macos': 'moltymacs-virtual-machine-local',
+};
+
+function loadNodeAliases() {
+  const aliasPath = path.join(os.homedir(), '.openclaw', 'mesh-aliases.json');
+  try {
+    if (fs.existsSync(aliasPath)) {
+      const custom = JSON.parse(fs.readFileSync(aliasPath, 'utf8'));
+      return { ...NODE_ALIASES_DEFAULTS, ...custom };
+    }
+  } catch {}
+  return NODE_ALIASES_DEFAULTS;
 }
+const NODE_ALIASES = loadNodeAliases();
 
 /**
  * Resolve a node name — accepts aliases, full IDs, or "self"/"local"
@@ -98,7 +119,7 @@ function checkExecSafety(command) {
  */
 async function natsConnect() {
   try {
-    return await connect(natsConnectOpts({ timeout: 5000 }));
+    return await connect({ servers: NATS_URL, timeout: 5000 });
   } catch (err) {
     console.error(`Error: Cannot connect to NATS at ${NATS_URL}`);
     console.error(`Is the NATS server running? Is Tailscale connected?`);
@@ -140,21 +161,15 @@ async function collectHeartbeats(nc, waitMs = 3000) {
     uptime: os.uptime(),
   };
 
-  // Force-unsubscribe after deadline to prevent hanging if no messages arrive
-  const timer = setTimeout(() => sub.unsubscribe(), waitMs);
-
   // Listen for heartbeats for a few seconds
   const deadline = Date.now() + waitMs;
   for await (const msg of sub) {
-    try {
-      const s = JSON.parse(sc.decode(msg.data));
-      if (s.node !== LOCAL_NODE) {
-        nodes[s.node] = s;
-      }
-    } catch {}
+    const s = JSON.parse(sc.decode(msg.data));
+    if (s.node !== LOCAL_NODE) {
+      nodes[s.node] = s;
+    }
     if (Date.now() >= deadline) break;
   }
-  clearTimeout(timer);
   sub.unsubscribe();
   return nodes;
 }
@@ -575,6 +590,119 @@ async function cmdRepair(args) {
   }
 }
 
+/**
+ * mesh deploy [--force] [--component <name>] [--node <name>] — trigger fleet deploy.
+ *
+ * Publishes mesh.deploy.trigger to NATS. All nodes with mesh-deploy-listener
+ * will pull from git and self-deploy. Polls MESH_DEPLOY_RESULTS for status.
+ */
+async function cmdDeploy(args) {
+  const { execSync } = require('child_process');
+  const repoDir = process.env.OPENCLAW_REPO_DIR || path.join(os.homedir(), 'openclaw');
+  const force = args.includes('--force');
+
+  // Parse --component flags
+  const components = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--component' && args[i + 1]) {
+      components.push(args[i + 1]);
+      i++;
+    }
+  }
+
+  // Parse --node flags (target specific nodes, default: all)
+  const targetNodes = [];
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--node' && args[i + 1]) {
+      targetNodes.push(resolveNode(args[i + 1]));
+      i++;
+    }
+  }
+
+  // Get current SHA and branch
+  let sha, branch;
+  try {
+    sha = execSync('git rev-parse --short HEAD', { cwd: repoDir, encoding: 'utf8' }).trim();
+    branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: repoDir, encoding: 'utf8' }).trim();
+  } catch {
+    console.error(`Error: Cannot read git state from ${repoDir}`);
+    process.exit(1);
+  }
+
+  console.log(`Deploying ${sha} (${branch})${force ? ' [FORCE]' : ''}`);
+  if (components.length > 0) console.log(`  Components: ${components.join(', ')}`);
+  if (targetNodes.length > 0) console.log(`  Targets: ${targetNodes.join(', ')}`);
+  else console.log('  Targets: all nodes');
+
+  const nc = await natsConnect();
+
+  const trigger = {
+    sha,
+    branch,
+    components: components.length > 0 ? components : ['all'],
+    nodes: targetNodes.length > 0 ? targetNodes : ['all'],
+    force,
+    initiator: LOCAL_NODE,
+    timestamp: new Date().toISOString(),
+  };
+
+  // Write "latest" marker so offline nodes can catch up
+  try {
+    const js = nc.jetstream();
+    const resultsKv = await js.views.kv('MESH_DEPLOY_RESULTS', { history: 5, ttl: 7 * 24 * 60 * 60 * 1000 });
+    await resultsKv.put('latest', sc.encode(JSON.stringify({ sha, branch })));
+  } catch {}
+
+  // Publish trigger
+  nc.publish('mesh.deploy.trigger', sc.encode(JSON.stringify(trigger)));
+  await nc.flush();
+  console.log('Deploy trigger sent.\n');
+
+  // Poll for results (15s timeout)
+  console.log('Waiting for node responses...');
+  const deadline = Date.now() + 15000;
+  const seen = new Set();
+
+  try {
+    const js = nc.jetstream();
+    const resultsKv = await js.views.kv('MESH_DEPLOY_RESULTS');
+
+    while (Date.now() < deadline) {
+      const allAliasNodes = [...new Set(Object.values(NODE_ALIASES))];
+      const checkNodes = targetNodes.length > 0 ? targetNodes : allAliasNodes;
+
+      for (const nodeId of checkNodes) {
+        if (seen.has(nodeId)) continue;
+        const key = `${sha}-${nodeId}`;
+        try {
+          const entry = await resultsKv.get(key);
+          if (entry && entry.value) {
+            const result = JSON.parse(sc.decode(entry.value));
+            if (result.status === 'success' || result.status === 'failed' || result.status === 'skipped') {
+              const icon = result.status === 'success' ? '\x1b[32m✓\x1b[0m' : result.status === 'skipped' ? '\x1b[33m-\x1b[0m' : '\x1b[31m✗\x1b[0m';
+              console.log(`  ${icon} ${nodeId}: ${result.status} (${result.durationSeconds || 0}s)`);
+              if (result.errors && result.errors.length > 0) {
+                for (const e of result.errors) console.log(`    Error: ${e}`);
+              }
+              seen.add(nodeId);
+            }
+          }
+        } catch {}
+      }
+
+      if (seen.size >= checkNodes.length) break;
+      await new Promise(r => setTimeout(r, 2000));
+    }
+  } catch {}
+
+  if (seen.size === 0) {
+    console.log('  (no responses yet — nodes may still be deploying)');
+  }
+
+  console.log('');
+  await nc.close();
+}
+
 /**
  * mesh help — show usage.
  */
@@ -602,6 +730,10 @@ function cmdHelp() {
     '  mesh health --json                      Health check (JSON output)',
     '  mesh repair                             Self-repair this node',
     '  mesh repair --all                       Self-repair ALL nodes',
+    '  mesh deploy                             Deploy to all nodes',
+    '  mesh deploy --force                     Force deploy (even if up to date)',
+    '  mesh deploy --component <name>          Deploy specific component',
+    '  mesh deploy --node <name>               Deploy to specific node',
     '',
     'NODE ALIASES:',
     '  ubuntu, linux   = Ubuntu VM (calos-vmware-virtual-platform)',
@@ -632,6 +764,7 @@ async function main() {
     case 'tasks':     return cmdTasks(args);
     case 'health':    return cmdHealth(args);
     case 'repair':    return cmdRepair(args);
+    case 'deploy':    return cmdDeploy(args);
     case 'help':
     case '--help':
     case '-h':        return cmdHelp();

package/bin/openclaw-node-init.js

@@ -460,14 +460,60 @@ function installLaunchdService(meshDir, nodeBin, nodeId, provider, natsUrl) {
     return;
   }
 
+  // Deploy listener plist
+  const deployPlistPath = path.join(plistDir, 'ai.openclaw.deploy-listener.plist');
+  const deployPlist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.openclaw.deploy-listener</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${meshDir}/bin/mesh-deploy-listener.js</string>
+  </array>
+  <key>KeepAlive</key>
+  <true/>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${os.homedir()}/.openclaw/workspace/.tmp/mesh-deploy-listener.log</string>
+  <key>StandardErrorPath</key>
+  <string>${os.homedir()}/.openclaw/workspace/.tmp/mesh-deploy-listener.err</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>OPENCLAW_NATS</key>
+    <string>${natsUrl}</string>
+    <key>OPENCLAW_NODE_ID</key>
+    <string>${nodeId}</string>
+    <key>OPENCLAW_NODE_ROLE</key>
+    <string>worker</string>
+    <key>OPENCLAW_REPO_DIR</key>
+    <string>${meshDir}</string>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${os.homedir()}/.npm-global/bin</string>
+    <key>NODE_PATH</key>
+    <string>${meshDir}/node_modules:${meshDir}/lib</string>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+</dict>
+</plist>`;
+
   fs.mkdirSync(plistDir, { recursive: true });
   fs.writeFileSync(plistPath, plist);
-  ok(`Launchd service written: ${plistPath}`);
+  ok(`Mesh agent service written: ${plistPath}`);
+  fs.writeFileSync(deployPlistPath, deployPlist);
+  ok(`Deploy listener service written: ${deployPlistPath}`);
 
   try {
     execSync(`launchctl unload "${plistPath}" 2>/dev/null || true`, { stdio: 'pipe' });
     execSync(`launchctl load "${plistPath}"`, { stdio: 'pipe' });
-    ok('Service loaded and started');
+    ok('Mesh agent loaded and started');
+    execSync(`launchctl unload "${deployPlistPath}" 2>/dev/null || true`, { stdio: 'pipe' });
+    execSync(`launchctl load "${deployPlistPath}"`, { stdio: 'pipe' });
+    ok('Deploy listener loaded and started');
   } catch (e) {
     warn(`Service load warning: ${e.message}`);
   }
@@ -508,11 +554,40 @@ WantedBy=default.target
   fs.writeFileSync(servicePath, service);
   ok(`Systemd service written: ${servicePath}`);
 
+  // Deploy listener service
+  const deployServicePath = path.join(serviceDir, 'openclaw-deploy-listener.service');
+  const deployService = `[Unit]
+Description=OpenClaw Deploy Listener
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${nodeBin} ${meshDir}/bin/mesh-deploy-listener.js
+Restart=always
+RestartSec=30
+Environment=OPENCLAW_NATS=${natsUrl}
+Environment=OPENCLAW_NODE_ID=${nodeId}
+Environment=OPENCLAW_NODE_ROLE=worker
+Environment=OPENCLAW_REPO_DIR=${meshDir}
+Environment=NODE_PATH=${meshDir}/node_modules:${meshDir}/lib
+Environment=PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin:${os.homedir()}/.local/bin:${os.homedir()}/.npm-global/bin
+WorkingDirectory=${meshDir}
+
+[Install]
+WantedBy=default.target
+`;
+  fs.writeFileSync(deployServicePath, deployService);
+  ok(`Deploy listener service written: ${deployServicePath}`);
+
   try {
     execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
     execSync('systemctl --user enable openclaw-mesh-agent', { stdio: 'pipe' });
     execSync('systemctl --user start openclaw-mesh-agent', { stdio: 'pipe' });
-    ok('Service enabled and started');
+    ok('Mesh agent enabled and started');
+    execSync('systemctl --user enable openclaw-deploy-listener', { stdio: 'pipe' });
+    execSync('systemctl --user start openclaw-deploy-listener', { stdio: 'pipe' });
+    ok('Deploy listener enabled and started');
   } catch (e) {
     warn(`Service start warning: ${e.message}`);
     warn('Try manually: systemctl --user start openclaw-mesh-agent');
@@ -630,6 +705,71 @@ async function verifyNatsHealth(natsUrl, nodeId) {
   }
 }
 
+// ── Mesh Topology Discovery ──────────────────────────
+
+async function discoverTopology(natsUrl, localNodeId) {
+  log('Discovering mesh topology...');
+
+  if (DRY_RUN) {
+    warn('[DRY RUN] Would query MESH_NODE_HEALTH and write mesh-aliases.json');
+    return;
+  }
+
+  try {
+    const nats = require('nats');
+    const nc = await nats.connect({ servers: natsUrl, timeout: 10000 });
+    const sc = nats.StringCodec();
+    const js = nc.jetstream();
+
+    const aliases = {};
+
+    // Query MESH_NODE_HEALTH for all known nodes
+    try {
+      const kv = await js.views.kv('MESH_NODE_HEALTH');
+      const keys = await kv.keys();
+      for await (const key of keys) {
+        const entry = await kv.get(key);
+        if (entry && entry.value) {
+          const health = JSON.parse(sc.decode(entry.value));
+          const nodeId = health.nodeId || key;
+          // Create short alias from node ID (strip common suffixes)
+          const short = nodeId
+            .replace(/-virtual-machine.*$/i, '')
+            .replace(/-vmware.*$/i, '')
+            .replace(/-local$/, '');
+          aliases[short] = nodeId;
+          if (health.role === 'lead') aliases['lead'] = nodeId;
+          ok(`Peer: ${nodeId} (${health.role || 'worker'}, ${health.tailscaleIp || 'unknown'})`);
+        }
+      }
+    } catch {
+      warn('MESH_NODE_HEALTH bucket not available — skipping topology');
+    }
+
+    // Also add self
+    const selfShort = localNodeId
+      .replace(/-virtual-machine.*$/i, '')
+      .replace(/-vmware.*$/i, '')
+      .replace(/-local$/, '');
+    aliases[selfShort] = localNodeId;
+    aliases['self'] = localNodeId;
+
+    await nc.drain();
+
+    if (Object.keys(aliases).length > 1) {
+      const aliasPath = path.join(os.homedir(), '.openclaw', 'mesh-aliases.json');
+      fs.writeFileSync(aliasPath, JSON.stringify(aliases, null, 2) + '\n', { mode: 0o644 });
+      ok(`Mesh aliases written: ${aliasPath} (${Object.keys(aliases).length} entries)`);
+    } else {
+      warn('No peers found in MESH_NODE_HEALTH — mesh-aliases.json will only have self');
+      const aliasPath = path.join(os.homedir(), '.openclaw', 'mesh-aliases.json');
+      fs.writeFileSync(aliasPath, JSON.stringify(aliases, null, 2) + '\n', { mode: 0o644 });
+    }
+  } catch (e) {
+    warn(`Topology discovery failed: ${e.message} (non-fatal)`);
+  }
+}
+
 // ── Main ──────────────────────────────────────────────
 
 async function main() {
@@ -699,6 +839,10 @@ async function main() {
   const natsHealthy = await verifyNatsHealth(config.nats, nodeId);
   const healthy = serviceAlive && natsHealthy;
 
+  // ── Step 9: Discover mesh topology ──
+  step(9, 'Discovering mesh topology...');
+  await discoverTopology(config.nats, nodeId);
+
   // ── Done ──
   console.log(`\n${BOLD}${GREEN}═══════════════════════════════════════${RESET}`);
   if (healthy) {

package/lib/mesh-tasks.js

@@ -140,15 +140,15 @@ class TaskStore {
       // Apply filters
       if (filter.status && task.status !== filter.status) continue;
       if (filter.owner && task.owner !== filter.owner) continue;
-      if (filter.tag && !task.tags.includes(filter.tag)) continue;
+      if (filter.tag && (!task.tags || !task.tags.includes(filter.tag))) continue;
 
       tasks.push(task);
     }
 
     // Sort by priority (higher first), then created_at (older first)
     tasks.sort((a, b) => {
-      if (b.priority !== a.priority) return b.priority - a.priority;
-      return new Date(a.created_at) - new Date(b.created_at);
+      if ((b.priority || 0) !== (a.priority || 0)) return (b.priority || 0) - (a.priority || 0);
+      return (new Date(a.created_at || 0)) - (new Date(b.created_at || 0));
     });
 
     return tasks;
@@ -169,7 +169,7 @@ class TaskStore {
       if (task.exclude_nodes && task.exclude_nodes.includes(nodeId)) continue;
 
       // Respect dependencies
-      if (task.depends_on.length > 0) {
+      if (task.depends_on && task.depends_on.length > 0) {
         const depsReady = await this._checkDeps(task.depends_on);
         if (!depsReady) continue;
       }
@@ -192,9 +192,8 @@ class TaskStore {
     task.status = TASK_STATUS.CLAIMED;
     task.owner = nodeId;
     task.claimed_at = new Date().toISOString();
-    task.budget_deadline = new Date(
-      Date.now() + task.budget_minutes * 60 * 1000
-    ).toISOString();
+    const budgetMs = (task.budget_minutes || 30) * 60 * 1000;
+    task.budget_deadline = new Date(Date.now() + budgetMs).toISOString();
 
     await this.put(task);
     return task;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-node-harness",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "One-command installer for the OpenClaw node layer — identity, skills, souls, daemon, and Mission Control.",
   "bin": {
     "openclaw-node": "./cli.js"