oomi-ai 0.2.40 → 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';
@@ -39,7 +40,9 @@ const LEGACY_WEBSPATIAL_TEMPLATE_FILE_RULES = [
     relativePath: path.join('src', 'spatial.ts'),
     shouldReplace: (content) =>
       !content.includes('WEBSPATIAL_FORK_REPOSITORY') ||
-      !content.includes('configurePersonaScene'),
+      !content.includes('configurePersonaScene') ||
+      content.includes('WEBSPATIAL_FORK_COMMIT = "b2746721e4fe6b4f86dac0ea55938074eea00cda"') ||
+      content.includes('WEBSPATIAL_FORK_COMMIT = "8904ac8fec48fe49ee14d1739237bd1afb2894fe"'),
   },
   {
     relativePath: path.join('src', 'main.tsx'),
@@ -57,21 +60,44 @@ const LEGACY_WEBSPATIAL_TEMPLATE_FILE_RULES = [
   {
     relativePath: path.join('src', 'pages', 'HomePage.tsx'),
     shouldReplace: (content) =>
-      content.includes('Open Spatial Scene') &&
-      content.includes('Open Scene Route'),
+      (content.includes('Open Spatial Scene') &&
+      content.includes('Open Scene Route')) ||
+      (content.includes('Launch Spatial Surface') &&
+      content.includes('Open Browser Preview') &&
+      content.includes('Focused surface') &&
+      !content.includes('sceneMode')) ||
+      content.includes('enable-xr-monitor={sceneMode || undefined}') ||
+      content.includes('enable-xr={sceneMode || undefined}') ||
+      (
+        content.includes('persona-panel persona-runtime" enable-xr') ||
+        content.includes('persona-button" onClick={openPersonaScene} enable-xr') ||
+        content.includes('persona-link" to="/scene" target="_blank" enable-xr') ||
+        content.includes('persona-card" enable-xr style={xrStyle(')
+      ),
   },
   {
     relativePath: path.join('src', 'pages', 'ScenePage.tsx'),
     shouldReplace: (content) =>
-      !content.includes('enable-xr-monitor') &&
-      content.includes(
-        'This route is intentionally separate so WebSpatial scene launching has a dedicated',
+      (
+        !content.includes('enable-xr-monitor') &&
+        content.includes(
+          'This route is intentionally separate so WebSpatial scene launching has a dedicated',
+        )
+      ) ||
+      (
+        content.includes('Awaiting AndroidXR interaction') &&
+        content.includes('Interaction Console') &&
+        content.includes('Fork-backed proof points')
       ),
   },
   {
     relativePath: path.join('src', 'App.css'),
     shouldReplace: (content) =>
-      content.includes('.scene-panel') && !content.includes('.scene-interaction-grid'),
+      (content.includes('.scene-panel') && !content.includes('.scene-interaction-grid')) ||
+      content.includes('html.is-spatial .persona-runtime {') ||
+      content.includes('html.is-spatial .persona-scene-root {') ||
+      content.includes('html.is-spatial .persona-button,') ||
+      content.includes('html.is-spatial .persona-card,'),
   },
   {
     relativePath: 'vite.config.ts',
@@ -173,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) {
@@ -729,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.40",
+  "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.40",
+  "version": "0.2.42",
   "description": "Oomi OpenClaw channel plugin and bridge tooling",
   "bin": {
     "oomi": "bin/oomi-ai.js"

package/templates/persona-app/src/App.css

@@ -105,6 +105,10 @@ code {
   gap: 24px;
 }
 
+.persona-scene-root {
+  position: relative;
+}
+
 .persona-header,
 .persona-grid,
 .scene-interaction-grid,
@@ -594,19 +598,11 @@ html.is-spatial body {
   background: transparent;
 }
 
-html.is-spatial .persona-button,
-html.is-spatial .persona-link,
 html.is-spatial .scene-chip,
 html.is-spatial .scene-material-chip {
   --xr-background-material: regular;
 }
 
-html.is-spatial .persona-runtime {
-  transform: translateZ(20px) rotateX(10deg);
-  transform-origin: top right;
-}
-
-html.is-spatial .persona-card,
 html.is-spatial .scene-ops-card,
 html.is-spatial .scene-interaction-card,
 html.is-spatial .scene-proof-card,

package/templates/persona-app/src/pages/HomePage.tsx

@@ -47,9 +47,9 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
   }, []);
 
   return (
-    <main className="persona-shell" enable-xr-monitor={sceneMode || undefined}>
+    <main className={`persona-shell${sceneMode ? " persona-scene-root" : ""}`}>
       <section className="persona-header">
-        <div className="persona-panel persona-hero" enable-xr style={xrStyle(22, "translucent")}>
+        <div className="persona-panel persona-hero">
           <div>
             <p className="persona-eyebrow">{sceneMode ? "Spatial Persona Surface" : "WebSpatial Persona"}</p>
             <h1 className="persona-title">{personaConfig.name}</h1>
@@ -59,15 +59,15 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
           <div className="persona-actions">
             {!sceneMode ? (
               <>
-                <button className="persona-button" onClick={openPersonaScene} enable-xr style={xrStyle(52, "regular")}>
+                <button className="persona-button" onClick={openPersonaScene}>
                   Launch Spatial Surface
                 </button>
-                <Link className="persona-link" to="/scene" target="_blank" enable-xr style={xrStyle(92, "thin")}>
+                <Link className="persona-link" to="/scene" target="_blank">
                   Open Spatial Preview
                 </Link>
               </>
             ) : (
-              <Link className="persona-button" to="/" enable-xr style={xrStyle(52, "regular")}>
+              <Link className="persona-button" to="/">
                 Return To Browser View
               </Link>
             )}
@@ -89,7 +89,7 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
           </div>
         </div>
 
-        <aside className="persona-panel persona-runtime" enable-xr style={xrStyle(72, "thin")}>
+        <aside className="persona-panel persona-runtime">
           <p className="persona-eyebrow">Runtime</p>
           <div className="runtime-list">
             <div className="runtime-row">
@@ -117,7 +117,7 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
       </section>
 
       <section className="persona-grid">
-        <article className="persona-panel persona-card" enable-xr style={xrStyle(34, "translucent")}>
+        <article className="persona-panel persona-card">
           <h2>What Good XR Feels Like</h2>
           <p>
             Treat the generated persona site like a spatial work surface. The XR route should keep
@@ -131,7 +131,7 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
           </p>
         </article>
 
-        <article className="persona-panel persona-card" enable-xr style={xrStyle(74, "thin")}>
+        <article className="persona-panel persona-card">
           <h2>Editing Notes</h2>
           <ul className="persona-note-list">
             {personaNotes.map(note => (
@@ -140,7 +140,7 @@ export function HomePage({ sceneMode = false }: HomePageProps) {
           </ul>
         </article>
 
-        <article className="persona-panel persona-card persona-scene-card" enable-xr style={xrStyle(118, "regular")}>
+        <article className="persona-panel persona-card persona-scene-card">
           <h2>Scene Contract</h2>
           <p>
             The page should import WebSpatial helpers, self-configure the scene, and keep using

package/templates/persona-app/src/spatial.ts

@@ -3,7 +3,7 @@ import { initScene, version as webSpatialSdkVersion } from "@webspatial/react-sd
 
 export const PERSONA_SCENE_NAME = "personaScene";
 export const WEBSPATIAL_FORK_REPOSITORY = "https://github.com/zill4/webspatial-sdk";
-export const WEBSPATIAL_FORK_COMMIT = "b2746721e4fe6b4f86dac0ea55938074eea00cda";
+export const WEBSPATIAL_FORK_COMMIT = "ac4bd47eb14a894ffef34a4044ddd0bbd47f3e72";
 
 type SpatialWindow = Window & {
   webspatialBridge?: unknown;

package/templates/persona-app/vendor/webspatial/FORK.md

@@ -1,6 +1,6 @@
 This persona template vendors the AndroidXR-capable WebSpatial runtime packages from:
 
 - Repository: https://github.com/zill4/webspatial-sdk
-- Commit: 8904ac8fec48fe49ee14d1739237bd1afb2894fe
+- Commit: ac4bd47eb14a894ffef34a4044ddd0bbd47f3e72
 
 Oomi uses these vendored packages for persona runtimes so OpenClaw installs the AndroidXR-enabled fork instead of the stock npm release.