oomi-ai 0.2.49 → 0.3.0

package/lib/channelPluginClient.js

@@ -1,119 +0,0 @@
-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/openclawDevGateway.js

@@ -1,384 +0,0 @@
-import fs from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import WebSocket, { WebSocketServer } from 'ws';
-
-import { resolveOpenclawConfigCandidates } from './openclawPaths.js';
-import { inferSpokenMetadataFromContent } from './spokenMetadata.js';
-
-const DEFAULT_GATEWAY_HOST = '127.0.0.1';
-const DEFAULT_GATEWAY_PORT = 18789;
-const PRIMER_MARKER = '[oomi:primer:v1]';
-
-function trimString(value, fallback = '') {
-  return typeof value === 'string' && value.trim() ? value.trim() : fallback;
-}
-
-function readJsonSafe(filePath) {
-  if (!filePath || !fs.existsSync(filePath)) return null;
-  try {
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-function resolveGatewayConfig() {
-  const config = resolveOpenclawConfigCandidates()
-    .map((candidate) => readJsonSafe(candidate))
-    .find((entry) => entry && typeof entry === 'object');
-
-  const gateway = config?.gateway && typeof config.gateway === 'object' ? config.gateway : {};
-  const auth = gateway.auth && typeof gateway.auth === 'object' ? gateway.auth : {};
-  const port = Number(gateway.port);
-  return {
-    host: trimString(process.env.OPENCLAW_GATEWAY_HOST, DEFAULT_GATEWAY_HOST),
-    port: Number.isFinite(port) && port > 0 ? Math.floor(port) : DEFAULT_GATEWAY_PORT,
-    token: trimString(process.env.OPENCLAW_GATEWAY_TOKEN, trimString(auth.token)),
-    password: trimString(process.env.OPENCLAW_GATEWAY_PASSWORD, trimString(auth.password)),
-  };
-}
-
-function chunkText(text, maxChunkLength = 32) {
-  const words = trimString(text).split(/\s+/).filter(Boolean);
-  if (words.length === 0) return [];
-
-  const chunks = [];
-  let current = '';
-  for (const word of words) {
-    const next = current ? `${current} ${word}` : word;
-    if (current && next.length > maxChunkLength) {
-      chunks.push(current);
-      current = word;
-      continue;
-    }
-    current = next;
-  }
-  if (current) {
-    chunks.push(current);
-  }
-  return chunks;
-}
-
-function buildHistoryMessage({ role, content, metadata, timestamp = Date.now() }) {
-  const message = {
-    role,
-    content: [{ type: 'text', text: content }],
-    ts: timestamp,
-  };
-  if (metadata && typeof metadata === 'object') {
-    message.metadata = metadata;
-  }
-  return message;
-}
-
-function buildLocalGatewayAssistantText(userText) {
-  const normalized = trimString(userText);
-  if (!normalized) {
-    return 'Local OpenClaw dev agent is connected and ready.';
-  }
-  return `Local OpenClaw dev agent received: ${normalized}`;
-}
-
-function createLocalGatewayAssistantFrames({ sessionKey, replyText, runId, seqStart = 1, timestampStart = Date.now() }) {
-  const spoken = inferSpokenMetadataFromContent(replyText);
-  const chunks = chunkText(replyText);
-  const frames = [];
-  let seq = seqStart;
-  let ts = timestampStart;
-
-  frames.push({
-    type: 'event',
-    event: 'agent',
-    payload: {
-      runId,
-      stream: 'lifecycle',
-      data: { phase: 'start' },
-      sessionKey,
-      seq: seq++,
-      ts: ts++,
-    },
-  });
-
-  for (const chunk of chunks) {
-    frames.push({
-      type: 'event',
-      event: 'agent',
-      payload: {
-        runId,
-        stream: 'assistant',
-        delta: chunk,
-        sessionKey,
-        seq: seq++,
-        ts: ts++,
-      },
-    });
-  }
-
-  frames.push({
-    type: 'event',
-    event: 'chat',
-    payload: {
-      runId,
-      sessionKey,
-      seq: seq++,
-      ts: ts++,
-      state: 'final',
-      message: {
-        role: 'assistant',
-        content: [{ type: 'text', text: replyText }],
-        timestamp: Date.now(),
-        metadata: spoken ? { spoken } : {},
-      },
-    },
-  });
-
-  frames.push({
-    type: 'event',
-    event: 'agent',
-    payload: {
-      runId,
-      stream: 'lifecycle',
-      data: { phase: 'end' },
-      sessionKey,
-      seq: seq++,
-      ts: ts++,
-    },
-  });
-
-  return frames;
-}
-
-function createUnauthorizedResponse(id) {
-  return {
-    type: 'res',
-    id,
-    ok: false,
-    error: {
-      code: 'unauthorized',
-      message: 'Local gateway auth rejected the connection request.',
-    },
-  };
-}
-
-function createOkResponse(id, payload = {}) {
-  return {
-    type: 'res',
-    id,
-    ok: true,
-    payload,
-  };
-}
-
-function createAbortedEvent(sessionKey) {
-  return {
-    type: 'event',
-    event: 'chat',
-    payload: {
-      sessionKey,
-      state: 'aborted',
-      timestamp: Date.now(),
-    },
-  };
-}
-
-function scheduleAssistantFrames({ socket, sessionKey, frames, pendingReplies, logger }) {
-  const existing = pendingReplies.get(sessionKey);
-  if (existing?.timers) {
-    for (const timer of existing.timers) {
-      clearTimeout(timer);
-    }
-  }
-
-  const timers = [];
-  frames.forEach((frame, index) => {
-    const timer = setTimeout(() => {
-      if (socket.readyState !== WebSocket.OPEN) return;
-      socket.send(JSON.stringify(frame));
-      if (index === frames.length - 1) {
-        pendingReplies.delete(sessionKey);
-      }
-    }, index * 30);
-    timers.push(timer);
-  });
-  pendingReplies.set(sessionKey, { timers });
-  logger?.(`[dev-gateway] queued assistant reply for ${sessionKey} (${frames.length} frames)`);
-}
-
-async function startLocalGatewayAgentServer({ host, port, token, password, logger = () => {} } = {}) {
-  const gatewayConfig = resolveGatewayConfig();
-  const bindHost = trimString(host, gatewayConfig.host);
-  const bindPort = Number.isFinite(Number(port)) && Number(port) > 0 ? Math.floor(Number(port)) : gatewayConfig.port;
-  const authToken = trimString(token, gatewayConfig.token);
-  const authPassword = trimString(password, gatewayConfig.password);
-  const histories = new Map();
-  const pendingReplies = new Map();
-
-  const server = new WebSocketServer({
-    host: bindHost,
-    port: bindPort,
-  });
-
-  const closePendingForSession = (sessionKey) => {
-    const pending = pendingReplies.get(sessionKey);
-    if (!pending?.timers) return false;
-    for (const timer of pending.timers) {
-      clearTimeout(timer);
-    }
-    pendingReplies.delete(sessionKey);
-    return true;
-  };
-
-  const appendHistory = (sessionKey, message) => {
-    const history = histories.get(sessionKey) || [];
-    history.push(message);
-    histories.set(sessionKey, history);
-  };
-
-  server.on('connection', (socket) => {
-    const challengeNonce = `dev-nonce-${randomUUID()}`;
-    socket.send(JSON.stringify({
-      type: 'event',
-      event: 'connect.challenge',
-      payload: { nonce: challengeNonce },
-    }));
-    logger(`[dev-gateway] connection opened, challenge sent (${challengeNonce})`);
-
-    socket.on('message', (rawMessage) => {
-      let frame;
-      try {
-        frame = JSON.parse(String(rawMessage));
-      } catch {
-        return;
-      }
-
-      if (!frame || frame.type !== 'req') {
-        return;
-      }
-
-      const requestId = trimString(frame.id);
-      const method = trimString(frame.method);
-      const params = frame.params && typeof frame.params === 'object' ? frame.params : {};
-      const sessionKey = trimString(params.sessionKey, 'agent:main:webchat:channel:oomi');
-
-      if (method === 'connect') {
-        const requestAuth = params.auth && typeof params.auth === 'object' ? params.auth : {};
-        const providedToken = trimString(requestAuth.token);
-        const providedPassword = trimString(requestAuth.password);
-        const authorized =
-          (!authToken || providedToken === authToken) &&
-          (!authPassword || providedPassword === authPassword);
-        socket.send(JSON.stringify(authorized ? createOkResponse(requestId, { sessionKey }) : createUnauthorizedResponse(requestId)));
-        return;
-      }
-
-      if (method === 'chat.history') {
-        const messages = histories.get(sessionKey) || [];
-        socket.send(JSON.stringify(createOkResponse(requestId, { messages })));
-        return;
-      }
-
-      if (method === 'chat.abort') {
-        closePendingForSession(sessionKey);
-        socket.send(JSON.stringify(createOkResponse(requestId)));
-        socket.send(JSON.stringify(createAbortedEvent(sessionKey)));
-        return;
-      }
-
-      if (method !== 'chat.send') {
-        socket.send(JSON.stringify({
-          type: 'res',
-          id: requestId,
-          ok: false,
-          error: {
-            code: 'unsupported_method',
-            message: `Local dev gateway does not handle ${method || 'unknown'}.`,
-          },
-        }));
-        return;
-      }
-
-      const messageText = trimString(params.message);
-      appendHistory(sessionKey, buildHistoryMessage({
-        role: 'user',
-        content: messageText,
-      }));
-      socket.send(JSON.stringify(createOkResponse(requestId)));
-
-      if (!messageText || messageText.includes(PRIMER_MARKER)) {
-        return;
-      }
-
-      const replyText = buildLocalGatewayAssistantText(messageText);
-      const runId = `dev-run-${randomUUID()}`;
-      const assistantMessage = buildHistoryMessage({
-        role: 'assistant',
-        content: replyText,
-        metadata: {
-          spoken: inferSpokenMetadataFromContent(replyText),
-        },
-      });
-      appendHistory(sessionKey, assistantMessage);
-      const frames = createLocalGatewayAssistantFrames({
-        sessionKey,
-        replyText,
-        runId,
-      });
-      scheduleAssistantFrames({
-        socket,
-        sessionKey,
-        frames,
-        pendingReplies,
-        logger,
-      });
-    });
-
-    socket.on('close', () => {
-      for (const [sessionKey, pending] of pendingReplies.entries()) {
-        if (!pending?.timers) continue;
-        for (const timer of pending.timers) {
-          clearTimeout(timer);
-        }
-        pendingReplies.delete(sessionKey);
-      }
-      logger('[dev-gateway] connection closed');
-    });
-  });
-
-  await new Promise((resolve, reject) => {
-    server.once('listening', resolve);
-    server.once('error', reject);
-  });
-
-  logger(`[dev-gateway] listening on ws://${bindHost}:${bindPort}`);
-
-  return {
-    host: bindHost,
-    port: bindPort,
-    token: authToken,
-    password: authPassword,
-    close: async () => {
-      for (const pending of pendingReplies.values()) {
-        if (!pending?.timers) continue;
-        for (const timer of pending.timers) {
-          clearTimeout(timer);
-        }
-      }
-      pendingReplies.clear();
-      await new Promise((resolve, reject) => {
-        server.close((error) => {
-          if (error) {
-            reject(error);
-            return;
-          }
-          resolve();
-        });
-      });
-    },
-  };
-}
-
-export {
-  buildLocalGatewayAssistantText,
-  createLocalGatewayAssistantFrames,
-  startLocalGatewayAgentServer,
-};

package/lib/personaJobExecutor.js

@@ -1,139 +0,0 @@
-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 () => {},
-  destroyWorkspace = async () => ({ deleted: false }),
-  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 (!['create_persona_runtime', 'destroy_persona_runtime'].includes(payload.jobType)) {
-      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';
-
-    if (payload.jobType === 'destroy_persona_runtime') {
-      const workspacePath = String(scaffold.outDir || '').trim();
-      if (!workspacePath) {
-        throw new Error('Destroy persona job payload is missing scaffold.outDir.');
-      }
-
-      const result = {
-        workspacePath,
-        ...(await destroyWorkspace({
-          payload,
-          workspacePath,
-        })),
-      };
-
-      await onJobSuccess({ jobId, payload, result });
-
-      return {
-        ok: true,
-        jobId,
-        result,
-      };
-    }
-
-    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,
-      },
-    };
-  }
-}