oomi-ai 0.2.16 → 0.2.18

package/lib/personaJobPoller.js

@@ -0,0 +1,112 @@
+import { createChannelPluginClient } from './channelPluginClient.js';
+
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function failureCodeFor(error) {
+  if (error && typeof error === 'object' && typeof error.code === 'string' && error.code.trim()) {
+    return error.code.trim();
+  }
+  return 'persona_job_delivery_failed';
+}
+
+export function startPersonaJobPoller({
+  backendUrl,
+  deviceToken,
+  onMessage,
+  fetchImpl = globalThis.fetch,
+  metadataType = 'persona_job',
+  pollIntervalMs = 3000,
+  idleIntervalMs = 3000,
+  logger = console,
+}) {
+  if (typeof onMessage !== 'function') {
+    throw new Error('onMessage callback is required.');
+  }
+
+  const client = createChannelPluginClient({
+    backendUrl,
+    deviceToken,
+    fetchImpl,
+  });
+
+  let stopped = false;
+  let activeLoop = null;
+
+  async function loop() {
+    while (!stopped) {
+      try {
+        const payload = await client.pollMessages({
+          limit: 10,
+          metadataType,
+        });
+        const messages = Array.isArray(payload?.messages) ? payload.messages : [];
+
+        if (messages.length === 0) {
+          await wait(idleIntervalMs);
+          continue;
+        }
+
+        for (const message of messages) {
+          if (stopped) break;
+
+          try {
+            await onMessage(message);
+            await client.ackMessage({
+              messageId: message?.messageId,
+              outcome: 'delivered',
+            });
+          } catch (error) {
+            const messageId = typeof message?.messageId === 'string' ? message.messageId : '';
+            try {
+              if (messageId) {
+                await client.ackMessage({
+                  messageId,
+                  outcome: 'failed',
+                  failureCode: failureCodeFor(error),
+                });
+              }
+            } catch (ackError) {
+              logger.error?.(
+                `[persona-jobs] failed to ack message ${messageId || 'unknown'}: ${
+                  ackError instanceof Error ? ackError.message : String(ackError)
+                }`
+              );
+            }
+
+            logger.error?.(
+              `[persona-jobs] execution failed for ${messageId || 'unknown'}: ${
+                error instanceof Error ? error.message : String(error)
+              }`
+            );
+          }
+        }
+
+        if (stopped) {
+          break;
+        }
+        await wait(pollIntervalMs);
+      } catch (error) {
+        logger.error?.(
+          `[persona-jobs] poll failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+        if (stopped) {
+          break;
+        }
+        await wait(idleIntervalMs);
+      }
+    }
+  }
+
+  activeLoop = loop();
+
+  return {
+    stop() {
+      stopped = true;
+    },
+    completed: activeLoop,
+  };
+}

package/lib/personaRuntimeProcess.js

@@ -0,0 +1,152 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+function resolveNpmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function wait(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function runProcess({ command, args, cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: 'inherit',
+      shell: false,
+      windowsHide: true,
+    });
+
+    child.on('error', reject);
+    child.on('exit', (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} ${args.join(' ')} failed with exit code ${code ?? 'unknown'}.`));
+    });
+  });
+}
+
+export async function installPersonaWorkspace({
+  workspacePath,
+}) {
+  if (!workspacePath) {
+    throw new Error('Workspace path is required.');
+  }
+
+  await runProcess({
+    command: resolveNpmCommand(),
+    args: ['install'],
+    cwd: workspacePath,
+  });
+}
+
+export function startPersonaWorkspace({
+  workspacePath,
+  logFilePath,
+  env = {},
+}) {
+  if (!workspacePath) {
+    throw new Error('Workspace path is required.');
+  }
+
+  const resolvedLogFilePath =
+    logFilePath ||
+    path.join(workspacePath, '.oomi', 'runtime.log');
+  ensureDir(path.dirname(resolvedLogFilePath));
+
+  const output = fs.openSync(resolvedLogFilePath, 'a');
+  const child = spawn(resolveNpmCommand(), ['run', 'dev'], {
+    cwd: workspacePath,
+    detached: true,
+    stdio: ['ignore', output, output],
+    shell: false,
+    windowsHide: true,
+    env: {
+      ...process.env,
+      ...env,
+    },
+  });
+
+  child.unref();
+
+  return {
+    pid: child.pid,
+    logFilePath: resolvedLogFilePath,
+  };
+}
+
+async function fetchHealth(url) {
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: {
+      Accept: 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Healthcheck returned ${response.status}.`);
+  }
+
+  return response;
+}
+
+export async function waitForPersonaRuntime({
+  healthcheckUrl,
+  timeoutMs = 45000,
+  intervalMs = 1000,
+}) {
+  if (!healthcheckUrl) {
+    throw new Error('Healthcheck URL is required.');
+  }
+
+  const startedAt = Date.now();
+  let lastError = null;
+  while (Date.now() - startedAt <= timeoutMs) {
+    try {
+      await fetchHealth(healthcheckUrl);
+      return;
+    } catch (error) {
+      lastError = error;
+      await wait(intervalMs);
+    }
+  }
+
+  const message =
+    lastError instanceof Error
+      ? lastError.message
+      : 'Timed out waiting for persona runtime healthcheck.';
+  throw new Error(`Timed out waiting for persona runtime healthcheck: ${message}`);
+}
+
+export function buildLocalPersonaRuntime({
+  localPort,
+  healthPath,
+}) {
+  const port = Number(localPort);
+  if (!Number.isFinite(port) || port <= 0) {
+    throw new Error('Local port is required.');
+  }
+
+  const endpoint = `http://127.0.0.1:${port}`;
+  return {
+    transport: 'local',
+    endpoint,
+    localPort: port,
+    healthcheckUrl: `${endpoint}${healthPath}`,
+  };
+}
+
+export function defaultPersonaWorkspaceRoot() {
+  return path.join(os.homedir(), '.openclaw', 'personas');
+}

package/lib/scaffold.js

@@ -0,0 +1,108 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import {
+  DEFAULT_TEMPLATE_ID,
+  DEFAULT_TEMPLATE_VERSION,
+  readTemplateDescriptor,
+  renderTemplateFile,
+  resolveTemplateRoot,
+} from './template.js';
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function validatePersonaSlug(slug) {
+  if (typeof slug !== 'string' || !slug.trim()) {
+    throw new Error('Persona slug is required.');
+  }
+
+  const normalized = slug.trim();
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(normalized)) {
+    throw new Error(
+      'Persona slug must use lowercase letters, numbers, and single dashes only.',
+    );
+  }
+
+  return normalized;
+}
+
+function ensureWritableOutputDir(outDir, force) {
+  if (!outDir) {
+    throw new Error('Output directory is required. Use --out <path>.');
+  }
+
+  if (!fs.existsSync(outDir)) {
+    ensureDir(outDir);
+    return;
+  }
+
+  const entries = fs.readdirSync(outDir);
+  if (entries.length > 0 && !force) {
+    throw new Error(`Output directory is not empty: ${outDir}. Use --force to overwrite.`);
+  }
+}
+
+function copyTemplateTree(sourceRoot, targetRoot, variables) {
+  const entries = fs.readdirSync(sourceRoot, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name === 'template.json') {
+      continue;
+    }
+
+    const sourcePath = path.join(sourceRoot, entry.name);
+    const targetPath = path.join(targetRoot, entry.name);
+
+    if (entry.isDirectory()) {
+      ensureDir(targetPath);
+      copyTemplateTree(sourcePath, targetPath, variables);
+      continue;
+    }
+
+    const content = fs.readFileSync(sourcePath, 'utf8');
+    fs.writeFileSync(targetPath, renderTemplateFile(content, variables), 'utf8');
+  }
+}
+
+export function scaffoldPersonaApp({
+  slug,
+  name,
+  description,
+  outDir,
+  templateVersion = DEFAULT_TEMPLATE_VERSION,
+  templateId = DEFAULT_TEMPLATE_ID,
+  force = false,
+}) {
+  const safeSlug = validatePersonaSlug(slug);
+  const safeName = typeof name === 'string' && name.trim() ? name.trim() : safeSlug;
+  const safeDescription = typeof description === 'string' ? description.trim() : '';
+  if (!safeDescription) {
+    throw new Error('Persona description is required. Use --description "<text>".');
+  }
+
+  const resolvedOutDir = path.resolve(outDir);
+  const templateRoot = resolveTemplateRoot(templateId, templateVersion);
+  const descriptor = readTemplateDescriptor(templateRoot);
+  const variables = {
+    __OOMI_PERSONA_SLUG__: safeSlug,
+    __OOMI_PERSONA_NAME__: safeName,
+    __OOMI_PERSONA_DESCRIPTION__: safeDescription,
+    __OOMI_TEMPLATE_VERSION__: templateVersion,
+  };
+
+  ensureWritableOutputDir(resolvedOutDir, force);
+  copyTemplateTree(templateRoot, resolvedOutDir, variables);
+
+  return {
+    ok: true,
+    templateId,
+    templateVersion,
+    slug: safeSlug,
+    outDir: resolvedOutDir,
+    startCommand: `cd ${resolvedOutDir} && npm install && npm run dev`,
+    healthPath: descriptor.healthPath,
+    editableZones: descriptor.editableZones,
+    defaultPort: descriptor.defaultPort,
+  };
+}

package/lib/template.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const DEFAULT_TEMPLATE_ID = 'persona-app';
+export const DEFAULT_TEMPLATE_VERSION = 'v1';
+
+const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const TEMPLATE_ROOT = path.join(PACKAGE_ROOT, 'templates');
+
+export function readTemplateDescriptor(templateRoot) {
+  const descriptorPath = path.join(templateRoot, 'template.json');
+  if (!fs.existsSync(descriptorPath)) {
+    throw new Error(`Template descriptor not found: ${descriptorPath}`);
+  }
+
+  return JSON.parse(fs.readFileSync(descriptorPath, 'utf8'));
+}
+
+export function resolveTemplateRoot(
+  templateId = DEFAULT_TEMPLATE_ID,
+  version = DEFAULT_TEMPLATE_VERSION,
+) {
+  const templateRoot = path.join(TEMPLATE_ROOT, templateId);
+  if (!fs.existsSync(templateRoot)) {
+    throw new Error(`Unknown template: ${templateId}`);
+  }
+
+  const descriptor = readTemplateDescriptor(templateRoot);
+  if (descriptor.version !== version) {
+    throw new Error(
+      `Unsupported template version "${version}" for ${templateId}. Available version: ${descriptor.version}`,
+    );
+  }
+
+  return templateRoot;
+}
+
+export function renderTemplateFile(content, variables) {
+  let rendered = content;
+  for (const [token, value] of Object.entries(variables)) {
+    rendered = rendered.split(token).join(String(value));
+  }
+  return rendered;
+}