oomi-ai 0.2.29 → 0.2.38

package/lib/personaApiClient.js

@@ -1,253 +1,304 @@
-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 {
-    createManagedPersona({
-      slug,
-      name,
-      description,
-      templateType = 'persona-app',
-      promptTemplateVersion = 'v1',
-    }) {
-      const safeName = trimString(name);
-      if (!safeName) {
-        throw new Error('Persona name is required.');
-      }
-
-      const body = withDevice({
-        name: safeName,
-        description: trimString(description) || safeName,
-        templateType: trimString(templateType) || 'persona-app',
-        promptTemplateVersion: trimString(promptTemplateVersion) || 'v1',
-      });
-      const safeSlug = trimString(slug);
-      if (safeSlug) {
-        body.slug = safeSlug;
-      }
-
-      return postJson({
-        fetchImpl,
-        backendUrl: resolvedBackendUrl,
-        deviceToken: resolvedDeviceToken,
-        path: '/v1/personas/managed_create',
-        body,
-      });
-    },
-
-    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,
-        }),
-      });
-    },
-  };
-}
+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 getJson({ fetchImpl, backendUrl, path, deviceToken }) {
+  const baseUrl = stripTrailingSlash(backendUrl);
+  if (!baseUrl) {
+    throw new Error('Backend URL is required.');
+  }
+
+  const headers = {};
+  const token = trimString(deviceToken);
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+
+  const response = await fetchImpl(`${baseUrl}${path}`, {
+    method: 'GET',
+    headers,
+  });
+
+  const payload = await readJsonResponse(response);
+  if (!response.ok) {
+    const errorMessage =
+      trimString(payload?.error) ||
+      trimString(payload?.message) ||
+      `Persona API request failed (${response.status})`;
+    const error = new Error(errorMessage);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+
+  return payload;
+}
+
+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})`;
+    const error = new Error(errorMessage);
+    error.status = response.status;
+    error.payload = payload;
+    throw error;
+  }
+
+  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 {
+    getPersona({
+      slug,
+    }) {
+      const safeSlug = trimString(slug);
+      if (!safeSlug) {
+        throw new Error('Persona slug is required.');
+      }
+
+      return getJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: `/v1/personas/${encodeURIComponent(safeSlug)}`,
+      });
+    },
+
+    createManagedPersona({
+      slug,
+      name,
+      description,
+      templateType = 'persona-app',
+      promptTemplateVersion = 'v1',
+    }) {
+      const safeName = trimString(name);
+      if (!safeName) {
+        throw new Error('Persona name is required.');
+      }
+
+      const body = withDevice({
+        name: safeName,
+        description: trimString(description) || safeName,
+        templateType: trimString(templateType) || 'persona-app',
+        promptTemplateVersion: trimString(promptTemplateVersion) || 'v1',
+      });
+      const safeSlug = trimString(slug);
+      if (safeSlug) {
+        body.slug = safeSlug;
+      }
+
+      return postJson({
+        fetchImpl,
+        backendUrl: resolvedBackendUrl,
+        deviceToken: resolvedDeviceToken,
+        path: '/v1/personas/managed_create',
+        body,
+      });
+    },
+
+    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

@@ -17,6 +17,7 @@ export async function executePersonaJob({
   startWorkspace = async () => ({ pid: null, logFilePath: '' }),
   waitForRuntime = async () => {},
   registerRuntime = async () => {},
+  destroyWorkspace = async () => ({ deleted: false }),
   onJobStart = async () => {},
   onJobSuccess = async () => {},
   onJobFailure = async () => {},
@@ -27,17 +28,40 @@ export async function executePersonaJob({
     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';
-
+  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(),

package/lib/personaPortAllocator.js

@@ -0,0 +1,36 @@
+import net from 'node:net';
+
+function listenOnce({ port, host }) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+
+    server.once('error', () => {
+      resolve(false);
+    });
+
+    server.listen({ port, host }, () => {
+      server.close(() => resolve(true));
+    });
+  });
+}
+
+export async function findAvailablePort({
+  preferredPort,
+  host = '127.0.0.1',
+  basePort = 4789,
+  maxAttempts = 50,
+} = {}) {
+  const preferred = Number(preferredPort);
+  const startPort = Number.isFinite(preferred) && preferred > 0 ? Math.floor(preferred) : Math.floor(basePort);
+
+  for (let offset = 0; offset < maxAttempts; offset += 1) {
+    const port = startPort + offset;
+    const available = await listenOnce({ port, host });
+    if (available) {
+      return port;
+    }
+  }
+
+  throw new Error(`Unable to find an available port starting at ${startPort}.`);
+}