oomi-ai 0.2.7 → 0.2.10

package/README.md

@@ -59,6 +59,15 @@ If you need a fresh auth link later (without re-pairing), run:
 oomi openclaw invite --app-url https://your-oomi-app.vercel.app
 ```
 
+Bridge lifecycle handler (singleton, one bridge per host/device):
+```
+oomi openclaw bridge ensure --detach   # start if needed; no-op if already running
+oomi openclaw bridge ps                # list bridge pids
+oomi openclaw bridge stop              # stop all bridge workers
+oomi openclaw bridge restart --detach  # clean restart as background worker
+```
+`oomi openclaw bridge --detach` is equivalent to `oomi openclaw bridge start --detach`.
+
 Agent-intent mapping (recommended):
 - If user says `Connect yourself to Oomi. Use app URL https://www.oomi.ai.`
 - Run:

package/agent_instructions.md

@@ -26,10 +26,13 @@ If the user asks to connect OpenClaw to Oomi voice/web:
 5. Configure channel account (`channels.oomi.accounts.default`) from:
    - `oomi openclaw plugin --show-secrets --backend-url https://api.oomi.ai`
 6. Restart OpenClaw.
-7. If user provides an app URL (for example "Connect yourself to Oomi. Use app URL <URL>."):
+7. Ensure exactly one bridge worker is running (singleton handler):
+   - `oomi openclaw bridge ensure --detach`
+   - If stale/disconnected: `oomi openclaw bridge restart --detach`
+8. If user provides an app URL (for example "Connect yourself to Oomi. Use app URL <URL>."):
    - Use that URL directly in the pair command.
    - Example: `oomi openclaw pair --app-url <URL> --no-start`
-8. Return this exact result format to the user:
+9. Return this exact result format to the user:
    - `Oomi Connect Ready`
    - `Auth Link: ...`
    - No extra narrative text before or after those lines.

package/bin/oomi-ai.js

@@ -2,7 +2,7 @@
 import fs from 'fs';
 import os from 'os';
 import path from 'path';
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { createPrivateKey, createPublicKey, randomUUID, sign as cryptoSign } from 'crypto';
 import net from 'net';
 import { lookup as dnsLookup } from 'dns/promises';
@@ -151,8 +151,8 @@ Commands:
   openclaw install
     Install agent instructions and the Oomi skill into OpenClaw.
 
-  openclaw bridge
-    Start local OpenClaw-to-Oomi managed broker bridge.
+  openclaw bridge [start|ensure|stop|restart|ps]
+    Manage local OpenClaw-to-Oomi bridge lifecycle (singleton).
 
   openclaw pair
     Pair this OpenClaw host with Oomi and start bridge (single command).
@@ -204,8 +204,8 @@ function readFile(filePath) {
   return fs.readFileSync(filePath, 'utf-8');
 }
 
-function writeFile(filePath, content) {
-  fs.writeFileSync(filePath, content);
+function writeFile(filePath, content, options = undefined) {
+  fs.writeFileSync(filePath, content, options);
 }
 
 function resolveWorkspace() {
@@ -558,6 +558,10 @@ function resolveBridgeStatusPath() {
   return path.join(os.homedir(), '.openclaw', 'oomi-bridge-status.json');
 }
 
+function resolveBridgeLockPath() {
+  return path.join(os.homedir(), '.openclaw', 'oomi-bridge.lock');
+}
+
 function defaultDeviceId() {
   const host = os.hostname().toLowerCase().replace(/[^a-z0-9-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24) || 'openclaw';
   return `oomi-${host}-${randomUUID().slice(0, 8)}`;
@@ -608,6 +612,136 @@ function updateBridgeStatus(partial) {
   return next;
 }
 
+function normalizePid(value) {
+  const pid = Number(value);
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  return pid;
+}
+
+function isPidAlive(pid) {
+  const normalized = normalizePid(pid);
+  if (!normalized) return false;
+  try {
+    process.kill(normalized, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isBridgeWorkerCommand(command) {
+  const text = String(command || '').trim().toLowerCase();
+  if (!text.includes('openclaw bridge')) return false;
+  if (/\bopenclaw\s+bridge\s+(ps|stop|restart|ensure)\b/.test(text)) return false;
+  if (/\bopenclaw\s+bridge\s+start\b/.test(text)) return true;
+  if (/\bopenclaw\s+bridge(\s+--|$)/.test(text)) return true;
+  return false;
+}
+
+function isBridgeProcess(pid) {
+  const normalized = normalizePid(pid);
+  if (!normalized) return false;
+  if (!isPidAlive(normalized)) return false;
+
+  try {
+    const result = spawnSync('ps', ['-p', String(normalized), '-o', 'command='], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const command = String(result.stdout || '').trim();
+    if (!command) return true;
+    return isBridgeWorkerCommand(command);
+  } catch {
+    return true;
+  }
+}
+
+function readBridgeLock() {
+  return readJsonSafe(resolveBridgeLockPath()) || {};
+}
+
+function clearStaleBridgeLock() {
+  const lockPath = resolveBridgeLockPath();
+  if (!fs.existsSync(lockPath)) return;
+  const lock = readBridgeLock();
+  const lockPid = normalizePid(lock.pid);
+  if (lockPid && isBridgeProcess(lockPid)) return;
+  try {
+    fs.unlinkSync(lockPath);
+  } catch {
+    // no-op
+  }
+}
+
+function findRunningBridgeProcess() {
+  clearStaleBridgeLock();
+
+  const lock = readBridgeLock();
+  const lockPid = normalizePid(lock.pid);
+  if (lockPid && isBridgeProcess(lockPid)) {
+    return {
+      pid: lockPid,
+      source: 'lock',
+      deviceId: typeof lock.deviceId === 'string' ? lock.deviceId : '',
+    };
+  }
+
+  const status = readBridgeStatus();
+  const statusPid = normalizePid(status.pid);
+  if (statusPid && isBridgeProcess(statusPid)) {
+    return {
+      pid: statusPid,
+      source: 'status',
+      deviceId: typeof status.deviceId === 'string' ? status.deviceId : '',
+    };
+  }
+
+  return null;
+}
+
+function acquireBridgeLock(deviceId) {
+  const lockPath = resolveBridgeLockPath();
+  ensureDir(path.dirname(lockPath));
+  const payload = {
+    pid: process.pid,
+    deviceId,
+    acquiredAt: bridgeNowIso(),
+  };
+
+  const writeLock = () => writeFile(lockPath, JSON.stringify(payload, null, 2) + '\n', { flag: 'wx' });
+
+  try {
+    writeLock();
+  } catch (err) {
+    const code = err && typeof err === 'object' ? err.code : '';
+    if (code !== 'EEXIST') {
+      throw err;
+    }
+    clearStaleBridgeLock();
+    const existing = findRunningBridgeProcess();
+    if (existing && existing.pid !== process.pid) {
+      throw new Error(
+        `Bridge already running (pid ${existing.pid})${existing.deviceId ? ` for device ${existing.deviceId}` : ''}.`
+      );
+    }
+    writeLock();
+  }
+
+  const release = () => {
+    const current = readBridgeLock();
+    const currentPid = normalizePid(current.pid);
+    if (currentPid && currentPid !== process.pid) return;
+    try {
+      fs.unlinkSync(lockPath);
+    } catch {
+      // no-op
+    }
+  };
+
+  process.once('exit', release);
+  return release;
+}
+
 async function claimBridgeDeviceToken({ brokerHttp, pairCode, deviceId }) {
   const response = await fetch(`${brokerHttp.replace(/\/$/, '')}/v1/pair/claim`, {
     method: 'POST',
@@ -786,7 +920,9 @@ function prepareGatewayFrameForLocalGateway(frameText, gatewayAuth, options = {}
       ? 'node-host'
       : (typeof client.id === 'string' && client.id.trim() ? client.id.trim() : 'node-host');
     client.version = typeof client.version === 'string' && client.version.trim() ? client.version.trim() : '0.1.0';
-    client.platform = typeof client.platform === 'string' && client.platform.trim() ? client.platform.trim() : process.platform;
+    client.platform = proxiedBrowserClient
+      ? process.platform
+      : (typeof client.platform === 'string' && client.platform.trim() ? client.platform.trim() : process.platform);
     client.mode = proxiedBrowserClient
       ? 'backend'
       : (typeof client.mode === 'string' && client.mode.trim() ? client.mode.trim() : 'backend');
@@ -1030,13 +1166,129 @@ function buildBridgeDetachArgs(rawFlags = {}) {
 }
 
 function startBridgeDetachedProcess(rawFlags = {}) {
+  const existing = findRunningBridgeProcess();
+  if (existing) {
+    return {
+      pid: existing.pid,
+      alreadyRunning: true,
+    };
+  }
+
   const args = buildBridgeDetachArgs(rawFlags);
   const child = spawn(process.execPath, args, {
     detached: true,
     stdio: 'ignore',
   });
   child.unref();
-  return child.pid;
+  return {
+    pid: child.pid,
+    alreadyRunning: false,
+  };
+}
+
+function listBridgeProcessPids() {
+  const pids = new Set();
+  const addPid = (value) => {
+    const pid = normalizePid(value);
+    if (!pid || pid === process.pid) return;
+    if (!isBridgeProcess(pid)) return;
+    pids.add(pid);
+  };
+
+  const lock = readBridgeLock();
+  addPid(lock.pid);
+
+  const status = readBridgeStatus();
+  addPid(status.pid);
+
+  try {
+    const result = spawnSync('ps', ['-Ao', 'pid=,command='], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const output = String(result.stdout || '');
+    for (const rawLine of output.split('\n')) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const match = line.match(/^(\d+)\s+(.+)$/);
+      if (!match) continue;
+      const pid = Number(match[1]);
+      const command = String(match[2] || '');
+      if (!isBridgeWorkerCommand(command)) continue;
+      addPid(pid);
+    }
+  } catch {
+    // best-effort process scan
+  }
+
+  return Array.from(pids).sort((a, b) => a - b);
+}
+
+async function waitForBridgePidsToExit(pids, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const alive = pids.filter((pid) => isBridgeProcess(pid));
+    if (alive.length === 0) return [];
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return pids.filter((pid) => isBridgeProcess(pid));
+}
+
+async function stopBridgeProcesses() {
+  const targets = listBridgeProcessPids();
+  if (targets.length === 0) {
+    clearStaleBridgeLock();
+    updateBridgeStatus({
+      status: 'stopped',
+      stopSignal: 'none',
+      lastDisconnectAt: bridgeNowIso(),
+      pid: null,
+    });
+    return {
+      stopped: [],
+      forceKilled: [],
+      found: [],
+    };
+  }
+
+  for (const pid of targets) {
+    try {
+      process.kill(pid, 'SIGTERM');
+    } catch {
+      // no-op
+    }
+  }
+
+  let remaining = await waitForBridgePidsToExit(targets, 2500);
+  const forceKilled = [];
+  if (remaining.length > 0) {
+    for (const pid of remaining) {
+      try {
+        process.kill(pid, 'SIGKILL');
+        forceKilled.push(pid);
+      } catch {
+        // no-op
+      }
+    }
+    remaining = await waitForBridgePidsToExit(remaining, 1000);
+  }
+
+  clearStaleBridgeLock();
+
+  const stopped = targets.filter((pid) => !remaining.includes(pid));
+  updateBridgeStatus({
+    status: 'stopped',
+    stopSignal: forceKilled.length > 0 ? 'SIGKILL' : 'SIGTERM',
+    lastDisconnectAt: bridgeNowIso(),
+    pid: null,
+  });
+
+  return {
+    stopped,
+    forceKilled,
+    found: targets,
+    stillAlive: remaining,
+  };
 }
 
 async function resolveBridgeRuntimeConfig(flags, bridgeState) {
@@ -1077,6 +1329,13 @@ async function resolveBridgeRuntimeConfig(flags, bridgeState) {
 }
 
 async function startOpenclawBridge(flags) {
+  const runningBridge = findRunningBridgeProcess();
+  if (runningBridge && runningBridge.pid !== process.pid) {
+    throw new Error(
+      `Bridge already running (pid ${runningBridge.pid})${runningBridge.deviceId ? ` for device ${runningBridge.deviceId}` : ''}.`
+    );
+  }
+
   const bridgeState = readBridgeState();
   const runtimeConfig = await resolveBridgeRuntimeConfig(flags, bridgeState);
   const brokerHttp = runtimeConfig.brokerHttp;
@@ -1084,6 +1343,7 @@ async function startOpenclawBridge(flags) {
   const deviceId = resolveDeviceId(flags, bridgeState);
   const pairCode = String(flags['pair-code'] || '').trim().toUpperCase();
   const explicitDeviceToken = String(flags['device-token'] || '').trim();
+  const releaseBridgeLock = acquireBridgeLock(deviceId);
   let deviceToken = explicitDeviceToken;
   if (!deviceToken && String(bridgeState.deviceId || '').trim() === deviceId) {
     deviceToken = String(bridgeState.deviceToken || '').trim();
@@ -1671,6 +1931,7 @@ async function startOpenclawBridge(flags) {
       stopSignal: signal,
       pid: process.pid,
     });
+    releaseBridgeLock();
     process.exit(0);
   };
   process.once('SIGINT', () => markStopped('SIGINT'));
@@ -1765,13 +2026,17 @@ async function pairAndStartOpenclawBridge(flags) {
   }
 
   if (detach) {
-    const pid = startBridgeDetachedProcess({
+    const result = startBridgeDetachedProcess({
       'broker-http': managedConfig.brokerHttpUrl,
       'broker-ws': brokerWs,
       'device-id': deviceId,
       'device-token': deviceToken,
     });
-    console.log(`Bridge started in background (pid: ${pid}).`);
+    if (result.alreadyRunning) {
+      console.log(`Bridge already running (pid: ${result.pid}).`);
+      return;
+    }
+    console.log(`Bridge started in background (pid: ${result.pid}).`);
     return;
   }
 
@@ -1969,6 +2234,86 @@ function printOpenclawPluginSetup(flags) {
   }
 }
 
+async function startBridgeLifecycle(flags = {}) {
+  if (Boolean(flags.detach)) {
+    const detachedFlags = { ...flags };
+    delete detachedFlags.detach;
+    const result = startBridgeDetachedProcess(detachedFlags);
+    if (result.alreadyRunning) {
+      console.log(`Bridge already running (pid: ${result.pid}).`);
+      return;
+    }
+    console.log(`Bridge started in background (pid: ${result.pid}).`);
+    return;
+  }
+
+  const running = findRunningBridgeProcess();
+  if (running) {
+    console.log(
+      `Bridge already running (pid ${running.pid})${running.deviceId ? ` for device ${running.deviceId}` : ''}.`
+    );
+    return;
+  }
+
+  await startOpenclawBridge(flags);
+}
+
+async function handleBridgeLifecycleCommand(flags = {}, actionRaw = '') {
+  const action = String(actionRaw || 'start').trim().toLowerCase();
+
+  if (action === 'start' || action === 'ensure') {
+    await startBridgeLifecycle(flags);
+    return;
+  }
+
+  if (action === 'ps') {
+    const pids = listBridgeProcessPids();
+    if (pids.length === 0) {
+      console.log('No bridge processes running.');
+      return;
+    }
+    console.log(`Bridge processes: ${pids.join(', ')}`);
+    return;
+  }
+
+  if (action === 'stop') {
+    const result = await stopBridgeProcesses();
+    if (result.found.length === 0) {
+      console.log('No bridge processes running.');
+      return;
+    }
+    console.log(`Stopped bridge processes: ${result.stopped.join(', ') || 'none'}.`);
+    if (result.forceKilled.length > 0) {
+      console.log(`Force-killed bridge processes: ${result.forceKilled.join(', ')}.`);
+    }
+    if (Array.isArray(result.stillAlive) && result.stillAlive.length > 0) {
+      throw new Error(`Failed to stop bridge processes: ${result.stillAlive.join(', ')}`);
+    }
+    return;
+  }
+
+  if (action === 'restart') {
+    const result = await stopBridgeProcesses();
+    if (result.found.length > 0) {
+      console.log(`Stopped bridge processes: ${result.stopped.join(', ') || 'none'}.`);
+      if (result.forceKilled.length > 0) {
+        console.log(`Force-killed bridge processes: ${result.forceKilled.join(', ')}.`);
+      }
+    } else {
+      console.log('No existing bridge process found; starting fresh bridge.');
+    }
+    if (Array.isArray(result.stillAlive) && result.stillAlive.length > 0) {
+      throw new Error(`Failed to stop bridge processes: ${result.stillAlive.join(', ')}`);
+    }
+    await startBridgeLifecycle(flags);
+    return;
+  }
+
+  throw new Error(
+    `Unknown bridge action: ${action}. Use: oomi openclaw bridge [start|ensure|stop|restart|ps]`
+  );
+}
+
 async function main() {
   const args = parseArgs(process.argv);
   const command = args.command;
@@ -2001,14 +2346,8 @@ async function main() {
   }
 
   if (command === 'openclaw' && subcommand === 'bridge') {
-    if (Boolean(args.flags.detach)) {
-      const detachedFlags = { ...args.flags };
-      delete detachedFlags.detach;
-      const pid = startBridgeDetachedProcess(detachedFlags);
-      console.log(`Bridge started in background (pid: ${pid}).`);
-      return;
-    }
-    await startOpenclawBridge(args.flags);
+    const bridgeAction = args.positionals[0] || 'start';
+    await handleBridgeLifecycleCommand(args.flags, bridgeAction);
     return;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oomi-ai",
-  "version": "0.2.7",
+  "version": "0.2.10",
   "description": "Oomi CLI for OpenClaw setup",
   "bin": {
     "oomi": "bin/oomi-ai.js"

package/skills/oomi/agent_instructions.md

@@ -26,10 +26,13 @@ If the user asks to connect OpenClaw to Oomi voice/web:
 5. Configure channel account (`channels.oomi.accounts.default`) from:
    - `oomi openclaw plugin --show-secrets --backend-url https://api.oomi.ai`
 6. Restart OpenClaw.
-7. If user provides an app URL (for example "Connect yourself to Oomi. Use app URL <URL>."):
+7. Ensure exactly one bridge worker is running (singleton handler):
+   - `oomi openclaw bridge ensure --detach`
+   - If stale/disconnected: `oomi openclaw bridge restart --detach`
+8. If user provides an app URL (for example "Connect yourself to Oomi. Use app URL <URL>."):
    - Use that URL directly in the pair command.
    - Example: `oomi openclaw pair --app-url <URL> --no-start`
-8. Return this exact result format to the user:
+9. Return this exact result format to the user:
    - `Oomi Connect Ready`
    - `Auth Link: ...`
    - No extra narrative text before or after those lines.