oomi-ai 0.2.45 → 0.2.48

package/bin/oomi-ai.js

@@ -924,8 +924,98 @@ function collectManagedPersonaRefreshTargets({
 
   return targets.sort((a, b) => a.slug.localeCompare(b.slug));
 }
-
-async function findExistingManagedPersona(client, slug) {
+
+function normalizeBackendPersonaRefreshRecord(rawPersona) {
+  if (!rawPersona || typeof rawPersona !== 'object') {
+    return null;
+  }
+
+  const slug = String(
+    rawPersona.slug ||
+      rawPersona.id ||
+      rawPersona.personaId ||
+      ''
+  ).trim();
+  if (!slug) {
+    return null;
+  }
+
+  return {
+    slug,
+    name: String(rawPersona.name || slug).trim() || slug,
+    description: String(rawPersona.description || rawPersona.summary || rawPersona.name || slug).trim() || slug,
+    templateVersion: String(rawPersona.promptTemplateVersion || 'v1').trim() || 'v1',
+    templateType: String(rawPersona.templateType || '').trim(),
+  };
+}
+
+function resolveExistingWorkspacePathForSlug(slug, workspaceRoot = defaultPersonaWorkspaceRoot()) {
+  for (const root of listPersonaWorkspaceRoots(workspaceRoot)) {
+    const workspacePath = resolvePersonaWorkspacePath({
+      workspaceRoot: root,
+      slug,
+    });
+    if (fs.existsSync(workspacePath)) {
+      return workspacePath;
+    }
+  }
+  return '';
+}
+
+async function discoverBackendLinkedPersonaRefreshTargets({
+  client,
+  workspaceRoot = defaultPersonaWorkspaceRoot(),
+  existingTargets = [],
+  logger = null,
+} = {}) {
+  if (!client || typeof client.listPersonas !== 'function') {
+    return [];
+  }
+
+  const targetsBySlug = new Map(
+    Array.isArray(existingTargets)
+      ? existingTargets.map((target) => [String(target?.slug || '').trim(), target]).filter(([slug]) => slug)
+      : [],
+  );
+
+  const payload = await client.listPersonas();
+  const backendPersonas = Array.isArray(payload?.personas) ? payload.personas : [];
+  const discoveredTargets = [];
+
+  for (const rawPersona of backendPersonas) {
+    const backendPersona = normalizeBackendPersonaRefreshRecord(rawPersona);
+    if (!backendPersona || targetsBySlug.has(backendPersona.slug)) {
+      continue;
+    }
+    const workspacePath = resolveExistingWorkspacePathForSlug(backendPersona.slug, workspaceRoot);
+    if (!workspacePath) {
+      continue;
+    }
+    const state = readPersonaRuntimeState(workspacePath);
+    const target = {
+      slug: backendPersona.slug,
+      workspacePath,
+      state: {
+        ...state,
+        slug: backendPersona.slug,
+        name: backendPersona.name,
+        description: backendPersona.description,
+        templateVersion: backendPersona.templateVersion,
+      },
+      processRunning: false,
+    };
+    discoveredTargets.push(target);
+    targetsBySlug.set(backendPersona.slug, target);
+  }
+
+  if (discoveredTargets.length > 0) {
+    logger?.(`Added ${discoveredTargets.length} backend-linked persona runtime target${discoveredTargets.length === 1 ? '' : 's'} from workspace discovery.`);
+  }
+
+  return discoveredTargets;
+}
+
+async function findExistingManagedPersona(client, slug) {
   try {
     return await client.getPersona({ slug });
   } catch (error) {
@@ -1314,6 +1404,7 @@ function printStructuredResult(result, asJson = false) {
 
 async function handlePersonaRuntimeRegisterCommand(slug, flags = {}) {
   const client = createCliPersonaApiClient(flags);
+  const jsonOutput = isTruthyFlag(flags.json);
   const runtime = resolvePersonaRuntimeInput(
     flags,
     {},
@@ -1322,19 +1413,27 @@ async function handlePersonaRuntimeRegisterCommand(slug, flags = {}) {
       workspaceRoot: resolvePersonaWorkspaceRoot(flags),
     },
   );
+  if (!jsonOutput) {
+    console.log(`[personas] Registering runtime for ${slug}.`);
+    console.log(`[personas] Backend: ${resolvePersonaBackendUrl(flags)}`);
+    console.log(`[personas] Device: ${resolvePersonaDeviceId(flags)}`);
+    console.log(`[personas] Endpoint: ${runtime.endpoint}`);
+    console.log(`[personas] Healthcheck: ${runtime.healthcheckUrl}`);
+  }
   const payload = await client.registerRuntime({
     slug,
     endpoint: runtime.endpoint,
-    healthcheckUrl: runtime.healthcheckUrl,
-    localPort: runtime.localPort,
-    transport: runtime.transport,
-    startedAt: parseIsoTimestamp(flags['started-at'], 'started-at'),
-  });
-  printStructuredResult(payload, isTruthyFlag(flags.json));
-}
-
+    healthcheckUrl: runtime.healthcheckUrl,
+    localPort: runtime.localPort,
+    transport: runtime.transport,
+    startedAt: parseIsoTimestamp(flags['started-at'], 'started-at'),
+  });
+  printStructuredResult(payload, jsonOutput);
+}
+
 async function handlePersonaHeartbeatCommand(slug, flags = {}) {
   const client = createCliPersonaApiClient(flags);
+  const jsonOutput = isTruthyFlag(flags.json);
   const runtime = resolvePersonaRuntimeInput(
     flags,
     {},
@@ -1343,16 +1442,23 @@ async function handlePersonaHeartbeatCommand(slug, flags = {}) {
       workspaceRoot: resolvePersonaWorkspaceRoot(flags),
     },
   );
+  if (!jsonOutput) {
+    console.log(`[personas] Sending heartbeat for ${slug}.`);
+    console.log(`[personas] Backend: ${resolvePersonaBackendUrl(flags)}`);
+    console.log(`[personas] Device: ${resolvePersonaDeviceId(flags)}`);
+    console.log(`[personas] Endpoint: ${runtime.endpoint}`);
+    console.log(`[personas] Healthcheck: ${runtime.healthcheckUrl}`);
+  }
   const payload = await client.heartbeatRuntime({
     slug,
     endpoint: runtime.endpoint,
-    healthcheckUrl: runtime.healthcheckUrl,
-    localPort: runtime.localPort,
-    transport: runtime.transport,
-    observedAt: parseIsoTimestamp(flags['observed-at'], 'observed-at'),
-  });
-  printStructuredResult(payload, isTruthyFlag(flags.json));
-}
+    healthcheckUrl: runtime.healthcheckUrl,
+    localPort: runtime.localPort,
+    transport: runtime.transport,
+    observedAt: parseIsoTimestamp(flags['observed-at'], 'observed-at'),
+  });
+  printStructuredResult(payload, jsonOutput);
+}
 
 async function handlePersonaRuntimeFailCommand(slug, flags = {}) {
   const code = String(flags.code || '').trim();
@@ -1566,13 +1672,16 @@ async function handlePersonaDeleteCommand(slug, flags = {}) {
   printStructuredResult(result, isTruthyFlag(flags.json));
 }
 
-async function restartManagedPersonaRefreshTargets(flags = {}) {
+async function restartManagedPersonaRefreshTargets(flags = {}, options = {}) {
   const workspaceRoot = resolvePersonaWorkspaceRoot(flags);
-  const targets = collectManagedPersonaRefreshTargets({
+  const localTargets = collectManagedPersonaRefreshTargets({
     workspaceRoot,
     includeStopped: isTruthyFlag(flags['include-stopped']),
   });
+  const targetsBySlug = new Map(localTargets.map((target) => [target.slug, target]));
+  const targets = [...localTargets];
   const results = [];
+  const logger = options.logger || null;
 
   let client = null;
   let registrationError = '';
@@ -1580,10 +1689,35 @@ async function restartManagedPersonaRefreshTargets(flags = {}) {
     client = createCliPersonaApiClient(flags);
   } catch (error) {
     registrationError = error instanceof Error ? error.message : String(error);
+    logger?.(`Persona backend registration unavailable: ${registrationError}`);
+  }
+
+  if (client) {
+    try {
+      const backendTargets = await discoverBackendLinkedPersonaRefreshTargets({
+        client,
+        workspaceRoot,
+        existingTargets: targets,
+        logger,
+      });
+      for (const target of backendTargets) {
+        targetsBySlug.set(target.slug, target);
+        targets.push(target);
+      }
+    } catch (error) {
+      logger?.(`Backend persona discovery failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
   }
 
+  logger?.(
+    `Discovered ${targets.length} managed persona runtime${targets.length == 1 ? '' : 's'} to refresh.`,
+  );
+
   for (const target of targets) {
     const state = target.state && typeof target.state === 'object' ? target.state : {};
+    logger?.(
+      `Refreshing persona ${target.slug} (previous port: ${String(state.localPort || 'unknown')}).`,
+    );
     const launchResult = await launchManagedPersonaRuntime({
       slug: target.slug,
       name: String(state.name || target.slug).trim() || target.slug,
@@ -1600,6 +1734,7 @@ async function restartManagedPersonaRefreshTargets(flags = {}) {
     let registration = null;
     if (client) {
       try {
+        logger?.(`Re-registering runtime for ${launchResult.slug} at ${launchResult.runtime.endpoint}.`);
         registration = await client.registerRuntime({
           slug: launchResult.slug,
           endpoint: launchResult.runtime.endpoint,
@@ -1613,9 +1748,14 @@ async function restartManagedPersonaRefreshTargets(flags = {}) {
           ok: false,
           error: error instanceof Error ? error.message : String(error),
         };
+        logger?.(`Runtime registration failed for ${launchResult.slug}: ${registration.error}`);
       }
     }
 
+    logger?.(
+      `Persona ${launchResult.slug} refreshed on port ${launchResult.runtime.localPort} (${launchResult.runtime.endpoint}).`,
+    );
+
     results.push({
       slug: launchResult.slug,
       workspacePath: launchResult.workspacePath,
@@ -1634,10 +1774,12 @@ async function restartManagedPersonaRefreshTargets(flags = {}) {
   };
 }
 
-async function refreshBridgeForUpdate(flags = {}) {
+async function refreshBridgeForUpdate(flags = {}, options = {}) {
+  const logger = options.logger || null;
   if (process.platform === 'darwin') {
     const launchdStatus = readBridgeLaunchdStatus();
     if (launchdStatus.installed) {
+      logger?.(`Restarting launchd-managed bridge ${launchdStatus.target}.`);
       await stopBridgeLaunchdService();
       startBridgeLaunchdService();
       incrementBridgeMetric('bridge_restart_count');
@@ -1651,12 +1793,14 @@ async function refreshBridgeForUpdate(flags = {}) {
 
   const running = findRunningBridgeProcess();
   if (!running) {
+    logger?.('No bridge process is currently running; skipping bridge restart.');
     return {
       restarted: false,
       mode: 'process',
     };
   }
 
+  logger?.(`Restarting bridge process ${running.pid}.`);
   const stopResult = await stopBridgeProcesses();
   if (Array.isArray(stopResult.stillAlive) && stopResult.stillAlive.length > 0) {
     throw new Error(`Failed to stop bridge processes: ${stopResult.stillAlive.join(', ')}`);
@@ -1673,19 +1817,31 @@ async function refreshBridgeForUpdate(flags = {}) {
 }
 
 async function handleOpenclawRefreshCommand(flags = {}) {
+  const jsonOutput = isTruthyFlag(flags.json);
+  const logProgress = jsonOutput ? null : (message) => console.log(`[refresh] ${message}`);
   const currentVersion = currentPackageVersion();
   let latestVersion = '';
   if (!isTruthyFlag(flags['skip-version-check'])) {
+    logProgress?.(`Checking npm for the latest oomi-ai version (installed: ${currentVersion || 'unknown'}).`);
     latestVersion = await fetchLatestPublishedVersion('oomi-ai');
     if (latestVersion && compareVersions(currentVersion, latestVersion) < 0) {
       throw new Error(
         `Installed oomi-ai ${currentVersion} is behind npm ${latestVersion}. Update first, then rerun: oomi openclaw refresh`
       );
     }
+    if (latestVersion) {
+      logProgress?.(`Latest published version is ${latestVersion}.`);
+    }
   }
 
-  const personaRefresh = await restartManagedPersonaRefreshTargets(flags);
-  const bridgeRefresh = await refreshBridgeForUpdate(flags);
+  logProgress?.('Refreshing managed persona runtimes.');
+  const personaRefresh = await restartManagedPersonaRefreshTargets(flags, {
+    logger: logProgress,
+  });
+  logProgress?.('Refreshing bridge process.');
+  const bridgeRefresh = await refreshBridgeForUpdate(flags, {
+    logger: logProgress,
+  });
   const payload = {
     ok: true,
     currentVersion,
@@ -1699,7 +1855,7 @@ async function handleOpenclawRefreshCommand(flags = {}) {
     bridge: bridgeRefresh,
   };
 
-  if (isTruthyFlag(flags.json)) {
+  if (jsonOutput) {
     console.log(JSON.stringify(payload, null, 2));
     return;
   }
@@ -5827,5 +5983,8 @@ export {
   isBridgeWorkerCommand,
   parsePositiveInteger,
   collectManagedPersonaRefreshTargets,
+  discoverBackendLinkedPersonaRefreshTargets,
+  normalizeBackendPersonaRefreshRecord,
   resolvePersonaRuntimeInput,
+  resolveExistingWorkspacePathForSlug,
 };

package/lib/personaApiClient.js

@@ -100,10 +100,19 @@ export function createPersonaApiClient({
     };
   }
 
-  return {
-    getPersona({
-      slug,
-    }) {
+  return {
+    listPersonas() {
+      return getJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: '/v1/personas',
+      });
+    },
+
+    getPersona({
+      slug,
+    }) {
       const safeSlug = trimString(slug);
       if (!safeSlug) {
         throw new Error('Persona slug is required.');

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

package/package.json

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