oomi-ai 0.2.41 → 0.2.42

package/lib/personaRuntimeManager.js

@@ -210,28 +210,32 @@ async function ensureWorkspaceInstall({
   return true;
 }
 
-function buildRuntimeRegistration({
-  localRuntime,
-  entryUrl,
-  transport,
-}) {
-  const safeEntryUrl = trimString(entryUrl);
-  if (safeEntryUrl) {
-    return {
-      endpoint: safeEntryUrl,
-      transport: trimString(transport) || 'relay',
-      healthcheckUrl: localRuntime.healthcheckUrl,
-      localPort: localRuntime.localPort,
-    };
-  }
-
-  return {
-    endpoint: localRuntime.endpoint,
-    transport: trimString(transport) || localRuntime.transport,
-    healthcheckUrl: localRuntime.healthcheckUrl,
-    localPort: localRuntime.localPort,
-  };
-}
+function buildRuntimeRegistration({
+  localRuntime,
+  entryUrl,
+  transport,
+}) {
+  const safeEntryUrl = trimString(entryUrl);
+  if (safeEntryUrl) {
+    return {
+      endpoint: safeEntryUrl,
+      transport: trimString(transport) || 'relay',
+      healthcheckUrl: localRuntime.healthcheckUrl,
+      localPort: localRuntime.localPort,
+      localEndpoint: localRuntime.endpoint,
+      reachableEndpoint: localRuntime.reachableEndpoint,
+    };
+  }
+
+  return {
+    endpoint: localRuntime.reachableEndpoint || localRuntime.endpoint,
+    transport: trimString(transport) || localRuntime.transport,
+    healthcheckUrl: localRuntime.healthcheckUrl,
+    localPort: localRuntime.localPort,
+    localEndpoint: localRuntime.endpoint,
+    reachableEndpoint: localRuntime.reachableEndpoint,
+  };
+}
 
 export async function launchManagedPersonaRuntime({
   slug,
@@ -272,13 +276,25 @@ export async function launchManagedPersonaRuntime({
   });
 
   const healthPath = scaffoldInfo.healthPath || resolveHealthPath(workspacePath);
-  const preferredPort = previousState.localPort || scaffoldInfo.defaultPort;
-
-  let reusingRunningProcess = false;
-  if (!restart && Number.isInteger(previousState.pid) && isPersonaWorkspaceProcessRunning(previousState.pid)) {
-    try {
-      await waitForPersonaRuntime({
-        healthcheckUrl: previousState.healthcheckUrl || buildLocalPersonaRuntime({
+  const preferredPort = previousState.localPort || scaffoldInfo.defaultPort;
+  const expectedDevCommand = resolvePersonaDevCommand({
+    workspacePath,
+    localPort: preferredPort,
+  });
+
+  let reusingRunningProcess = false;
+  if (
+    !restart &&
+    Number.isInteger(previousState.pid) &&
+    isPersonaWorkspaceProcessRunning(previousState.pid, {
+      workspacePath,
+      expectedCommand: expectedDevCommand,
+      localPort: preferredPort,
+    })
+  ) {
+    try {
+      await waitForPersonaRuntime({
+        healthcheckUrl: previousState.healthcheckUrl || buildLocalPersonaRuntime({
           localPort: preferredPort,
           healthPath,
         }).healthcheckUrl,
@@ -326,24 +342,27 @@ export async function launchManagedPersonaRuntime({
     entryUrl,
     transport,
   });
-  const runtimeState = updatePersonaRuntimeState(workspacePath, {
+  const runtimeState = updatePersonaRuntimeState(workspacePath, {
     slug: safeSlug,
     name: safeName,
     description: safeDescription,
     workspacePath,
     templateVersion,
-    localPort: localRuntime.localPort,
-    localEndpoint: localRuntime.endpoint,
-    endpoint: registration.endpoint,
-    entryUrl: registration.endpoint,
+    localPort: localRuntime.localPort,
+    localEndpoint: localRuntime.endpoint,
+    reachableEndpoint: localRuntime.reachableEndpoint,
+    bindHost: localRuntime.bindHost,
+    reachableHost: localRuntime.reachableHost,
+    endpoint: registration.endpoint,
+    entryUrl: registration.endpoint,
     transport: registration.transport,
     healthcheckUrl: localRuntime.healthcheckUrl,
     pid: processInfo.pid,
     logFilePath: processInfo.logFilePath,
-    status: 'running',
-    lastStartedAt: new Date().toISOString(),
-    devCommand: resolvePersonaDevCommand({ workspacePath, localPort }),
-  });
+    status: 'running',
+    lastStartedAt: new Date().toISOString(),
+    devCommand: resolvePersonaDevCommand({ workspacePath, localPort }),
+  });
 
   return {
     ok: true,

package/lib/personaRuntimeProcess.js

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
@@ -198,9 +199,96 @@ function normalizePositiveInteger(value) {
   return Math.floor(parsed);
 }
 
-function resolvePersonaBindHost() {
+function isWildcardHost(host) {
+  const normalized = String(host || '').trim().toLowerCase();
+  return normalized === '0.0.0.0' || normalized === '::' || normalized === '[::]';
+}
+
+function isLoopbackHost(host) {
+  const normalized = String(host || '').trim().toLowerCase();
+  return normalized === 'localhost' || normalized === '127.0.0.1' || normalized === '::1' || normalized === '[::1]';
+}
+
+function isPrivateIpv4(address) {
+  if (!/^\d+\.\d+\.\d+\.\d+$/u.test(address)) {
+    return false;
+  }
+
+  const [first, second] = address.split('.').map((segment) => Number(segment));
+  if (first === 10) return true;
+  if (first === 192 && second === 168) return true;
+  if (first === 172 && second >= 16 && second <= 31) return true;
+  return false;
+}
+
+function scorePersonaNetworkCandidate(candidate) {
+  let score = 0;
+  const name = String(candidate.name || '').toLowerCase();
+  const address = String(candidate.address || '');
+
+  if (isPrivateIpv4(address)) score += 40;
+  if (address.startsWith('192.168.')) score += 8;
+  if (address.startsWith('10.')) score += 6;
+  if (/ethernet|wi-?fi|wlan|en\d|eth\d/iu.test(name)) score += 12;
+  if (/hyper-v|vethernet|wsl|docker|vmware|virtualbox|tailscale|loopback|bridge/iu.test(name)) score -= 30;
+  if (address.startsWith('169.254.')) score -= 100;
+  return score;
+}
+
+function formatPersonaRuntimeHostForUrl(host) {
+  const safeHost = String(host || '').trim();
+  if (!safeHost) {
+    return '127.0.0.1';
+  }
+  if (safeHost.includes(':') && !safeHost.startsWith('[')) {
+    return `[${safeHost}]`;
+  }
+  return safeHost;
+}
+
+export function resolvePersonaBindHost() {
   const value = String(process.env.OOMI_PERSONA_BIND_HOST || '').trim();
-  return value || '127.0.0.1';
+  return value || '0.0.0.0';
+}
+
+export function resolvePersonaReachableHost({
+  bindHost = resolvePersonaBindHost(),
+  env = process.env,
+  networkInterfaces = os.networkInterfaces(),
+} = {}) {
+  const explicit = String(env.OOMI_PERSONA_PUBLIC_HOST || '').trim();
+  if (explicit) {
+    return explicit;
+  }
+
+  const safeBindHost = String(bindHost || '').trim();
+  if (safeBindHost && !isWildcardHost(safeBindHost) && !isLoopbackHost(safeBindHost)) {
+    return safeBindHost;
+  }
+
+  const candidates = [];
+  for (const [name, entries] of Object.entries(networkInterfaces || {})) {
+    for (const entry of Array.isArray(entries) ? entries : []) {
+      if (!entry || entry.internal || entry.family !== 'IPv4') {
+        continue;
+      }
+
+      const address = String(entry.address || '').trim();
+      if (!address || isLoopbackHost(address) || address.startsWith('169.254.')) {
+        continue;
+      }
+
+      candidates.push({
+        name,
+        address,
+      });
+    }
+  }
+
+  const winner = candidates
+    .sort((left, right) => scorePersonaNetworkCandidate(right) - scorePersonaNetworkCandidate(left))[0];
+
+  return winner?.address || '127.0.0.1';
 }
 
 function trimString(value) {
@@ -754,23 +842,29 @@ export async function waitForPersonaRuntime({
   throw new Error(`Timed out waiting for persona runtime healthcheck: ${message}`);
 }
 
-export function buildLocalPersonaRuntime({
-  localPort,
-  healthPath,
-}) {
-  const port = Number(localPort);
-  if (!Number.isFinite(port) || port <= 0) {
-    throw new Error('Local port is required.');
-  }
-
-  const endpoint = `http://127.0.0.1:${port}`;
-  return {
-    transport: 'local',
-    endpoint,
-    localPort: port,
-    healthcheckUrl: `${endpoint}${healthPath}`,
-  };
-}
+export function buildLocalPersonaRuntime({
+  localPort,
+  healthPath,
+}) {
+  const port = Number(localPort);
+  if (!Number.isFinite(port) || port <= 0) {
+    throw new Error('Local port is required.');
+  }
+
+  const bindHost = resolvePersonaBindHost();
+  const reachableHost = resolvePersonaReachableHost({ bindHost });
+  const endpoint = `http://127.0.0.1:${port}`;
+  const reachableEndpoint = `http://${formatPersonaRuntimeHostForUrl(reachableHost)}:${port}`;
+  return {
+    transport: 'local',
+    endpoint,
+    reachableEndpoint,
+    bindHost,
+    reachableHost,
+    localPort: port,
+    healthcheckUrl: `${endpoint}${healthPath}`,
+  };
+}
 
 export function defaultPersonaWorkspaceRoot() {
   return resolveOpenclawPersonasDir();

package/lib/personaRuntimeSupervisor.js

@@ -4,8 +4,8 @@ import path from 'node:path';
 import { resolveOpenclawLegacyPersonasDir } from './openclawPaths.js';
 import { createPersonaApiClient } from './personaApiClient.js';
 import { launchManagedPersonaRuntime } from './personaRuntimeManager.js';
-import { readPersonaRuntimeState } from './personaRuntimeRegistry.js';
-import { isPersonaWorkspaceProcessRunning } from './personaRuntimeProcess.js';
+import { readPersonaRuntimeState, updatePersonaRuntimeState } from './personaRuntimeRegistry.js';
+import { buildLocalPersonaRuntime, isPersonaWorkspaceProcessRunning, resolvePersonaDevCommand } from './personaRuntimeProcess.js';
 
 function trimString(value) {
   return typeof value === 'string' ? value.trim() : '';
@@ -17,6 +17,20 @@ function wait(ms) {
   });
 }
 
+function resolveHealthPath(healthcheckUrl) {
+  const safeUrl = trimString(healthcheckUrl);
+  if (!safeUrl) {
+    return '/oomi.health.json';
+  }
+
+  try {
+    const parsed = new URL(safeUrl);
+    return `${parsed.pathname || '/oomi.health.json'}${parsed.search || ''}`;
+  } catch {
+    return '/oomi.health.json';
+  }
+}
+
 function listWorkspacePaths(workspaceRoot) {
   const roots = [trimString(workspaceRoot), trimString(resolveOpenclawLegacyPersonasDir())]
     .filter(Boolean)
@@ -76,14 +90,29 @@ async function reconcileWorkspace({
   const runtime = {
     slug,
     endpoint: trimString(state.endpoint || state.entryUrl || state.localEndpoint),
+    localEndpoint: trimString(state.localEndpoint),
+    reachableEndpoint: trimString(state.reachableEndpoint),
     healthcheckUrl: trimString(state.healthcheckUrl),
     transport: trimString(state.transport) || 'local',
     localPort: Number.isFinite(Number(state.localPort)) ? Number(state.localPort) : null,
   };
 
+  const localRuntime = runtime.localPort
+    ? buildLocalPersonaRuntime({
+        localPort: runtime.localPort,
+        healthPath: resolveHealthPath(runtime.healthcheckUrl),
+      })
+    : null;
+
+  const expectedDevCommand = runtime.localPort
+    ? resolvePersonaDevCommand({
+        workspacePath,
+        localPort: runtime.localPort,
+      })
+    : state.devCommand;
   const processRunning = isPersonaWorkspaceProcessRunning(state.pid, {
     workspacePath,
-    expectedCommand: state.devCommand,
+    expectedCommand: expectedDevCommand,
     localPort: runtime.localPort,
   });
 
@@ -110,6 +139,8 @@ async function reconcileWorkspace({
       effectiveRuntime = {
         slug,
         endpoint: launchResult.runtime.endpoint,
+        localEndpoint: launchResult.runtime.localEndpoint || launchResult.localRuntime.endpoint,
+        reachableEndpoint: launchResult.runtime.reachableEndpoint || launchResult.localRuntime.reachableEndpoint,
         healthcheckUrl: launchResult.runtime.healthcheckUrl,
         transport: launchResult.runtime.transport,
         localPort: launchResult.runtime.localPort,
@@ -138,6 +169,48 @@ async function reconcileWorkspace({
     return;
   }
 
+  if (localRuntime) {
+    const desiredEndpoint = localRuntime.reachableEndpoint || runtime.endpoint;
+    const endpointChanged = desiredEndpoint && desiredEndpoint !== effectiveRuntime.endpoint;
+    const localEndpointChanged = localRuntime.endpoint !== effectiveRuntime.localEndpoint;
+    const reachableEndpointChanged = localRuntime.reachableEndpoint !== effectiveRuntime.reachableEndpoint;
+
+    if (endpointChanged || localEndpointChanged || reachableEndpointChanged) {
+      effectiveRuntime = {
+        ...effectiveRuntime,
+        endpoint: desiredEndpoint,
+        localEndpoint: localRuntime.endpoint,
+        reachableEndpoint: localRuntime.reachableEndpoint,
+      };
+      updatePersonaRuntimeState(workspacePath, {
+        endpoint: desiredEndpoint,
+        entryUrl: desiredEndpoint,
+        localEndpoint: localRuntime.endpoint,
+        reachableEndpoint: localRuntime.reachableEndpoint,
+        bindHost: localRuntime.bindHost,
+        reachableHost: localRuntime.reachableHost,
+      });
+
+      try {
+        await client.registerRuntime({
+          slug,
+          endpoint: effectiveRuntime.endpoint,
+          healthcheckUrl: effectiveRuntime.healthcheckUrl,
+          localPort: effectiveRuntime.localPort,
+          transport: effectiveRuntime.transport,
+          startedAt: new Date().toISOString(),
+        });
+      } catch (error) {
+        logger.warn?.(
+          `[persona-runtime] registration refresh failed for ${slug}: ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        );
+        return;
+      }
+    }
+  }
+
   try {
     await client.heartbeatRuntime({
       slug,

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "oomi-ai",
   "name": "Oomi Channel Plugin",
   "description": "Managed Oomi channel integration for OpenClaw.",
-  "version": "0.2.41",
+  "version": "0.2.42",
   "author": "Oomi",
   "license": "MIT",
   "openclawVersion": ">=0.5.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.2.41",
+  "version": "0.2.42",
   "description": "Oomi OpenClaw channel plugin and bridge tooling",
   "bin": {
     "oomi": "bin/oomi-ai.js"