oomi-ai 0.2.17 → 0.2.18

package/bin/sessionBridgeState.js

@@ -1,78 +1,78 @@
-const WS_CONNECTING = 0;
-const WS_OPEN = 1;
-
-/**
- * Ensure session state exists so client frames can be buffered before client.open arrives.
- */
-export function ensureSessionBridge({ sessions, sessionId, createSocket }) {
-  const id = String(sessionId || '').trim();
-  if (!id) return null;
-
-  const existing = sessions.get(id);
-  if (existing) return existing;
-
-  const socket = createSocket(id);
-  const next = {
-    socket,
-    queue: [],
-    connectAccepted: false,
-    waitingForConnect: [],
-  };
-  sessions.set(id, next);
-  return next;
-}
-
-/**
- * Forward a frame to the gateway socket or queue it while connecting.
- */
-export function forwardFrameToSession(sessionBridge, frameText, options = {}) {
-  if (!sessionBridge || !sessionBridge.socket || typeof frameText !== 'string' || !frameText) {
-    return 'dropped';
-  }
-
-  if (options.requiresConnectAccepted === true && sessionBridge.connectAccepted !== true) {
-    if (!Array.isArray(sessionBridge.waitingForConnect)) {
-      sessionBridge.waitingForConnect = [];
-    }
-    sessionBridge.waitingForConnect.push(frameText);
-    return 'waiting_for_connect';
-  }
-
-  const { socket } = sessionBridge;
-  if (socket.readyState === WS_OPEN) {
-    socket.send(frameText);
-    return 'sent';
-  }
-
-  if (socket.readyState === WS_CONNECTING) {
-    sessionBridge.queue.push(frameText);
-    return 'queued';
-  }
-
-  return 'dropped';
-}
-
-export function flushWaitingForConnect(sessionBridge) {
-  if (!sessionBridge) return [];
-
-  sessionBridge.connectAccepted = true;
-  const pending = Array.isArray(sessionBridge.waitingForConnect)
-    ? sessionBridge.waitingForConnect.splice(0, sessionBridge.waitingForConnect.length)
-    : [];
-
-  return pending.map((frameText) => ({
-    frameText,
-    result: forwardFrameToSession(sessionBridge, frameText),
-  }));
-}
-
-export function flushSessionQueue(sessionBridge) {
-  if (!sessionBridge || !sessionBridge.socket) return;
-  const socket = sessionBridge.socket;
-  while (sessionBridge.queue.length > 0 && socket.readyState === WS_OPEN) {
-    const nextFrame = sessionBridge.queue.shift();
-    if (typeof nextFrame === 'string' && nextFrame) {
-      socket.send(nextFrame);
-    }
-  }
-}
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+
+/**
+ * Ensure session state exists so client frames can be buffered before client.open arrives.
+ */
+export function ensureSessionBridge({ sessions, sessionId, createSocket }) {
+  const id = String(sessionId || '').trim();
+  if (!id) return null;
+
+  const existing = sessions.get(id);
+  if (existing) return existing;
+
+  const socket = createSocket(id);
+  const next = {
+    socket,
+    queue: [],
+    connectAccepted: false,
+    waitingForConnect: [],
+  };
+  sessions.set(id, next);
+  return next;
+}
+
+/**
+ * Forward a frame to the gateway socket or queue it while connecting.
+ */
+export function forwardFrameToSession(sessionBridge, frameText, options = {}) {
+  if (!sessionBridge || !sessionBridge.socket || typeof frameText !== 'string' || !frameText) {
+    return 'dropped';
+  }
+
+  if (options.requiresConnectAccepted === true && sessionBridge.connectAccepted !== true) {
+    if (!Array.isArray(sessionBridge.waitingForConnect)) {
+      sessionBridge.waitingForConnect = [];
+    }
+    sessionBridge.waitingForConnect.push(frameText);
+    return 'waiting_for_connect';
+  }
+
+  const { socket } = sessionBridge;
+  if (socket.readyState === WS_OPEN) {
+    socket.send(frameText);
+    return 'sent';
+  }
+
+  if (socket.readyState === WS_CONNECTING) {
+    sessionBridge.queue.push(frameText);
+    return 'queued';
+  }
+
+  return 'dropped';
+}
+
+export function flushWaitingForConnect(sessionBridge) {
+  if (!sessionBridge) return [];
+
+  sessionBridge.connectAccepted = true;
+  const pending = Array.isArray(sessionBridge.waitingForConnect)
+    ? sessionBridge.waitingForConnect.splice(0, sessionBridge.waitingForConnect.length)
+    : [];
+
+  return pending.map((frameText) => ({
+    frameText,
+    result: forwardFrameToSession(sessionBridge, frameText),
+  }));
+}
+
+export function flushSessionQueue(sessionBridge) {
+  if (!sessionBridge || !sessionBridge.socket) return;
+  const socket = sessionBridge.socket;
+  while (sessionBridge.queue.length > 0 && socket.readyState === WS_OPEN) {
+    const nextFrame = sessionBridge.queue.shift();
+    if (typeof nextFrame === 'string' && nextFrame) {
+      socket.send(nextFrame);
+    }
+  }
+}

package/lib/channelPluginClient.js

@@ -0,0 +1,119 @@
+function trimString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function stripTrailingSlash(value) {
+  return trimString(value).replace(/\/+$/, '');
+}
+
+async function readJsonResponse(response) {
+  return response.json().catch(() => ({}));
+}
+
+async function requestJson({
+  fetchImpl,
+  backendUrl,
+  path,
+  deviceToken,
+  method = 'POST',
+  body,
+}) {
+  const baseUrl = stripTrailingSlash(backendUrl);
+  if (!baseUrl) {
+    throw new Error('Backend URL is required.');
+  }
+  const token = trimString(deviceToken);
+  if (!token) {
+    throw new Error('Device token is required.');
+  }
+
+  const response = await fetchImpl(`${baseUrl}${path}`, {
+    method,
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    const errorMessage =
+      trimString(payload?.error) ||
+      trimString(payload?.message) ||
+      `Channel plugin request failed (${response.status})`;
+    throw new Error(errorMessage);
+  }
+
+  return payload;
+}
+
+export function createChannelPluginClient({
+  backendUrl,
+  deviceToken,
+  fetchImpl = globalThis.fetch,
+}) {
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch implementation is required.');
+  }
+
+  const resolvedBackendUrl = stripTrailingSlash(backendUrl);
+  const resolvedDeviceToken = trimString(deviceToken);
+
+  return {
+    pollMessages({
+      limit = 20,
+      metadataType,
+    } = {}) {
+      const safeLimit = Number.isFinite(Number(limit)) ? Math.max(1, Math.min(100, Math.floor(Number(limit)))) : 20;
+      const payload = { limit: safeLimit };
+      const safeMetadataType = trimString(metadataType);
+      if (safeMetadataType) {
+        payload.metadataType = safeMetadataType;
+      }
+
+      return requestJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: '/v1/channel/plugin/poll',
+        method: 'POST',
+        body: payload,
+      });
+    },
+
+    ackMessage({
+      messageId,
+      outcome = 'delivered',
+      failureCode,
+    }) {
+      const safeMessageId = trimString(messageId);
+      if (!safeMessageId) {
+        throw new Error('Channel message id is required.');
+      }
+
+      const safeOutcome = trimString(outcome) || 'delivered';
+      if (safeOutcome !== 'delivered' && safeOutcome !== 'failed') {
+        throw new Error('Ack outcome must be delivered or failed.');
+      }
+
+      const body = {
+        messageId: safeMessageId,
+        outcome: safeOutcome,
+      };
+      const safeFailureCode = trimString(failureCode);
+      if (safeFailureCode) {
+        body.failureCode = safeFailureCode;
+      }
+
+      return requestJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: '/v1/channel/plugin/acks',
+        method: 'POST',
+        body,
+      });
+    },
+  };
+}

package/lib/personaApiClient.js

@@ -0,0 +1,221 @@
+function trimString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function stripTrailingSlash(value) {
+  return trimString(value).replace(/\/+$/, '');
+}
+
+async function readJsonResponse(response) {
+  return response.json().catch(() => ({}));
+}
+
+async function postJson({ fetchImpl, backendUrl, path, deviceToken, body }) {
+  const baseUrl = stripTrailingSlash(backendUrl);
+  if (!baseUrl) {
+    throw new Error('Backend URL is required.');
+  }
+  const token = trimString(deviceToken);
+  if (!token) {
+    throw new Error('Device token is required.');
+  }
+
+  const response = await fetchImpl(`${baseUrl}${path}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    const errorMessage =
+      trimString(payload?.error) ||
+      trimString(payload?.message) ||
+      `Persona API request failed (${response.status})`;
+    throw new Error(errorMessage);
+  }
+
+  return payload;
+}
+
+export function createPersonaApiClient({
+  backendUrl,
+  deviceToken,
+  deviceId,
+  fetchImpl = globalThis.fetch,
+}) {
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch implementation is required.');
+  }
+
+  const resolvedBackendUrl = stripTrailingSlash(backendUrl);
+  const resolvedDeviceToken = trimString(deviceToken);
+  const resolvedDeviceId = trimString(deviceId);
+
+  function withDevice(body = {}) {
+    if (!resolvedDeviceId) {
+      return body;
+    }
+    return {
+      ...body,
+      deviceId: resolvedDeviceId,
+    };
+  }
+
+  return {
+    registerRuntime({
+      slug,
+      endpoint,
+      healthcheckUrl,
+      transport = 'local',
+      localPort,
+      startedAt,
+    }) {
+      const safeSlug = trimString(slug);
+      if (!safeSlug) {
+        throw new Error('Persona slug is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/personas/${encodeURIComponent(safeSlug)}/runtime_register`,
+        body: withDevice({
+          endpoint,
+          healthcheckUrl,
+          transport,
+          localPort,
+          startedAt,
+        }),
+      });
+    },
+
+    heartbeatRuntime({
+      slug,
+      endpoint,
+      healthcheckUrl,
+      transport = 'local',
+      localPort,
+      observedAt,
+    }) {
+      const safeSlug = trimString(slug);
+      if (!safeSlug) {
+        throw new Error('Persona slug is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/personas/${encodeURIComponent(safeSlug)}/heartbeat`,
+        body: withDevice({
+          endpoint,
+          healthcheckUrl,
+          transport,
+          localPort,
+          observedAt,
+        }),
+      });
+    },
+
+    failRuntime({
+      slug,
+      code,
+      message,
+    }) {
+      const safeSlug = trimString(slug);
+      if (!safeSlug) {
+        throw new Error('Persona slug is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/personas/${encodeURIComponent(safeSlug)}/fail`,
+        body: withDevice({
+          code,
+          message,
+        }),
+      });
+    },
+
+    startJob({
+      jobId,
+      startedAt,
+    }) {
+      const safeJobId = trimString(jobId);
+      if (!safeJobId) {
+        throw new Error('Persona job id is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/persona_jobs/${encodeURIComponent(safeJobId)}/start`,
+        body: withDevice({
+          startedAt,
+        }),
+      });
+    },
+
+    succeedJob({
+      jobId,
+      workspacePath,
+      localPort,
+      transport = 'local',
+      endpoint,
+      healthcheckUrl,
+      completedAt,
+    }) {
+      const safeJobId = trimString(jobId);
+      if (!safeJobId) {
+        throw new Error('Persona job id is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/persona_jobs/${encodeURIComponent(safeJobId)}/succeed`,
+        body: withDevice({
+          workspacePath,
+          localPort,
+          transport,
+          endpoint,
+          healthcheckUrl,
+          completedAt,
+        }),
+      });
+    },
+
+    failJob({
+      jobId,
+      code,
+      message,
+      completedAt,
+    }) {
+      const safeJobId = trimString(jobId);
+      if (!safeJobId) {
+        throw new Error('Persona job id is required.');
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/persona_jobs/${encodeURIComponent(safeJobId)}/fail`,
+        body: withDevice({
+          code,
+          message,
+          completedAt,
+        }),
+      });
+    },
+  };
+}

package/lib/personaJobExecutor.js

@@ -0,0 +1,115 @@
+import { scaffoldPersonaApp } from './scaffold.js';
+
+export function extractPersonaJobPayload(message = {}) {
+  const metadata = message.metadata && typeof message.metadata === 'object' ? message.metadata : {};
+  const payload = metadata.payload && typeof metadata.payload === 'object' ? metadata.payload : null;
+
+  if (metadata.type !== 'persona_job' || !payload) {
+    throw new Error('Message is not a persona job payload.');
+  }
+
+  return payload;
+}
+
+export async function executePersonaJob({
+  message,
+  installWorkspace = async () => {},
+  startWorkspace = async () => ({ pid: null, logFilePath: '' }),
+  waitForRuntime = async () => {},
+  registerRuntime = async () => {},
+  onJobStart = async () => {},
+  onJobSuccess = async () => {},
+  onJobFailure = async () => {},
+}) {
+  const payload = extractPersonaJobPayload(message);
+  const jobId = String(payload.jobId || message?.metadata?.jobId || '').trim();
+  if (!jobId) {
+    throw new Error('Persona job payload is missing jobId.');
+  }
+
+  try {
+    if (payload.jobType !== 'create_persona_runtime') {
+      throw new Error(`Unsupported persona job type: ${payload.jobType || 'unknown'}`);
+    }
+
+    await onJobStart({ jobId, payload });
+
+    const persona = payload.persona && typeof payload.persona === 'object' ? payload.persona : {};
+    const scaffold = payload.scaffold && typeof payload.scaffold === 'object' ? payload.scaffold : {};
+    const templateVersion = String(persona.templateVersion || 'v1').trim() || 'v1';
+
+    const scaffoldResult = scaffoldPersonaApp({
+      slug: String(persona.slug || '').trim(),
+      name: String(persona.name || '').trim(),
+      description: String(persona.description || '').trim(),
+      outDir: String(scaffold.outDir || '').trim(),
+      templateVersion,
+      force: true,
+    });
+
+    await installWorkspace({
+      payload,
+      workspacePath: scaffoldResult.outDir,
+      scaffoldResult,
+    });
+
+    const runtime = {
+      transport: 'local',
+      endpoint: `http://127.0.0.1:${scaffoldResult.defaultPort}`,
+      localPort: scaffoldResult.defaultPort,
+      healthcheckUrl: `http://127.0.0.1:${scaffoldResult.defaultPort}${scaffoldResult.healthPath}`,
+    };
+    const processInfo = await startWorkspace({
+      payload,
+      workspacePath: scaffoldResult.outDir,
+      scaffoldResult,
+      runtime,
+    });
+    await waitForRuntime({
+      payload,
+      workspacePath: scaffoldResult.outDir,
+      scaffoldResult,
+      runtime,
+      processInfo,
+    });
+
+    const result = {
+      workspacePath: scaffoldResult.outDir,
+      localPort: runtime.localPort,
+      transport: runtime.transport,
+      endpoint: runtime.endpoint,
+      healthcheckUrl: runtime.healthcheckUrl,
+      pid: processInfo?.pid || null,
+      logFilePath: processInfo?.logFilePath || '',
+      templateVersion,
+    };
+
+    await registerRuntime({ jobId, payload, result });
+    await onJobSuccess({ jobId, payload, result });
+
+    return {
+      ok: true,
+      jobId,
+      result,
+    };
+  } catch (error) {
+    const messageText = error instanceof Error ? error.message : 'Persona job execution failed.';
+    await onJobFailure({
+      jobId,
+      payload,
+      error: {
+        code: 'PERSONA_JOB_EXECUTION_FAILED',
+        message: messageText,
+      },
+    });
+
+    return {
+      ok: false,
+      jobId,
+      error: {
+        code: 'PERSONA_JOB_EXECUTION_FAILED',
+        message: messageText,
+      },
+    };
+  }
+}