@clawlabz/clawnetwork 0.1.20 → 0.1.22

package/index.ts

@@ -7,7 +7,7 @@ declare function setInterval(fn: () => void, ms: number): unknown
 declare function clearInterval(id: unknown): void
 declare function fetch(url: string, init?: Record<string, unknown>): Promise<{ status: number; ok: boolean; text: () => Promise<string>; json: () => Promise<unknown> }>
 
-const VERSION = '0.1.20'
+const VERSION = '0.1.22'
 const PLUGIN_ID = 'clawnetwork'
 const GITHUB_REPO = 'clawlabz/claw-network'
 const DEFAULT_RPC_PORT = 9710
@@ -484,11 +484,13 @@ interface NodeStatus {
 let nodeStartedAt: number | null = null
 let lastHealth: { blockHeight: number | null; peerCount: number | null; syncing: boolean } = { blockHeight: null, peerCount: null, syncing: false }
 let cachedBinaryVersion: string | null = null
+let activeRpcPort: number | null = null  // actual port the plugin node is running on (may differ from config)
+let activeP2pPort: number | null = null
 
-function isNodeRunning(rpcPort: number = DEFAULT_RPC_PORT): { running: boolean; pid: number | null } {
-  // Check in-memory process first
+function isNodeRunning(): { running: boolean; pid: number | null } {
+  // 1. In-memory process reference
   if (nodeProcess && !nodeProcess.killed) return { running: true, pid: nodeProcess.pid }
-  // Check PID file (for detached processes from previous CLI invocations)
+  // 2. PID file — the ONLY authority for "is MY node running"
   const pidFile = path.join(WORKSPACE_DIR, 'node.pid')
   try {
     const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10)
@@ -499,27 +501,50 @@ function isNodeRunning(rpcPort: number = DEFAULT_RPC_PORT): { running: boolean;
       }
     }
   } catch { /* no file */ }
-  // Last resort: check if RPC port is responding (covers orphaned processes)
-  try {
-    execFileSync('curl', ['-sf', '--max-time', '1', `http://localhost:${rpcPort}/health`], { timeout: 3000, encoding: 'utf8' })
-    // Port is responding — find PID by port
-    try {
-      const lsof = execFileSync('lsof', ['-ti', `:${rpcPort}`], { timeout: 3000, encoding: 'utf8' }).trim()
-      const pid = parseInt(lsof.split('\n')[0], 10)
-      if (pid > 0) {
-        // Write recovered PID to file for future management
-        try { fs.writeFileSync(pidFile, String(pid)) } catch { /* ok */ }
-        return { running: true, pid }
-      }
-    } catch { /* ok */ }
-    return { running: true, pid: null }
-  } catch { /* not responding */ }
+  // No port probing — if we don't have a PID, we don't own any running node
   return { running: false, pid: null }
 }
 
+/** Check if a TCP port is in use via nc -z (works across users, no bind needed) */
+function isPortInUse(port: number): boolean {
+  try {
+    execFileSync('nc', ['-z', '127.0.0.1', String(port)], { timeout: 2000, stdio: 'ignore' })
+    return true // connection succeeded → something is listening
+  } catch {
+    return false // connection refused → port is free
+  }
+}
+
+/** Find available ports starting from the configured ones, skipping occupied ports */
+function findAvailablePorts(rpcPort: number, p2pPort: number, api: OpenClawApi): { rpcPort: number; p2pPort: number } {
+  const MAX_TRIES = 20
+  let rpc = rpcPort
+  let p2p = p2pPort
+
+  // Find available RPC port
+  for (let i = 0; i < MAX_TRIES; i++) {
+    if (!isPortInUse(rpc)) break
+    api.logger?.info?.(`[clawnetwork] RPC port ${rpc} in use, trying ${rpc + 1}...`)
+    rpc++
+  }
+
+  // Find available P2P port
+  for (let i = 0; i < MAX_TRIES; i++) {
+    if (!isPortInUse(p2p)) break
+    api.logger?.info?.(`[clawnetwork] P2P port ${p2p} in use, trying ${p2p + 1}...`)
+    p2p++
+  }
+
+  if (rpc !== rpcPort || p2p !== p2pPort) {
+    api.logger?.info?.(`[clawnetwork] resolved ports: RPC=${rpc} (config=${rpcPort}), P2P=${p2p} (config=${p2pPort})`)
+  }
+  return { rpcPort: rpc, p2pPort: p2p }
+}
+
 function buildStatus(cfg: PluginConfig): NodeStatus {
   const wallet = loadWallet()
-  const nodeState = isNodeRunning(cfg.rpcPort)
+  const nodeState = isNodeRunning()
+  const rpcPort = activeRpcPort ?? cfg.rpcPort
   const uptime = nodeStartedAt ? Math.floor((Date.now() - nodeStartedAt) / 1000) : null
   return {
     running: nodeState.running,
@@ -528,7 +553,7 @@ function buildStatus(cfg: PluginConfig): NodeStatus {
     peerCount: lastHealth.peerCount,
     network: cfg.network,
     syncMode: cfg.syncMode,
-    rpcUrl: `http://localhost:${cfg.rpcPort}`,
+    rpcUrl: `http://localhost:${rpcPort}`,
     walletAddress: wallet?.address ?? '',
     binaryVersion: cachedBinaryVersion,
     pluginVersion: VERSION,
@@ -569,12 +594,12 @@ async function rpcCall(rpcPort: number, method: string, params: unknown[] = []):
 }
 
 function startNodeProcess(binaryPath: string, cfg: PluginConfig, api: OpenClawApi): void {
-  // Guard: check in-memory reference, PID file, AND health endpoint
+  // Guard: check in-memory reference and PID file only (not port)
   if (nodeProcess && !nodeProcess.killed) {
     api.logger?.warn?.('[clawnetwork] node already running (in-memory)')
     return
   }
-  const existingState = isNodeRunning(cfg.rpcPort)
+  const existingState = isNodeRunning()
   if (existingState.running) {
     api.logger?.info?.(`[clawnetwork] node already running (pid=${existingState.pid}), skipping start`)
     return
@@ -583,7 +608,12 @@ function startNodeProcess(binaryPath: string, cfg: PluginConfig, api: OpenClawAp
   if (!isValidNetwork(cfg.network)) { api.logger?.error?.(`[clawnetwork] invalid network: ${cfg.network}`); return }
   if (!isValidSyncMode(cfg.syncMode)) { api.logger?.error?.(`[clawnetwork] invalid sync mode: ${cfg.syncMode}`); return }
 
-  const args = ['start', '--network', cfg.network, '--rpc-port', String(cfg.rpcPort), '--p2p-port', String(cfg.p2pPort), '--sync-mode', cfg.syncMode, '--allow-genesis']
+  // Find available ports (auto-increment if configured ports are occupied by other processes)
+  const ports = findAvailablePorts(cfg.rpcPort, cfg.p2pPort, api)
+  activeRpcPort = ports.rpcPort
+  activeP2pPort = ports.p2pPort
+
+  const args = ['start', '--network', cfg.network, '--rpc-port', String(ports.rpcPort), '--p2p-port', String(ports.p2pPort), '--sync-mode', cfg.syncMode, '--allow-genesis']
 
   // Add bootstrap peers: built-in for the network + user-configured extra peers
   const peers = [...(BOOTSTRAP_PEERS[cfg.network] ?? []), ...cfg.extraBootstrapPeers]
@@ -626,6 +656,10 @@ function startNodeProcess(binaryPath: string, cfg: PluginConfig, api: OpenClawAp
   const pidFile = path.join(WORKSPACE_DIR, 'node.pid')
   fs.writeFileSync(pidFile, String(nodeProcess.pid))
 
+  // Save actual runtime ports to workspace (UI server and health checks read from here)
+  const runtimeCfg = path.join(WORKSPACE_DIR, 'runtime.json')
+  fs.writeFileSync(runtimeCfg, JSON.stringify({ rpcPort: ports.rpcPort, p2pPort: ports.p2pPort, pid: nodeProcess.pid, startedAt: Date.now() }))
+
   nodeProcess.on('exit', (code: number | null) => {
     api.logger?.warn?.(`[clawnetwork] node exited with code ${code}`)
     fs.closeSync(logFd)
@@ -654,7 +688,8 @@ function startHealthCheck(cfg: PluginConfig, api: OpenClawApi): void {
   if (healthTimer) clearTimeout(healthTimer)
 
   const check = async () => {
-    lastHealth = await checkHealth(cfg.rpcPort)
+    const rpcPort = activeRpcPort ?? cfg.rpcPort
+    lastHealth = await checkHealth(rpcPort)
     if (lastHealth.blockHeight !== null) {
       api.logger?.info?.(`[clawnetwork] height=${lastHealth.blockHeight} peers=${lastHealth.peerCount} syncing=${lastHealth.syncing}`)
     }
@@ -673,7 +708,7 @@ function stopNode(api: OpenClawApi): void {
     healthTimer = null
   }
 
-  // Find PID: in-memory process or PID file (for detached processes)
+  // Find PID: in-memory process or PID file — the ONLY ways to identify our node
   let pid: number | null = nodeProcess?.pid ?? null
   const pidFile = path.join(WORKSPACE_DIR, 'node.pid')
   if (!pid) {
@@ -685,23 +720,26 @@ function stopNode(api: OpenClawApi): void {
 
   if (pid) {
     api.logger?.info?.(`[clawnetwork] stopping node pid=${pid} (SIGTERM)...`)
-    try { process.kill(pid, 'SIGTERM') } catch { /* already dead */ }
+    try { process.kill(pid, 'SIGTERM') } catch (e: unknown) {
+      api.logger?.warn?.(`[clawnetwork] failed to kill pid=${pid}: ${(e as Error).message}`)
+    }
     setTimeout(() => {
       try { process.kill(pid as number, 'SIGKILL') } catch { /* ok */ }
     }, 10_000)
+  } else {
+    api.logger?.warn?.('[clawnetwork] no PID found — cannot stop node (may not be running)')
   }
 
   // Write stop signal file (tells restart loop in other CLI processes to stop)
   const stopFile = path.join(WORKSPACE_DIR, 'stop.signal')
   try { fs.writeFileSync(stopFile, String(Date.now())) } catch { /* ok */ }
 
-  // Fallback: only use pkill if we had no PID to target (avoids killing other profiles' nodes)
-  if (!pid) {
-    try { execFileSync('pkill', ['-f', 'claw-node start'], { timeout: 3000 }) } catch { /* ok */ }
-  }
+  // NO pkill — we only kill our own process identified by PID file
 
   nodeProcess = null
   nodeStartedAt = null
+  activeRpcPort = null
+  activeP2pPort = null
   lastHealth = { blockHeight: null, peerCount: null, syncing: false }
   try { fs.unlinkSync(pidFile) } catch { /* ok */ }
 }
@@ -1716,24 +1754,16 @@ async function handle(req, res) {
     }
     if (a === 'start') {
       try {
-        // Check if already running — try RPC health first (covers stale PID file)
+        // Check if already running — PID file is the only authority
         const pidFile = OC_PID_FILE;
-        try {
-          const h = await fetchJson('http://localhost:' + RPC_PORT + '/health');
-          if (h && (h.status === 'ok' || h.status === 'degraded')) {
-            try {
-              const { execSync } = require('child_process');
-              const pgrep = execSync("pgrep -f 'claw-node start'", { encoding: 'utf8', timeout: 3000 }).trim();
-              const livePid = parseInt(pgrep.split('\\n')[0], 10);
-              if (livePid > 0) fs.writeFileSync(pidFile, String(livePid));
-            } catch {}
-            json(200, { message: 'Node already running' }); return;
-          }
-        } catch {}
-        // Fallback: check PID file
         try {
           const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
-          if (pid > 0) { try { process.kill(pid, 0); json(200, { message: 'Node already running', pid }); return; } catch {} }
+          if (pid > 0) {
+            try { process.kill(pid, 0); json(200, { message: 'Node already running', pid }); return; } catch {
+              // PID stale, clean up
+              try { fs.unlinkSync(pidFile); } catch {}
+            }
+          }
         } catch {}
         // Find binary
         const binDir = OC_BIN_DIR;
@@ -1786,14 +1816,14 @@ async function handle(req, res) {
         // Write stop signal for restart loop
         const stopFile = OC_STOP_SIGNAL;
         try { fs.writeFileSync(stopFile, String(Date.now())); } catch {}
-        // Also kill by name (covers orphans)
-        try { require('child_process').execFileSync('pkill', ['-f', 'claw-node start'], { timeout: 3000 }); } catch {}
-        try { fs.unlinkSync(pidFile); } catch {}
-        // Wait for process to actually exit (max 5s)
-        for (let w = 0; w < 10; w++) {
-          try { require('child_process').execSync("pgrep -f 'claw-node start'", { timeout: 1000 }); } catch { break; }
-          require('child_process').execSync('sleep 0.5', { timeout: 2000 });
+        // Wait for our process to exit (max 5s), using PID-specific check
+        if (pid && pid > 0) {
+          for (let w = 0; w < 10; w++) {
+            try { process.kill(pid, 0); } catch { break; }
+            require('child_process').execSync('sleep 0.5', { timeout: 2000 });
+          }
         }
+        try { fs.unlinkSync(pidFile); } catch {}
         json(200, { message: 'Node stopped' });
       } catch (e) { json(500, { error: e.message }); }
       return;
@@ -1808,13 +1838,17 @@ async function handle(req, res) {
         } catch {}
         const stopFile = OC_STOP_SIGNAL;
         try { fs.writeFileSync(stopFile, String(Date.now())); } catch {}
-        try { require('child_process').execFileSync('pkill', ['-f', 'claw-node start'], { timeout: 3000 }); } catch {}
+        // Wait for our process to exit (PID-specific)
+        try {
+          const stoppedPid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
+          if (stoppedPid > 0) {
+            for (let w = 0; w < 10; w++) {
+              try { process.kill(stoppedPid, 0); } catch { break; }
+              require('child_process').execSync('sleep 0.5', { timeout: 2000 });
+            }
+          }
+        } catch {}
         try { fs.unlinkSync(pidFile); } catch {}
-        // Wait for exit
-        for (let w = 0; w < 10; w++) {
-          try { require('child_process').execSync("pgrep -f 'claw-node start'", { timeout: 1000 }); } catch { break; }
-          require('child_process').execSync('sleep 0.5', { timeout: 2000 });
-        }
         try { fs.unlinkSync(stopFile); } catch {}
         // Now start (reuse start logic inline)
         const binDir = OC_BIN_DIR;
@@ -1858,7 +1892,7 @@ async function handle(req, res) {
           const pid = parseInt(fs.readFileSync(pidFile, 'utf8').trim(), 10);
           if (pid > 0) try { process.kill(pid, 'SIGTERM'); } catch {}
         } catch {}
-        try { require('child_process').execFileSync('pkill', ['-f', 'claw-node start'], { timeout: 5000 }); } catch {}
+        // No pkill — only target our own PID
 
         // 2. Download latest binary
         const binDir = OC_BIN_DIR;
@@ -2158,7 +2192,7 @@ export default function register(api: OpenClawApi) {
 
     const handleStart = async () => {
       // Check if already running (in-memory or detached via PID file)
-      const state = isNodeRunning(cfg.rpcPort)
+      const state = isNodeRunning()
       if (state.running) {
         out({ message: 'Node already running', pid: state.pid })
         return
@@ -2421,7 +2455,7 @@ export default function register(api: OpenClawApi) {
       ;(async () => {
         try {
           // Check if already running (e.g. from a previous detached start)
-          const state = isNodeRunning(cfg.rpcPort)
+          const state = isNodeRunning()
           if (state.running) {
             api.logger?.info?.(`[clawnetwork] node already running (pid=${state.pid})`)
 
@@ -2431,10 +2465,18 @@ export default function register(api: OpenClawApi) {
               const binary = findBinary()
               const localBinaryVersion = binary ? getBinaryVersion(binary) : null
 
-              // Get the RUNNING process version from health endpoint (not the file version)
+              // Read actual runtime port from last run (may differ from config if port was auto-shifted)
+              let runtimeRpcPort = cfg.rpcPort
+              try {
+                const rt = JSON.parse(fs.readFileSync(path.join(WORKSPACE_DIR, 'runtime.json'), 'utf8'))
+                if (rt.rpcPort) { runtimeRpcPort = rt.rpcPort; activeRpcPort = rt.rpcPort }
+                if (rt.p2pPort) { activeP2pPort = rt.p2pPort }
+              } catch { /* no runtime file, use config */ }
+
+              // Get the RUNNING process version from health endpoint
               let runningProcessVersion: string | null = null
               try {
-                const health = await fetch(`http://localhost:${cfg.rpcPort}/health`)
+                const health = await fetch(`http://localhost:${runtimeRpcPort}/health`)
                 if (health.ok) {
                   const hd = await health.json() as Record<string, unknown>
                   if (typeof hd.version === 'string') runningProcessVersion = hd.version.replace(/^v/, '')

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "clawnetwork",
   "name": "ClawNetwork Node",
   "description": "Run a ClawNetwork blockchain node inside OpenClaw. Every agent is a node.",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawlabz/clawnetwork",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Run a ClawNetwork blockchain node inside OpenClaw. Every agent is a blockchain node.",
   "type": "module",
   "license": "MIT",