oomi-ai 0.2.38 → 0.2.40

package/lib/personaRuntimeProcess.js

@@ -1,16 +1,155 @@
-import fs from 'node:fs';
-import path from 'node:path';
+import fs from 'node:fs';
+import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
-
-import { resolveOpenclawPersonasDir } from './openclawPaths.js';
+import { fileURLToPath } from 'node:url';
+
+import { resolveOpenclawPersonasDir } from './openclawPaths.js';
+import {
+  DEFAULT_TEMPLATE_ID,
+  DEFAULT_TEMPLATE_VERSION,
+  renderTemplateFile,
+  resolveTemplateRoot,
+} from './template.js';
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const PERSONA_TEMPLATE_ROOT = resolveTemplateRoot(
+  DEFAULT_TEMPLATE_ID,
+  DEFAULT_TEMPLATE_VERSION,
+);
+const PERSONA_TEMPLATE_PACKAGE_JSON_PATH = path.join(PERSONA_TEMPLATE_ROOT, 'package.json');
+const PERSONA_TEMPLATE_PACKAGE_JSON = fs.existsSync(PERSONA_TEMPLATE_PACKAGE_JSON_PATH)
+  ? JSON.parse(fs.readFileSync(PERSONA_TEMPLATE_PACKAGE_JSON_PATH, 'utf8'))
+  : {};
+const WEBSPATIAL_VENDOR_ROOT = path.join(
+  PACKAGE_ROOT,
+  'templates',
+  'persona-app',
+  'vendor',
+  'webspatial',
+);
+const VENDORED_WEBSPATIAL_CORE_SPEC = 'file:./vendor/webspatial/core-sdk';
+const VENDORED_WEBSPATIAL_REACT_SPEC = 'file:./vendor/webspatial/react-sdk';
+const WEBSPATIAL_TEMPLATE_DEV_DEPENDENCIES = [
+  '@webspatial/builder',
+  '@webspatial/platform-visionos',
+  '@webspatial/vite-plugin',
+];
+const LEGACY_WEBSPATIAL_TEMPLATE_FILE_RULES = [
+  {
+    relativePath: path.join('src', 'spatial.ts'),
+    shouldReplace: (content) =>
+      !content.includes('WEBSPATIAL_FORK_REPOSITORY') ||
+      !content.includes('configurePersonaScene'),
+  },
+  {
+    relativePath: path.join('src', 'main.tsx'),
+    shouldReplace: (content) =>
+      !content.includes('snapdom') &&
+      !content.includes('html2canvas') &&
+      content.includes('createRoot(document.getElementById("root")!)'),
+  },
+  {
+    relativePath: path.join('src', 'App.tsx'),
+    shouldReplace: (content) =>
+      content.includes('<Route path="/" element={<HomePage />} />') ||
+      content.includes('<Route path="/scene" element={<ScenePage />} />'),
+  },
+  {
+    relativePath: path.join('src', 'pages', 'HomePage.tsx'),
+    shouldReplace: (content) =>
+      content.includes('Open Spatial Scene') &&
+      content.includes('Open Scene Route'),
+  },
+  {
+    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',
+      ),
+  },
+  {
+    relativePath: path.join('src', 'App.css'),
+    shouldReplace: (content) =>
+      content.includes('.scene-panel') && !content.includes('.scene-interaction-grid'),
+  },
+  {
+    relativePath: 'vite.config.ts',
+    shouldReplace: (content) =>
+      content.includes('webSpatial()') && !content.includes('optimizeDeps'),
+  },
+];
 
 function resolveNpmCommand() {
   return process.platform === 'win32' ? 'npm.cmd' : 'npm';
 }
 
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function copyDirectory(sourcePath, targetPath) {
+  ensureDir(targetPath);
+  let changed = false;
+  const sourceEntries = fs.readdirSync(sourcePath, { withFileTypes: true });
+  const sourceEntryNames = new Set(sourceEntries.map((entry) => entry.name));
+  const existingTargetEntries = fs.readdirSync(targetPath, { withFileTypes: true });
+
+  for (const entry of existingTargetEntries) {
+    if (sourceEntryNames.has(entry.name)) {
+      continue;
+    }
+    fs.rmSync(path.join(targetPath, entry.name), { recursive: true, force: true });
+    changed = true;
+  }
+
+  for (const entry of sourceEntries) {
+    const sourceEntryPath = path.join(sourcePath, entry.name);
+    const targetEntryPath = path.join(targetPath, entry.name);
+    const targetExists = fs.existsSync(targetEntryPath);
+
+    if (entry.isDirectory()) {
+      if (targetExists && !fs.statSync(targetEntryPath).isDirectory()) {
+        fs.rmSync(targetEntryPath, { recursive: true, force: true });
+        changed = true;
+      }
+      if (copyDirectory(sourceEntryPath, targetEntryPath)) {
+        changed = true;
+      }
+      continue;
+    }
+
+    if (targetExists && fs.statSync(targetEntryPath).isDirectory()) {
+      fs.rmSync(targetEntryPath, { recursive: true, force: true });
+      changed = true;
+    }
+
+    const sourceBuffer = fs.readFileSync(sourceEntryPath);
+    const targetBuffer = fs.existsSync(targetEntryPath)
+      ? fs.readFileSync(targetEntryPath)
+      : null;
+    if (targetBuffer && sourceBuffer.equals(targetBuffer)) {
+      continue;
+    }
+
+    fs.copyFileSync(sourceEntryPath, targetEntryPath);
+    changed = true;
+  }
+
+  return changed;
+}
 
 function quoteWindowsCommandPart(value) {
   const text = String(value);
@@ -43,6 +182,191 @@ function trimString(value) {
   return typeof value === 'string' ? value.trim() : '';
 }
 
+function readPersonaConfigLiteral(source, key) {
+  if (!source) {
+    return '';
+  }
+
+  const match = source.match(new RegExp(`${key}:\\s*"([^"]*)"`, 'u'));
+  return trimString(match?.[1] || '');
+}
+
+function resolvePersonaTemplateVariables(workspacePath) {
+  const personaConfigSource = fs.existsSync(path.join(workspacePath, 'src', 'persona', 'config.ts'))
+    ? fs.readFileSync(path.join(workspacePath, 'src', 'persona', 'config.ts'), 'utf8')
+    : '';
+  const personaJson = readJsonFile(path.join(workspacePath, 'persona.json')) || {};
+  const runtimeConfig = readPersonaRuntimeConfig(workspacePath);
+  const slug =
+    readPersonaConfigLiteral(personaConfigSource, 'slug') ||
+    trimString(personaJson.id) ||
+    path.basename(path.resolve(workspacePath));
+  const name =
+    readPersonaConfigLiteral(personaConfigSource, 'name') ||
+    trimString(personaJson.name) ||
+    slug;
+  const description =
+    readPersonaConfigLiteral(personaConfigSource, 'description') ||
+    trimString(personaJson.summary) ||
+    name;
+  const templateVersion =
+    readPersonaConfigLiteral(personaConfigSource, 'templateVersion') ||
+    trimString(personaJson.promptTemplateVersion) ||
+    trimString(runtimeConfig.templateVersion) ||
+    DEFAULT_TEMPLATE_VERSION;
+
+  return {
+    __OOMI_PERSONA_SLUG__: slug,
+    __OOMI_PERSONA_NAME__: name,
+    __OOMI_PERSONA_DESCRIPTION__: description,
+    __OOMI_TEMPLATE_VERSION__: templateVersion,
+  };
+}
+
+function renderPersonaTemplateFile({ workspacePath, relativePath }) {
+  const sourcePath = path.join(PERSONA_TEMPLATE_ROOT, relativePath);
+  const content = fs.readFileSync(sourcePath, 'utf8');
+  return renderTemplateFile(content, resolvePersonaTemplateVariables(workspacePath));
+}
+
+function readPersonaRuntimeConfig(workspacePath) {
+  if (!workspacePath) {
+    return {};
+  }
+
+  const runtimeConfigPath = path.join(workspacePath, 'oomi.runtime.json');
+  if (!fs.existsSync(runtimeConfigPath)) {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(runtimeConfigPath, 'utf8'));
+    return parsed && typeof parsed === 'object' ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function isWebSpatialRuntime(workspacePath) {
+  const runtimeConfig = readPersonaRuntimeConfig(workspacePath);
+  return trimString(runtimeConfig?.renderMode).toLowerCase() === 'webspatial';
+}
+
+export function syncVendoredWebSpatialPackages({
+  workspacePath,
+} = {}) {
+  if (!workspacePath || !isWebSpatialRuntime(workspacePath)) {
+    return false;
+  }
+
+  const packageJsonPath = path.join(workspacePath, 'package.json');
+  if (!fs.existsSync(packageJsonPath)) {
+    return false;
+  }
+
+  const vendorTargetRoot = path.join(workspacePath, 'vendor', 'webspatial');
+  let changed = false;
+  if (fs.existsSync(WEBSPATIAL_VENDOR_ROOT)) {
+    changed = copyDirectory(WEBSPATIAL_VENDOR_ROOT, vendorTargetRoot) || changed;
+  }
+
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const dependencies =
+    packageJson.dependencies && typeof packageJson.dependencies === 'object'
+      ? packageJson.dependencies
+      : {};
+  const devDependencies =
+    packageJson.devDependencies && typeof packageJson.devDependencies === 'object'
+      ? packageJson.devDependencies
+      : {};
+  const scripts =
+    packageJson.scripts && typeof packageJson.scripts === 'object'
+      ? packageJson.scripts
+      : {};
+  if (dependencies['@webspatial/core-sdk'] !== VENDORED_WEBSPATIAL_CORE_SPEC) {
+    dependencies['@webspatial/core-sdk'] = VENDORED_WEBSPATIAL_CORE_SPEC;
+    changed = true;
+  }
+
+  if (dependencies['@webspatial/react-sdk'] !== VENDORED_WEBSPATIAL_REACT_SPEC) {
+    dependencies['@webspatial/react-sdk'] = VENDORED_WEBSPATIAL_REACT_SPEC;
+    changed = true;
+  }
+
+  if (!dependencies['@zumer/snapdom']) {
+    dependencies['@zumer/snapdom'] = '^1.9.14';
+    changed = true;
+  }
+
+  if (!dependencies['html2canvas']) {
+    dependencies['html2canvas'] = '^1.4.1';
+    changed = true;
+  }
+
+  for (const dependencyName of WEBSPATIAL_TEMPLATE_DEV_DEPENDENCIES) {
+    const expectedVersion = trimString(
+      PERSONA_TEMPLATE_PACKAGE_JSON?.devDependencies?.[dependencyName],
+    );
+    if (!expectedVersion) {
+      continue;
+    }
+    if (devDependencies[dependencyName] !== expectedVersion) {
+      devDependencies[dependencyName] = expectedVersion;
+      changed = true;
+    }
+  }
+
+  for (const scriptName of ['dev:avp', 'build']) {
+    const expectedScript = trimString(PERSONA_TEMPLATE_PACKAGE_JSON?.scripts?.[scriptName]);
+    if (!expectedScript || trimString(scripts[scriptName])) {
+      continue;
+    }
+    scripts[scriptName] = expectedScript;
+    changed = true;
+  }
+
+  if (changed) {
+    packageJson.dependencies = dependencies;
+    packageJson.devDependencies = devDependencies;
+    packageJson.scripts = scripts;
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, 'utf8');
+  }
+
+  return changed;
+}
+
+export function syncLegacyWebSpatialScaffoldFiles({
+  workspacePath,
+} = {}) {
+  if (!workspacePath || !isWebSpatialRuntime(workspacePath)) {
+    return false;
+  }
+
+  let changed = false;
+  for (const rule of LEGACY_WEBSPATIAL_TEMPLATE_FILE_RULES) {
+    const targetPath = path.join(workspacePath, rule.relativePath);
+    const targetExists = fs.existsSync(targetPath);
+    const currentContent = targetExists ? fs.readFileSync(targetPath, 'utf8') : '';
+    if (targetExists && !rule.shouldReplace(currentContent)) {
+      continue;
+    }
+
+    const renderedContent = renderPersonaTemplateFile({
+      workspacePath,
+      relativePath: rule.relativePath,
+    });
+    if (currentContent === renderedContent) {
+      continue;
+    }
+
+    ensureDir(path.dirname(targetPath));
+    fs.writeFileSync(targetPath, renderedContent, 'utf8');
+    changed = true;
+  }
+
+  return changed;
+}
+
 function readProcessCommandLine(pid) {
   const safePid = normalizePositiveInteger(pid);
   if (!safePid) {
@@ -176,25 +500,28 @@ function runProcess({ command, args, cwd }) {
   });
 }
 
-export async function installPersonaWorkspace({
-  workspacePath,
-}) {
-  if (!workspacePath) {
-    throw new Error('Workspace path is required.');
-  }
-
-  await runProcess({
-    command: resolveNpmCommand(),
-    args: ['install', '--silent', '--no-fund', '--no-audit'],
+export async function installPersonaWorkspace({
+  workspacePath,
+}) {
+  if (!workspacePath) {
+    throw new Error('Workspace path is required.');
+  }
+
+  syncVendoredWebSpatialPackages({ workspacePath });
+  syncLegacyWebSpatialScaffoldFiles({ workspacePath });
+
+  await runProcess({
+    command: resolveNpmCommand(),
+    args: ['install', '--silent', '--no-fund', '--no-audit'],
     cwd: workspacePath,
   });
 }
 
-export function resolvePersonaDevCommand({
-  workspacePath,
-  localPort,
-}) {
-  const directCommand = resolveDirectViteCommand({ workspacePath, localPort });
+export function resolvePersonaDevCommand({
+  workspacePath,
+  localPort,
+}) {
+  const directCommand = resolveDirectViteCommand({ workspacePath, localPort });
   if (directCommand) {
     return directCommand;
   }
@@ -206,15 +533,29 @@ export function resolvePersonaDevCommand({
   }
   return {
     command: resolveNpmCommand(),
-    args,
-  };
-}
-
-export function startPersonaWorkspace({
-  workspacePath,
-  logFilePath,
-  env = {},
-  localPort,
+    args,
+  };
+}
+
+export function resolvePersonaDevEnvironment({
+  workspacePath,
+} = {}) {
+  const runtimeConfig = readPersonaRuntimeConfig(workspacePath);
+  const renderMode = trimString(runtimeConfig?.renderMode).toLowerCase();
+  if (renderMode === 'webspatial') {
+    return {
+      XR_ENV: 'avp',
+    };
+  }
+
+  return {};
+}
+
+export function startPersonaWorkspace({
+  workspacePath,
+  logFilePath,
+  env = {},
+  localPort,
 }) {
   if (!workspacePath) {
     throw new Error('Workspace path is required.');
@@ -238,15 +579,16 @@ export function startPersonaWorkspace({
     )} >> "${resolvedLogFilePath.replace(/"/g, '""')}" 2>&1`;
     const child = spawn(process.env.ComSpec || 'cmd.exe', ['/d', '/s', '/c', shellCommand], {
       cwd: workspacePath,
-      detached: true,
-      stdio: 'ignore',
-      shell: false,
-      windowsHide: true,
-      env: {
-        ...process.env,
-        ...env,
-      },
-    });
+      detached: true,
+      stdio: 'ignore',
+      shell: false,
+      windowsHide: true,
+      env: {
+        ...process.env,
+        ...resolvePersonaDevEnvironment({ workspacePath }),
+        ...env,
+      },
+    });
 
     child.unref();
 
@@ -265,15 +607,16 @@ export function startPersonaWorkspace({
   try {
     child = spawn(devCommand.command, devCommand.args, {
       cwd: workspacePath,
-      detached: true,
-      stdio: ['ignore', output, output],
-      shell: false,
-      windowsHide: true,
-      env: {
-        ...process.env,
-        ...env,
-      },
-    });
+      detached: true,
+      stdio: ['ignore', output, output],
+      shell: false,
+      windowsHide: true,
+      env: {
+        ...process.env,
+        ...resolvePersonaDevEnvironment({ workspacePath }),
+        ...env,
+      },
+    });
   } finally {
     fs.closeSync(output);
   }

package/lib/personaRuntimeSupervisor.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 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';
@@ -17,15 +18,27 @@ function wait(ms) {
 }
 
 function listWorkspacePaths(workspaceRoot) {
-  const safeRoot = trimString(workspaceRoot);
-  if (!safeRoot || !fs.existsSync(safeRoot)) {
-    return [];
+  const roots = [trimString(workspaceRoot), trimString(resolveOpenclawLegacyPersonasDir())]
+    .filter(Boolean)
+    .filter((root, index, values) => values.findIndex((candidate) => path.resolve(candidate) === path.resolve(root)) === index)
+    .filter((root) => fs.existsSync(root));
+
+  const workspacePaths = new Set();
+  for (const root of roots) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      const candidatePath = path.join(root, entry.name);
+      let dedupeKey = candidatePath;
+      try {
+        dedupeKey = fs.realpathSync(candidatePath);
+      } catch {
+        // fall back to the visible path when the real path is unavailable
+      }
+      workspacePaths.add(dedupeKey);
+    }
   }
 
-  return fs
-    .readdirSync(safeRoot, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => path.join(safeRoot, entry.name));
+  return Array.from(workspacePaths);
 }
 
 async function healthcheckOk(url) {

package/lib/scaffold.js

@@ -82,9 +82,9 @@ export function scaffoldPersonaApp({
   }
 
   const resolvedOutDir = path.resolve(outDir);
-  const templateRoot = resolveTemplateRoot(templateId, templateVersion);
-  const descriptor = readTemplateDescriptor(templateRoot);
-  const variables = {
+  const templateRoot = resolveTemplateRoot(templateId, templateVersion);
+  const descriptor = readTemplateDescriptor(templateRoot);
+  const variables = {
     __OOMI_PERSONA_SLUG__: safeSlug,
     __OOMI_PERSONA_NAME__: safeName,
     __OOMI_PERSONA_DESCRIPTION__: safeDescription,
@@ -95,14 +95,14 @@ export function scaffoldPersonaApp({
   copyTemplateTree(templateRoot, resolvedOutDir, variables);
 
   return {
-    ok: true,
-    templateId,
-    templateVersion,
-    slug: safeSlug,
-    outDir: resolvedOutDir,
-    startCommand: `cd ${resolvedOutDir} && npm install && npm run dev`,
-    healthPath: descriptor.healthPath,
-    editableZones: descriptor.editableZones,
-    defaultPort: descriptor.defaultPort,
-  };
-}
+    ok: true,
+    templateId,
+    templateVersion,
+    slug: safeSlug,
+    outDir: resolvedOutDir,
+    startCommand: `cd ${resolvedOutDir} && npm install && ${descriptor.startCommand || 'npm run dev'}`,
+    healthPath: descriptor.healthPath,
+    editableZones: descriptor.editableZones,
+    defaultPort: descriptor.defaultPort,
+  };
+}

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.38",
+  "version": "0.2.40",
   "author": "Oomi",
   "license": "MIT",
   "openclawVersion": ">=0.5.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.2.38",
+  "version": "0.2.40",
   "description": "Oomi OpenClaw channel plugin and bridge tooling",
   "bin": {
     "oomi": "bin/oomi-ai.js"
@@ -58,10 +58,12 @@
     "bin/sessionBridgeState.js",
     "lib",
     "openclaw.plugin.json",
-    "openclaw.extension.js",
-    "agent_instructions.md",
-    "README.md",
-    "skills/oomi",
-    "templates/persona-app"
-  ]
-}
+    "openclaw.extension.js",
+    "agent_instructions.md",
+    "README.md",
+    "skills/oomi",
+    "templates/persona-app",
+    "templates/persona-app/vendor/webspatial/core-sdk/dist",
+    "templates/persona-app/vendor/webspatial/react-sdk/dist"
+  ]
+}

package/templates/persona-app/package.json

@@ -12,8 +12,10 @@
     "lint": "eslint ."
   },
   "dependencies": {
-    "@webspatial/core-sdk": "^0.1.16",
-    "@webspatial/react-sdk": "^0.1.16",
+    "@webspatial/core-sdk": "file:./vendor/webspatial/core-sdk",
+    "@webspatial/react-sdk": "file:./vendor/webspatial/react-sdk",
+    "@zumer/snapdom": "^1.9.14",
+    "html2canvas": "^1.4.1",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
     "react-router-dom": "^7.4.0",
@@ -24,8 +26,8 @@
     "@types/react": "^19.0.10",
     "@types/react-dom": "^19.0.4",
     "@vitejs/plugin-react": "^4.3.4",
-    "@webspatial/builder": "^0.1.16",
-    "@webspatial/platform-visionos": "^0.1.16",
+    "@webspatial/builder": "^1.2.1",
+    "@webspatial/platform-visionos": "^1.2.1",
     "@webspatial/vite-plugin": "^0.1.7",
     "cross-env": "^7.0.3",
     "dotenv-cli": "^8.0.0",