oomi-ai 0.2.28 → 0.2.38

package/lib/personaRuntimeSupervisor.js

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { createPersonaApiClient } from './personaApiClient.js';
+import { launchManagedPersonaRuntime } from './personaRuntimeManager.js';
+import { readPersonaRuntimeState } from './personaRuntimeRegistry.js';
+import { isPersonaWorkspaceProcessRunning } 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 safeRoot = trimString(workspaceRoot);
+  if (!safeRoot || !fs.existsSync(safeRoot)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(safeRoot, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => path.join(safeRoot, entry.name));
+}
+
+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),
+    healthcheckUrl: trimString(state.healthcheckUrl),
+    transport: trimString(state.transport) || 'local',
+    localPort: Number.isFinite(Number(state.localPort)) ? Number(state.localPort) : null,
+  };
+
+  const processRunning = isPersonaWorkspaceProcessRunning(state.pid, {
+    workspacePath,
+    expectedCommand: state.devCommand,
+    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,
+        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) {
+    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/openclaw.plugin.json

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

package/package.json

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