openclaw-node-harness 2.1.0 → 2.2.0

package/bin/lane-watchdog.js

@@ -37,6 +37,11 @@ let lastInterventionAt = 0;
 let logWatcher = null;
 let errWatcher = null;
 
+// Incident log dedup: suppress identical messages within 60s
+let lastIncidentMsg = '';
+let lastIncidentAt = 0;
+let suppressedCount = 0;
+
 // Track detected events
 const events = {
   agentTimeout: null,    // timestamp of last "embedded run timeout"
@@ -45,6 +50,22 @@ const events = {
 
 // --- Helpers ---
 function log(msg) {
+  const now = Date.now();
+  // Dedup: suppress identical messages within 60s
+  if (msg === lastIncidentMsg && (now - lastIncidentAt) < 60_000) {
+    suppressedCount++;
+    return;
+  }
+  // If we suppressed duplicates, emit a summary before the new message
+  if (suppressedCount > 0) {
+    const summaryLine = `${new Date().toISOString()} [lane-watchdog] (suppressed ${suppressedCount} duplicate message(s))`;
+    console.log(summaryLine);
+    try { fs.appendFileSync(INCIDENT_LOG, summaryLine + '\n'); } catch { /* best effort */ }
+  }
+  lastIncidentMsg = msg;
+  lastIncidentAt = now;
+  suppressedCount = 0;
+
   const ts = new Date().toISOString();
   const line = `${ts} [lane-watchdog] ${msg}`;
   console.log(line);
@@ -172,29 +193,39 @@ function tailLog(filePath, label) {
 
   const watcher = fs.watch(filePath, { persistent: true }, () => {
     try {
-      const stat = fs.statSync(filePath);
-      if (stat.size < fileSize) {
-        // Log was rotated
+      // Read from current fileSize to EOF — avoid TOCTOU race by not
+      // pre-checking stat.size. createReadStream with just `start` reads
+      // to the end of the file atomically, then we update fileSize from
+      // the bytes actually read.
+      const stream = fs.createReadStream(filePath, {
+        start: fileSize,
+        encoding: 'utf8'
+      });
+      let buffer = '';
+      let bytesRead = 0;
+      stream.on('data', chunk => { buffer += chunk; bytesRead += Buffer.byteLength(chunk, 'utf8'); });
+      stream.on('end', () => {
+        if (bytesRead === 0) return; // no new data
+        const lines = buffer.split('\n').filter(Boolean);
+        for (const line of lines) {
+          parseLine(line);
+        }
+        fileSize += bytesRead;
+      });
+      stream.on('error', (err) => {
+        if (err.code === 'ENOENT') {
+          // File was deleted/rotated — reset position
+          fileSize = 0;
+        } else {
+          log(`ERROR: reading ${label}: ${err.message}`);
+        }
+      });
+    } catch (err) {
+      if (err.code === 'ENOENT') {
         fileSize = 0;
+      } else {
+        log(`ERROR: reading ${label}: ${err.message}`);
       }
-      if (stat.size > fileSize) {
-        const stream = fs.createReadStream(filePath, {
-          start: fileSize,
-          end: stat.size,
-          encoding: 'utf8'
-        });
-        let buffer = '';
-        stream.on('data', chunk => { buffer += chunk; });
-        stream.on('end', () => {
-          const lines = buffer.split('\n').filter(Boolean);
-          for (const line of lines) {
-            parseLine(line);
-          }
-          fileSize = stat.size;
-        });
-      }
-    } catch (err) {
-      log(`ERROR: reading ${label}: ${err.message}`);
     }
   });
 
@@ -220,8 +251,8 @@ function main() {
   for (const sig of ['SIGTERM', 'SIGINT']) {
     process.on(sig, () => {
       log(`Received ${sig}, shutting down`);
-      if (logWatcher) fs.unwatchFile(GATEWAY_LOG);
-      if (errWatcher) fs.unwatchFile(GATEWAY_ERR_LOG);
+      if (logWatcher) logWatcher.close();
+      if (errWatcher) errWatcher.close();
       process.exit(0);
     });
   }

package/bin/mesh-agent.js

@@ -36,7 +36,7 @@
  */
 
 const { connect, StringCodec } = require('nats');
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, execFileSync } = require('child_process');
 const os = require('os');
 const path = require('path');
 const fs = require('fs');
@@ -46,7 +46,7 @@ const { loadHarnessRules, runMeshHarness, runPostCommitValidation, formatHarness
 const { findRole, formatRoleForPrompt } = require('../lib/role-loader');
 
 const sc = StringCodec();
-const { NATS_URL } = require('../lib/nats-resolve');
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const { resolveProvider, resolveModel } = require('../lib/llm-providers');
 const NODE_ID = process.env.MESH_NODE_ID || os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 const POLL_INTERVAL = parseInt(process.env.MESH_POLL_INTERVAL || '15000'); // 15s between polls
@@ -198,8 +198,9 @@ function buildInitialPrompt(task) {
   }
 
   if (task.metric) {
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
     parts.push(`## Verification`);
-    parts.push(`Run this command to check your work: \`${task.metric}\``);
+    parts.push(`Run this command to check your work: \`${safeMetric}\``);
     parts.push(`Your changes are only accepted if this command exits with code 0.`);
     parts.push('');
   }
@@ -224,7 +225,8 @@ function buildInitialPrompt(task) {
   parts.push('- Make minimal, focused changes. Do not add scope beyond what is asked.');
   parts.push('- If you hit a blocker you cannot resolve, explain what is blocking you clearly.');
   if (task.metric) {
-    parts.push(`- After making changes, run \`${task.metric}\` to verify.`);
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
+    parts.push(`- After making changes, run \`${safeMetric}\` to verify.`);
     parts.push('- If verification fails, analyze the failure and iterate on your approach.');
   }
 
@@ -264,8 +266,9 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
   }
 
   if (task.metric) {
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
     parts.push(`## Verification`);
-    parts.push(`Run: \`${task.metric}\``);
+    parts.push(`Run: \`${safeMetric}\``);
     parts.push(`Must exit code 0.`);
     parts.push('');
   }
@@ -289,7 +292,8 @@ function buildRetryPrompt(task, previousAttempts, attemptNumber) {
   parts.push('- Read the relevant files before making changes.');
   parts.push('- Make minimal, focused changes.');
   if (task.metric) {
-    parts.push(`- Run \`${task.metric}\` to verify before finishing.`);
+    const safeMetric = isAllowedMetric(task.metric) ? task.metric : '[metric command filtered for security]';
+    parts.push(`- Run \`${safeMetric}\` to verify before finishing.`);
   }
 
   return parts.join('\n');
@@ -305,6 +309,9 @@ const WORKTREE_BASE = process.env.MESH_WORKTREE_BASE || path.join(process.env.HO
  * On failure, returns null (falls back to shared workspace).
  */
 function createWorktree(taskId) {
+  if (!/^[\w][\w.-]{0,127}$/.test(taskId)) {
+    throw new Error(`Invalid taskId: contains unsafe characters`);
+  }
   const worktreePath = path.join(WORKTREE_BASE, taskId);
   const branch = `mesh/${taskId}`;
 
@@ -315,19 +322,19 @@ function createWorktree(taskId) {
     if (fs.existsSync(worktreePath)) {
       log(`Cleaning stale worktree: ${worktreePath}`);
       try {
-        execSync(`git worktree remove --force "${worktreePath}"`, { cwd: WORKSPACE, timeout: 10000 });
+        execFileSync('git', ['worktree', 'remove', '--force', worktreePath], { cwd: WORKSPACE, timeout: 10000 });
       } catch {
         // If git worktree remove fails, manually clean up
         fs.rmSync(worktreePath, { recursive: true, force: true });
       }
       // Also clean up the branch if it exists
       try {
-        execSync(`git branch -D "${branch}"`, { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
+        execFileSync('git', ['branch', '-D', branch], { cwd: WORKSPACE, timeout: 5000, stdio: 'ignore' });
       } catch { /* branch may not exist */ }
     }
 
     // Create new worktree branched off HEAD
-    execSync(`git worktree add -b "${branch}" "${worktreePath}" HEAD`, {
+    execFileSync('git', ['worktree', 'add', '-b', branch, worktreePath, 'HEAD'], {
       cwd: WORKSPACE,
       timeout: 30000,
       stdio: 'pipe',
@@ -375,7 +382,7 @@ function commitAndMergeWorktree(worktreePath, taskId, summary) {
       log(`WARNING: commit message doesn't follow conventional format: "${commitMsg}"`);
     }
 
-    execSync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, {
+    execFileSync('git', ['commit', '-m', commitMsg], {
       cwd: worktreePath, timeout: 10000, stdio: 'pipe',
     });
 
@@ -391,7 +398,7 @@ function commitAndMergeWorktree(worktreePath, taskId, summary) {
     const mergeMsg = `Merge ${branch}: ${taskId}`;
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        execSync(`git merge --no-ff "${branch}" -m "${mergeMsg.replace(/"/g, '\\"')}"`, {
+        execFileSync('git', ['merge', '--no-ff', branch, '-m', mergeMsg], {
           cwd: WORKSPACE, timeout: 30000, stdio: 'pipe',
         });
         log(`Merged ${branch} into main${attempt > 0 ? ' (retry succeeded)' : ''}`);
@@ -429,13 +436,13 @@ function cleanupWorktree(worktreePath, keep = false) {
   const branch = `mesh/${taskId}`;
 
   try {
-    execSync(`git worktree remove --force "${worktreePath}"`, {
+    execFileSync('git', ['worktree', 'remove', '--force', worktreePath], {
       cwd: WORKSPACE,
       timeout: 10000,
       stdio: 'pipe',
     });
     if (!keep) {
-      execSync(`git branch -D "${branch}"`, {
+      execFileSync('git', ['branch', '-D', branch], {
         cwd: WORKSPACE,
         timeout: 5000,
         stdio: 'ignore',
@@ -507,9 +514,10 @@ function runLLM(prompt, task, worktreePath) {
 
     let stdout = '';
     let stderr = '';
+    const MAX_OUTPUT = 1024 * 1024; // 1MB cap
 
-    child.stdout.on('data', (d) => { stdout += d.toString(); });
-    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.stdout.on('data', (d) => { if (stdout.length < MAX_OUTPUT) stdout += d.toString().slice(0, MAX_OUTPUT - stdout.length); });
+    child.stderr.on('data', (d) => { if (stderr.length < MAX_OUTPUT) stderr += d.toString().slice(0, MAX_OUTPUT - stderr.length); });
 
     child.on('close', (code) => {
       clearInterval(heartbeatTimer);
@@ -525,10 +533,25 @@ function runLLM(prompt, task, worktreePath) {
 
 // ── Metric Evaluation ─────────────────────────────────
 
+const ALLOWED_METRIC_PREFIXES = [
+  'npm test', 'npm run', 'node ', 'pytest', 'cargo test',
+  'go test', 'make test', 'jest', 'vitest', 'mocha',
+];
+
+function isAllowedMetric(cmd) {
+  if (/[\n\r\0;`]|\$\(|\|\||&&|<\(|>\(|<<|>>|>\s|\|/.test(cmd)) return false;
+  if (/\bnode\s+(-e\b|--eval\b|-p\b|--print\b|-r\b|--require\b|--import\b)/.test(cmd)) return false;
+  return ALLOWED_METRIC_PREFIXES.some(prefix => cmd.startsWith(prefix));
+}
+
 /**
  * Run the task's metric command. Returns { passed, output }.
  */
 function evaluateMetric(metric, cwd) {
+  if (!isAllowedMetric(metric)) {
+    log(`WARNING: Metric command blocked by security filter: ${metric}`);
+    return Promise.resolve({ passed: false, output: 'Metric command blocked by security filter' });
+  }
   return new Promise((resolve) => {
     const child = spawn('bash', ['-c', metric], {
       cwd: cwd || WORKSPACE,
@@ -1011,6 +1034,9 @@ async function executeCollabTask(task) {
   // Create worktree for isolation
   const worktreePath = createWorktree(`${task.task_id}-${NODE_ID}`);
   const taskDir = worktreePath || WORKSPACE;
+  if (!worktreePath) {
+    log(`WARNING: Collab task ${task.task_id} running in shared workspace — isolation not achieved`);
+  }
 
   // Periodic session heartbeat — detects abort/completion while waiting for rounds
   const sessionHeartbeat = setInterval(async () => {
@@ -1169,9 +1195,13 @@ async function executeTask(task) {
   // Create isolated worktree for this task (falls back to shared workspace on failure)
   const worktreePath = createWorktree(task.task_id);
   const taskDir = worktreePath || WORKSPACE;
+  const workspaceIsolated = !!worktreePath;
+  if (!workspaceIsolated) {
+    log(`WARNING: Task ${task.task_id} running in shared workspace — isolation not achieved`);
+  }
 
-  // Signal start
-  await natsRequest('mesh.tasks.start', { task_id: task.task_id });
+  // Signal start (include isolation status so daemon knows)
+  await natsRequest('mesh.tasks.start', { task_id: task.task_id, workspace_isolated: workspaceIsolated });
   writeAgentState('working', task.task_id);
   log(`Started: ${task.task_id} (dir: ${worktreePath ? 'worktree' : 'workspace'})`);
 
@@ -1394,8 +1424,9 @@ async function main() {
   log(`  Poll interval: ${POLL_INTERVAL / 1000}s`);
   log(`  Mode:        ${ONCE ? 'single task' : 'continuous'} ${DRY_RUN ? '(dry run)' : ''}`);
 
+  const natsOpts = natsConnectOpts();
   nc = await connect({
-    servers: NATS_URL,
+    ...natsOpts,
     timeout: 5000,
     reconnect: true,
     maxReconnectAttempts: 10,

package/bin/mesh-bridge.js

@@ -21,7 +21,7 @@ const path = require('path');
 const { readTasks, updateTaskInPlace, isoTimestamp, ACTIVE_TASKS_PATH } = require('../lib/kanban-io');
 
 const sc = StringCodec();
-const { NATS_URL } = require('../lib/nats-resolve');
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const DISPATCH_INTERVAL = parseInt(process.env.BRIDGE_DISPATCH_INTERVAL || '10000'); // 10s
 const LOG_DIR = path.join(process.env.HOME, '.openclaw', 'workspace', 'memory', 'mesh-logs');
 const WORKSPACE = path.join(process.env.HOME, '.openclaw', 'workspace');
@@ -726,8 +726,9 @@ async function main() {
   log(`  Dispatch interval: ${DISPATCH_INTERVAL / 1000}s`);
   log(`  Mode:             ${DRY_RUN ? 'dry run' : 'live'}`);
 
+  const natsOpts = natsConnectOpts();
   nc = await connect({
-    servers: NATS_URL,
+    ...natsOpts,
     timeout: 5000,
     reconnect: true,
     maxReconnectAttempts: 10,

package/bin/mesh-deploy.js

@@ -47,6 +47,10 @@ const crypto = require('crypto');
 const IS_MAC = os.platform() === 'darwin';
 const HOME = os.homedir();
 const DEPLOY_BRANCH = process.env.OPENCLAW_DEPLOY_BRANCH || 'main';
+if (!/^[a-zA-Z0-9._\/-]+$/.test(DEPLOY_BRANCH)) {
+  console.error(`Invalid DEPLOY_BRANCH: ${DEPLOY_BRANCH}`);
+  process.exit(1);
+}
 const REPO_DIR = process.env.OPENCLAW_REPO_DIR || path.join(HOME, 'openclaw');
 
 // KNOWN ISSUE: Two-directory problem

package/bin/mesh-health-publisher.js

@@ -36,6 +36,12 @@ const IS_MAC = os.platform() === "darwin";
 
 const { ROLE_COMPONENTS } = require('../lib/mesh-roles');
 
+// ── Circuit Breaker State ───────────────────────────────────────────────
+let consecutiveFailures = 0;
+let skipTicksRemaining = 0;
+let lastErrorMsg = '';
+let lastErrorRepeatCount = 0;
+
 // ── Health Gathering ─────────────────────────────────────────────────────
 // All the expensive execSync calls happen here, on our own schedule.
 // No request timeout to race against.
@@ -226,11 +232,45 @@ async function main() {
 
   // Publish immediately, then every interval
   async function publish() {
+    // Circuit breaker: skip ticks during backoff
+    if (skipTicksRemaining > 0) {
+      skipTicksRemaining--;
+      return;
+    }
+
     try {
       const health = gatherHealth();
       await kv.put(NODE_ID, sc.encode(JSON.stringify(health)));
+      // Reset on success
+      if (consecutiveFailures > 0) {
+        console.log(`[health-publisher] recovered after ${consecutiveFailures} consecutive failures`);
+      }
+      consecutiveFailures = 0;
+      lastErrorMsg = '';
+      lastErrorRepeatCount = 0;
     } catch (err) {
-      console.error("[health-publisher] publish failed:", err.message);
+      consecutiveFailures++;
+      const msg = err.message;
+
+      // Log dedup: after 3 identical consecutive errors, log every 10th
+      if (msg === lastErrorMsg) {
+        lastErrorRepeatCount++;
+        if (lastErrorRepeatCount === 3) {
+          console.error(`[health-publisher] suppressing repeated errors (${lastErrorRepeatCount} occurrences): ${msg}`);
+        } else if (lastErrorRepeatCount > 3 && lastErrorRepeatCount % 10 === 0) {
+          console.error(`[health-publisher] suppressing repeated errors (${lastErrorRepeatCount} occurrences): ${msg}`);
+        }
+        // Silently skip logs between dedup thresholds
+      } else {
+        lastErrorMsg = msg;
+        lastErrorRepeatCount = 1;
+        console.error("[health-publisher] publish failed:", msg);
+      }
+
+      // Exponential backoff: skip 2^min(N,6) ticks (max ~64 ticks / ~16 min at 15s)
+      const backoffTicks = Math.pow(2, Math.min(consecutiveFailures, 6));
+      skipTicksRemaining = backoffTicks;
+      console.error(`[health-publisher] backoff: skipping next ${backoffTicks} ticks (failures=${consecutiveFailures})`);
     }
   }
 

package/bin/mesh-task-daemon.js

@@ -46,7 +46,7 @@ const ROLE_DIRS = [
 ];
 
 const sc = StringCodec();
-const { NATS_URL } = require('../lib/nats-resolve');
+const { NATS_URL, natsConnectOpts } = require('../lib/nats-resolve');
 const BUDGET_CHECK_INTERVAL = 30000; // 30s
 const STALL_MINUTES = parseInt(process.env.MESH_STALL_MINUTES || '5'); // no heartbeat for this long → stalled
 const CIRCLING_STEP_TIMEOUT_MS = parseInt(process.env.MESH_CIRCLING_STEP_TIMEOUT_MS || String(10 * 60 * 1000)); // 10 min default
@@ -2013,7 +2013,8 @@ function cascadeFailure(plan, failedSubtaskId) {
 async function main() {
   log('Starting mesh task daemon...');
 
-  nc = await connect({ servers: NATS_URL, timeout: 5000 });
+  const natsOpts = natsConnectOpts();
+  nc = await connect({ ...natsOpts, timeout: 5000 });
   log(`Connected to NATS at ${NATS_URL}`);
 
   // Initialize task store
@@ -2085,8 +2086,12 @@ async function main() {
   }
 
   // Start enforcement loops
-  const proposalTimer = setInterval(processProposals, BUDGET_CHECK_INTERVAL);
-  const budgetTimer = setInterval(enforceBudgets, BUDGET_CHECK_INTERVAL);
+  const proposalTimer = setInterval(async () => {
+    try { await processProposals(); } catch (err) { log(`processProposals error: ${err.message}`); }
+  }, BUDGET_CHECK_INTERVAL);
+  const budgetTimer = setInterval(async () => {
+    try { await enforceBudgets(); } catch (err) { log(`enforceBudgets error: ${err.message}`); }
+  }, BUDGET_CHECK_INTERVAL);
   const stallTimer = setInterval(detectStalls, BUDGET_CHECK_INTERVAL);
   const recruitTimer = setInterval(checkRecruitingDeadlines, 5000); // check every 5s
   const circlingStepSweepTimer = setInterval(sweepCirclingStepTimeouts, 60000); // every 60s
@@ -2106,6 +2111,11 @@ async function main() {
     clearInterval(budgetTimer);
     clearInterval(stallTimer);
     clearInterval(recruitTimer);
+    if (circlingStepSweepTimer) clearInterval(circlingStepSweepTimer);
+    if (circlingStepTimers) {
+      for (const timer of circlingStepTimers.values()) clearTimeout(timer);
+      circlingStepTimers.clear();
+    }
     for (const sub of subs) sub.unsubscribe();
     await nc.drain();
     process.exit(0);

package/bin/mesh.js

@@ -27,23 +27,7 @@ const { connect, StringCodec, createInbox } = require('nats');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-
-// ─── Config ──────────────────────────────────────────
-// ── 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 { natsConnectOpts } = require('../lib/nats-resolve');
 const SHARED_DIR = path.join(os.homedir(), 'openclaw', 'shared');
 const LOCAL_NODE = os.hostname().toLowerCase().replace(/[^a-z0-9-]/g, '-');
 const sc = StringCodec();
@@ -88,27 +72,16 @@ function remoteNode() {
 
 // ─── Exec safety ─────────────────────────────────────
 
-const DESTRUCTIVE_PATTERNS = [
-  /\brm\s+(-[a-zA-Z]*)?r[a-zA-Z]*f/,      // rm -rf, rm -fr, rm --recursive --force
-  /\brm\s+(-[a-zA-Z]*)?f[a-zA-Z]*r/,       // rm -fr variants
-  /\bmkfs\b/,                                // format filesystem
-  /\bdd\s+.*of=/,                            // raw disk write
-  /\b>\s*\/dev\/[sh]d/,                      // write to raw device
-  /\bcurl\b.*\|\s*(ba)?sh/,                  // curl pipe to shell
-  /\bwget\b.*\|\s*(ba)?sh/,                  // wget pipe to shell
-  /\bchmod\s+(-[a-zA-Z]*\s+)?777\s+\//,     // chmod 777 on root paths
-  /\b:(){ :\|:& };:/,                        // fork bomb
-];
+const { checkDestructivePatterns } = require('../lib/exec-safety');
 
 function checkExecSafety(command) {
-  for (const pattern of DESTRUCTIVE_PATTERNS) {
-    if (pattern.test(command)) {
-      console.error(`BLOCKED: Command matches destructive pattern.`);
-      console.error(`  Command: ${command}`);
-      console.error(`  Pattern: ${pattern}`);
-      console.error(`\nIf this is intentional, SSH into the node and run it directly.`);
-      process.exit(1);
-    }
+  const result = checkDestructivePatterns(command);
+  if (result.blocked) {
+    console.error(`BLOCKED: Command matches destructive pattern.`);
+    console.error(`  Command: ${command}`);
+    console.error(`  Pattern: ${result.pattern}`);
+    console.error(`\nIf this is intentional, SSH into the node and run it directly.`);
+    process.exit(1);
   }
 }
 
@@ -118,10 +91,11 @@ function checkExecSafety(command) {
  * Connect to NATS with a short timeout (this is a CLI tool, not a daemon).
  */
 async function natsConnect() {
+  const opts = natsConnectOpts();
   try {
-    return await connect({ servers: NATS_URL, timeout: 5000 });
+    return await connect({ ...opts, timeout: 5000 });
   } catch (err) {
-    console.error(`Error: Cannot connect to NATS at ${NATS_URL}`);
+    console.error(`Error: Cannot connect to NATS at ${opts.servers}`);
     console.error(`Is the NATS server running? Is Tailscale connected?`);
     process.exit(1);
   }
@@ -891,7 +865,7 @@ async function cmdPlan(args) {
       }
 
       // Submit to mesh via NATS
-      const nc = await connect({ servers: NATS_URL, timeout: 5000 });
+      const nc = await connect({ ...natsConnectOpts(), timeout: 5000 });
       try {
         const reply = await nc.request(
           'mesh.plans.create',
@@ -919,7 +893,7 @@ async function cmdPlan(args) {
         if (args[i] === '--status' && args[i + 1]) { statusFilter = args[++i]; }
       }
 
-      const nc = await connect({ servers: NATS_URL, timeout: 5000 });
+      const nc = await connect({ ...natsConnectOpts(), timeout: 5000 });
       try {
         const payload = statusFilter ? { status: statusFilter } : {};
         const reply = await nc.request(
@@ -952,7 +926,7 @@ async function cmdPlan(args) {
         process.exit(1);
       }
 
-      const nc = await connect({ servers: NATS_URL, timeout: 5000 });
+      const nc = await connect({ ...natsConnectOpts(), timeout: 5000 });
       try {
         const reply = await nc.request(
           'mesh.plans.get',
@@ -1050,7 +1024,7 @@ async function cmdPlan(args) {
         process.exit(1);
       }
 
-      const nc = await connect({ servers: NATS_URL, timeout: 5000 });
+      const nc = await connect({ ...natsConnectOpts(), timeout: 5000 });
       try {
         const reply = await nc.request(
           'mesh.plans.approve',
@@ -1079,7 +1053,7 @@ async function cmdPlan(args) {
         process.exit(1);
       }
 
-      const nc = await connect({ servers: NATS_URL, timeout: 5000 });
+      const nc = await connect({ ...natsConnectOpts(), timeout: 5000 });
       try {
         const reply = await nc.request(
           'mesh.plans.abort',

package/install.sh

@@ -770,8 +770,9 @@ else
     fi
 
     if [ "$OS" = "macos" ]; then
-      TEMPLATE="$LAUNCHD_TEMPLATES/ai.openclaw.${SVC_NAME}.plist"
-      DEST="$LAUNCHD_DEST/ai.openclaw.${SVC_NAME}.plist"
+      LAUNCHD_SVC_NAME="${SVC_NAME#openclaw-}"
+      TEMPLATE="$LAUNCHD_TEMPLATES/ai.openclaw.${LAUNCHD_SVC_NAME}.plist"
+      DEST="$LAUNCHD_DEST/ai.openclaw.${LAUNCHD_SVC_NAME}.plist"
 
       if [ ! -f "$TEMPLATE" ]; then
         warn "  Template not found: $TEMPLATE"

package/lib/agent-activity.js

@@ -147,7 +147,7 @@ async function readLastEntry(filePath) {
     } else {
       const fh = await open(filePath, 'r');
       try {
-        const buffer = Buffer.allocUnsafe(chunkSize);
+        const buffer = Buffer.alloc(chunkSize);
         await fh.read(buffer, 0, chunkSize, offset);
         content = buffer.toString('utf-8');
       } finally {
@@ -195,7 +195,7 @@ async function parseJsonlTail(filePath, maxBytes = 131072) {
       const fh = await open(filePath, 'r');
       try {
         const length = size - offset;
-        const buffer = Buffer.allocUnsafe(length);
+        const buffer = Buffer.alloc(length);
         await fh.read(buffer, 0, length, offset);
         content = buffer.toString('utf-8');
       } finally {