oomi-ai 0.2.49 → 0.3.0

package/lib/personaRuntimeRegistry.js

@@ -1,67 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-
-function readJsonSafe(filePath) {
-  if (!fs.existsSync(filePath)) {
-    return null;
-  }
-
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function trimString(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-export function resolvePersonaWorkspacePath({ workspaceRoot, slug }) {
-  const safeRoot = trimString(workspaceRoot);
-  const safeSlug = trimString(slug);
-  if (!safeRoot) {
-    throw new Error('Workspace root is required.');
-  }
-  if (!safeSlug) {
-    throw new Error('Persona slug is required.');
-  }
-
-  return path.resolve(safeRoot, safeSlug);
-}
-
-export function resolvePersonaRuntimeDir(workspacePath) {
-  return path.join(workspacePath, '.oomi');
-}
-
-export function resolvePersonaRuntimeStatePath(workspacePath) {
-  return path.join(resolvePersonaRuntimeDir(workspacePath), 'runtime.json');
-}
-
-export function resolvePersonaRuntimeLogPath(workspacePath) {
-  return path.join(resolvePersonaRuntimeDir(workspacePath), 'runtime.log');
-}
-
-export function readPersonaRuntimeState(workspacePath) {
-  return readJsonSafe(resolvePersonaRuntimeStatePath(workspacePath)) || {};
-}
-
-export function writePersonaRuntimeState(workspacePath, state) {
-  const runtimeDir = resolvePersonaRuntimeDir(workspacePath);
-  const statePath = resolvePersonaRuntimeStatePath(workspacePath);
-  ensureDir(runtimeDir);
-  fs.writeFileSync(statePath, JSON.stringify(state, null, 2) + '\n', 'utf8');
-  return state;
-}
-
-export function updatePersonaRuntimeState(workspacePath, partial) {
-  const current = readPersonaRuntimeState(workspacePath);
-  return writePersonaRuntimeState(workspacePath, {
-    ...current,
-    ...partial,
-  });
-}

package/lib/personaRuntimeSupervisor.js

@@ -1,330 +0,0 @@
-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, updatePersonaRuntimeState } from './personaRuntimeRegistry.js';
-import {
-  buildLocalPersonaRuntime,
-  isPersonaWorkspaceProcessRunning,
-  resolvePersonaDevCommand,
-  resolvePersonaHealthPath,
-} from './personaRuntimeProcess.js';
-
-function trimString(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-function wait(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-function listWorkspacePaths(workspaceRoot) {
-  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 Array.from(workspacePaths);
-}
-
-async function healthcheckOk(url) {
-  const safeUrl = trimString(url);
-  if (!safeUrl) {
-    return false;
-  }
-
-  try {
-    const response = await fetch(safeUrl, {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json',
-      },
-    });
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-async function reconcileWorkspace({
-  workspacePath,
-  workspaceRoot,
-  client,
-  logger,
-  autoRestart,
-}) {
-  const state = readPersonaRuntimeState(workspacePath);
-  const slug = trimString(state.slug);
-  if (!slug || trimString(state.status) !== 'running') {
-    return;
-  }
-
-  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: resolvePersonaHealthPath({
-          workspacePath,
-          fallback: '/oomi.health.json',
-        }),
-      })
-    : null;
-
-  const expectedDevCommand = runtime.localPort
-    ? resolvePersonaDevCommand({
-        workspacePath,
-        localPort: runtime.localPort,
-      })
-    : state.devCommand;
-  const processRunning = isPersonaWorkspaceProcessRunning(state.pid, {
-    workspacePath,
-    expectedCommand: expectedDevCommand,
-    localPort: runtime.localPort,
-  });
-
-  let effectiveRuntime = runtime;
-  if (!processRunning) {
-    if (!autoRestart) {
-      return;
-    }
-
-    try {
-      const launchResult = await launchManagedPersonaRuntime({
-        slug,
-        name: trimString(state.name) || slug,
-        description: trimString(state.description) || trimString(state.name) || slug,
-        workspaceRoot,
-        templateVersion: trimString(state.templateVersion) || 'v1',
-        forceInstall: false,
-        restart: false,
-        logFilePath: trimString(state.logFilePath),
-        entryUrl: '',
-        transport: 'local',
-      });
-
-      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,
-      };
-
-      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] restart failed for ${slug}: ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-      return;
-    }
-  }
-
-  const healthy = await healthcheckOk(effectiveRuntime.healthcheckUrl);
-  if (!healthy) {
-    if (!autoRestart) {
-      return;
-    }
-
-    try {
-      const recovered = await launchManagedPersonaRuntime({
-        slug,
-        name: trimString(state.name) || slug,
-        description: trimString(state.description) || trimString(state.name) || slug,
-        workspaceRoot,
-        templateVersion: trimString(state.templateVersion) || 'v1',
-        forceInstall: false,
-        restart: true,
-        logFilePath: trimString(state.logFilePath),
-        entryUrl: '',
-        transport: 'local',
-      });
-
-      effectiveRuntime = {
-        slug,
-        endpoint: recovered.runtime.endpoint,
-        localEndpoint: recovered.runtime.localEndpoint || recovered.localRuntime.endpoint,
-        reachableEndpoint: recovered.runtime.reachableEndpoint || recovered.localRuntime.reachableEndpoint,
-        healthcheckUrl: recovered.runtime.healthcheckUrl,
-        transport: recovered.runtime.transport,
-        localPort: recovered.runtime.localPort,
-      };
-
-      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] unhealthy runtime restart failed for ${slug}: ${
-          error instanceof Error ? error.message : String(error)
-        }`
-      );
-      return;
-    }
-  }
-
-  if (!healthy) {
-    const recoveredHealthy = await healthcheckOk(effectiveRuntime.healthcheckUrl);
-    if (!recoveredHealthy) {
-      return;
-    }
-  }
-
-  if (localRuntime) {
-    const refreshedLocalRuntime = buildLocalPersonaRuntime({
-      localPort: effectiveRuntime.localPort,
-      healthPath: resolvePersonaHealthPath({
-        workspacePath,
-        fallback: '/oomi.health.json',
-      }),
-    });
-    const desiredEndpoint = refreshedLocalRuntime.reachableEndpoint || runtime.endpoint;
-    const endpointChanged = desiredEndpoint && desiredEndpoint !== effectiveRuntime.endpoint;
-    const localEndpointChanged = refreshedLocalRuntime.endpoint !== effectiveRuntime.localEndpoint;
-    const reachableEndpointChanged = refreshedLocalRuntime.reachableEndpoint !== effectiveRuntime.reachableEndpoint;
-
-    if (endpointChanged || localEndpointChanged || reachableEndpointChanged) {
-      effectiveRuntime = {
-        ...effectiveRuntime,
-        endpoint: desiredEndpoint,
-        localEndpoint: refreshedLocalRuntime.endpoint,
-        reachableEndpoint: refreshedLocalRuntime.reachableEndpoint,
-      };
-      updatePersonaRuntimeState(workspacePath, {
-        endpoint: desiredEndpoint,
-        entryUrl: desiredEndpoint,
-        localEndpoint: refreshedLocalRuntime.endpoint,
-        reachableEndpoint: refreshedLocalRuntime.reachableEndpoint,
-        bindHost: refreshedLocalRuntime.bindHost,
-        reachableHost: refreshedLocalRuntime.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,
-      endpoint: effectiveRuntime.endpoint,
-      healthcheckUrl: effectiveRuntime.healthcheckUrl,
-      localPort: effectiveRuntime.localPort,
-      transport: effectiveRuntime.transport,
-      observedAt: new Date().toISOString(),
-    });
-  } catch (error) {
-    logger.warn?.(
-      `[persona-runtime] heartbeat failed for ${slug}: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-}
-
-export function startPersonaRuntimeSupervisor({
-  backendUrl,
-  deviceToken,
-  workspaceRoot,
-  fetchImpl = globalThis.fetch,
-  intervalMs = 30000,
-  logger = console,
-  autoRestart = true,
-}) {
-  const client = createPersonaApiClient({
-    backendUrl,
-    deviceToken,
-    fetchImpl,
-  });
-
-  let stopped = false;
-  let loopPromise = null;
-
-  async function runLoop() {
-    while (!stopped) {
-      const workspaces = listWorkspacePaths(workspaceRoot);
-      for (const workspacePath of workspaces) {
-        if (stopped) break;
-        await reconcileWorkspace({
-          workspacePath,
-          workspaceRoot,
-          client,
-          logger,
-          autoRestart,
-        });
-      }
-
-      if (stopped) {
-        break;
-      }
-      await wait(intervalMs);
-    }
-  }
-
-  loopPromise = runLoop();
-
-  return {
-    stop() {
-      stopped = true;
-    },
-    completed: loopPromise,
-  };
-}

package/lib/scaffold.js

@@ -1,108 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import {
-  DEFAULT_TEMPLATE_ID,
-  DEFAULT_TEMPLATE_VERSION,
-  readTemplateDescriptor,
-  renderTemplateFile,
-  resolveTemplateRoot,
-} from './template.js';
-
-function ensureDir(dirPath) {
-  fs.mkdirSync(dirPath, { recursive: true });
-}
-
-function validatePersonaSlug(slug) {
-  if (typeof slug !== 'string' || !slug.trim()) {
-    throw new Error('Persona slug is required.');
-  }
-
-  const normalized = slug.trim();
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(normalized)) {
-    throw new Error(
-      'Persona slug must use lowercase letters, numbers, and single dashes only.',
-    );
-  }
-
-  return normalized;
-}
-
-function ensureWritableOutputDir(outDir, force) {
-  if (!outDir) {
-    throw new Error('Output directory is required. Use --out <path>.');
-  }
-
-  if (!fs.existsSync(outDir)) {
-    ensureDir(outDir);
-    return;
-  }
-
-  const entries = fs.readdirSync(outDir);
-  if (entries.length > 0 && !force) {
-    throw new Error(`Output directory is not empty: ${outDir}. Use --force to overwrite.`);
-  }
-}
-
-function copyTemplateTree(sourceRoot, targetRoot, variables) {
-  const entries = fs.readdirSync(sourceRoot, { withFileTypes: true });
-  for (const entry of entries) {
-    if (entry.name === 'template.json') {
-      continue;
-    }
-
-    const sourcePath = path.join(sourceRoot, entry.name);
-    const targetPath = path.join(targetRoot, entry.name);
-
-    if (entry.isDirectory()) {
-      ensureDir(targetPath);
-      copyTemplateTree(sourcePath, targetPath, variables);
-      continue;
-    }
-
-    const content = fs.readFileSync(sourcePath, 'utf8');
-    fs.writeFileSync(targetPath, renderTemplateFile(content, variables), 'utf8');
-  }
-}
-
-export function scaffoldPersonaApp({
-  slug,
-  name,
-  description,
-  outDir,
-  templateVersion = DEFAULT_TEMPLATE_VERSION,
-  templateId = DEFAULT_TEMPLATE_ID,
-  force = false,
-}) {
-  const safeSlug = validatePersonaSlug(slug);
-  const safeName = typeof name === 'string' && name.trim() ? name.trim() : safeSlug;
-  const safeDescription = typeof description === 'string' ? description.trim() : '';
-  if (!safeDescription) {
-    throw new Error('Persona description is required. Use --description "<text>".');
-  }
-
-  const resolvedOutDir = path.resolve(outDir);
-  const templateRoot = resolveTemplateRoot(templateId, templateVersion);
-  const descriptor = readTemplateDescriptor(templateRoot);
-  const variables = {
-    __OOMI_PERSONA_SLUG__: safeSlug,
-    __OOMI_PERSONA_NAME__: safeName,
-    __OOMI_PERSONA_DESCRIPTION__: safeDescription,
-    __OOMI_TEMPLATE_VERSION__: templateVersion,
-  };
-
-  ensureWritableOutputDir(resolvedOutDir, force);
-  copyTemplateTree(templateRoot, resolvedOutDir, variables);
-
-  return {
-    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/lib/template.js

@@ -1,45 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export const DEFAULT_TEMPLATE_ID = 'persona-app';
-export const DEFAULT_TEMPLATE_VERSION = 'v1';
-
-const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const TEMPLATE_ROOT = path.join(PACKAGE_ROOT, 'templates');
-
-export function readTemplateDescriptor(templateRoot) {
-  const descriptorPath = path.join(templateRoot, 'template.json');
-  if (!fs.existsSync(descriptorPath)) {
-    throw new Error(`Template descriptor not found: ${descriptorPath}`);
-  }
-
-  return JSON.parse(fs.readFileSync(descriptorPath, 'utf8'));
-}
-
-export function resolveTemplateRoot(
-  templateId = DEFAULT_TEMPLATE_ID,
-  version = DEFAULT_TEMPLATE_VERSION,
-) {
-  const templateRoot = path.join(TEMPLATE_ROOT, templateId);
-  if (!fs.existsSync(templateRoot)) {
-    throw new Error(`Unknown template: ${templateId}`);
-  }
-
-  const descriptor = readTemplateDescriptor(templateRoot);
-  if (descriptor.version !== version) {
-    throw new Error(
-      `Unsupported template version "${version}" for ${templateId}. Available version: ${descriptor.version}`,
-    );
-  }
-
-  return templateRoot;
-}
-
-export function renderTemplateFile(content, variables) {
-  let rendered = content;
-  for (const [token, value] of Object.entries(variables)) {
-    rendered = rendered.split(token).join(String(value));
-  }
-  return rendered;
-}

package/skills/oomi/config.json

@@ -1,3 +0,0 @@
-{
-    "api_url": "http://localhost:3000/api/skill"
-}

package/skills/oomi/scripts/get_avatar_capabilities.py

@@ -1,40 +0,0 @@
-import urllib.request
-import urllib.error
-import json
-import os
-import sys
-
-# Load config
-try:
-    config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'config.json')
-    with open(config_path, 'r') as f:
-        config = json.load(f)
-        BASE_URL = config.get('api_url', 'http://localhost:3000/api/skill')
-except:
-    BASE_URL = 'http://localhost:3000/api/skill'
-
-API_URL = f"{BASE_URL}/avatar-capabilities"
-
-def get_avatar_capabilities():
-    try:
-        with urllib.request.urlopen(API_URL) as response:
-            data = json.loads(response.read().decode())
-
-        print(json.dumps({
-            "summary": "Avatar capabilities retrieved.",
-            "raw_data": data
-        }, indent=2))
-    except urllib.error.URLError as e:
-        print(json.dumps({
-            "error": f"Failed to connect to Oomi app: {str(e)}",
-            "hint": "Is the Next.js app running on localhost:3000?"
-        }))
-        sys.exit(1)
-    except Exception as e:
-        print(json.dumps({
-            "error": f"An error occurred: {str(e)}"
-        }))
-        sys.exit(1)
-
-if __name__ == "__main__":
-    get_avatar_capabilities()

package/skills/oomi/scripts/get_data.py

@@ -1,49 +0,0 @@
-import urllib.request
-import urllib.error
-import json
-import os
-import sys
-
-# Load config
-try:
-    config_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), 'config.json')
-    with open(config_path, 'r') as f:
-        config = json.load(f)
-        BASE_URL = config.get('api_url', 'http://localhost:3000/api/skill')
-except:
-    BASE_URL = 'http://localhost:3000/api/skill'
-
-API_URL = f"{BASE_URL}/data"
-
-def get_data():
-    try:
-        with urllib.request.urlopen(API_URL) as response:
-            data = json.loads(response.read().decode())
-        
-        # Format output for the agent
-        summary = (
-            f"Steps: {data['steps']} / {data['goals']['steps']}\n"
-            f"Sleep: {data['sleep']}h / {data['goals']['sleep']}h\n"
-            f"Energy: {data['energy']}/100\n"
-            f"Mood: {data['mood']}"
-        )
-        
-        print(json.dumps({
-            "summary": summary,
-            "raw_data": data
-        }, indent=2))
-        
-    except urllib.error.URLError as e:
-        print(json.dumps({
-            "error": f"Failed to connect to Oomi app: {str(e)}",
-            "hint": "Is the Next.js app running on localhost:3000?"
-        }))
-        sys.exit(1)
-    except Exception as e:
-        print(json.dumps({
-            "error": f"An error occurred: {str(e)}"
-        }))
-        sys.exit(1)
-
-if __name__ == "__main__":
-    get_data()