relmio 0.6.0 → 0.8.0

package/src/web/server.js

@@ -34,6 +34,7 @@ import {
   prepareLocalClientCredentialRotation,
 } from "../services/local-installer.js";
 import { startCodexDeviceLogin } from "../services/codex-login.js";
+import { createLocalChatTestService } from "../services/local-chat-test.js";
 
 const MAX_BODY_BYTES = 32 * 1024;
 const RATE_LIMIT_WINDOW_MS = 15 * 60 * 1000;
@@ -87,6 +88,7 @@ const defaultServices = {
   resolveLocalInstallRoot,
   restartLocalCodex,
   startCodexDeviceLogin,
+  createLocalChatTestService,
 };
 
 function setSecurityHeaders(response) {
@@ -113,6 +115,64 @@ function sendJson(response, statusCode, body) {
   response.end(contents);
 }
 
+function requestAcceptsEventStream(request) {
+  const value = request.headers.accept;
+  return (
+    typeof value === "string" &&
+    value
+      .split(",")
+      .some((entry) => entry.trim().split(";", 1)[0] === "text/event-stream")
+  );
+}
+
+function startLocalChatTestStream(response) {
+  let ended = false;
+  response.writeHead(200, {
+    "Content-Encoding": "none",
+    "Content-Type": "text/event-stream; charset=utf-8",
+    "X-Accel-Buffering": "no",
+    "X-Relmio-Stream": "v1",
+  });
+  const send = (event, data) => {
+    if (ended || response.writableEnded || response.destroyed) return;
+    response.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`);
+  };
+  const keepalive = setInterval(() => {
+    if (!ended && !response.writableEnded && !response.destroyed) {
+      response.write(": keepalive\n\n");
+    }
+  }, 15_000);
+  keepalive.unref?.();
+  send("start", { requestId: randomUUID() });
+  return {
+    send(event, data) {
+      if (event === "progress" || event === "delta") send(event, data);
+    },
+    complete(result) {
+      if (ended) return;
+      send("terminal", {
+        outcome: "completed",
+        conversationId: result.conversationId,
+      });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    fail(code = "upstream_failed") {
+      if (ended) return;
+      send("error", { code, retryable: true });
+      send("terminal", { outcome: "failed" });
+      ended = true;
+      clearInterval(keepalive);
+      response.end();
+    },
+    dispose() {
+      ended = true;
+      clearInterval(keepalive);
+    },
+  };
+}
+
 function tokenMatches(actual, expected) {
   if (typeof actual !== "string") {
     return false;
@@ -373,6 +433,67 @@ function createSafeProjectMeta(result) {
   };
 }
 
+function createSafeLocalChatTestKey(result) {
+  if (
+    !result ||
+    typeof result !== "object" ||
+    Array.isArray(result) ||
+    typeof result.keyId !== "string" ||
+    result.keyId.length === 0 ||
+    result.keyId.length > 128 ||
+    !result.publicKeyJwk ||
+    typeof result.publicKeyJwk !== "object" ||
+    Array.isArray(result.publicKeyJwk) ||
+    result.publicKeyJwk.kty !== "RSA" ||
+    typeof result.publicKeyJwk.n !== "string" ||
+    typeof result.publicKeyJwk.e !== "string" ||
+    result.publicKeyJwk.n.length === 0 ||
+    result.publicKeyJwk.n.length > 1_024 ||
+    result.publicKeyJwk.e.length === 0 ||
+    result.publicKeyJwk.e.length > 32 ||
+    result.algorithm !== "RSA-OAEP-256" ||
+    typeof result.expiresAt !== "string" ||
+    Number.isNaN(Date.parse(result.expiresAt))
+  ) {
+    throw Object.assign(new Error("The local tester could not start safely."), {
+      statusCode: 502,
+    });
+  }
+  return {
+    keyId: result.keyId,
+    publicKeyJwk: {
+      kty: "RSA",
+      n: result.publicKeyJwk.n,
+      e: result.publicKeyJwk.e,
+    },
+    algorithm: result.algorithm,
+    expiresAt: result.expiresAt,
+  };
+}
+
+function createSafeLocalChatTestResponse(result) {
+  if (
+    !result ||
+    typeof result !== "object" ||
+    Array.isArray(result) ||
+    typeof result.conversationId !== "string" ||
+    result.conversationId.length === 0 ||
+    result.conversationId.length > 160 ||
+    typeof result.output !== "string" ||
+    result.output.length === 0 ||
+    result.output.length > 12 * 1_024
+  ) {
+    throw Object.assign(
+      new Error("The local adapter returned an unexpected response."),
+      { statusCode: 502 },
+    );
+  }
+  return {
+    conversationId: result.conversationId,
+    output: result.output,
+  };
+}
+
 function getPendingLocalCredentialRotation(state) {
   if (
     state.localCredentialRotationPending &&
@@ -409,6 +530,15 @@ function requireLiveLocalAction(state, action) {
   }
 }
 
+function requireReadyLocalChatTester(state) {
+  if (state.localInstalledTarget !== "codex-chat") {
+    throw Object.assign(
+      new Error("Install the Codex Chat Adapter before starting its local tester."),
+      { statusCode: 409 },
+    );
+  }
+}
+
 async function handleApi(request, response, path, state) {
   requireApiToken(request, state);
   requireSameOrigin(request, state);
@@ -603,6 +733,68 @@ async function handleApi(request, response, path, state) {
 
   const body = await readJsonBody(request);
 
+  if (path === "/api/local/chat-test/key") {
+    requireLiveLocalAction(state, "Local chat testing");
+    requireReadyLocalChatTester(state);
+    enforceRateLimit(state, path);
+    sendJson(
+      response,
+      200,
+      createSafeLocalChatTestKey(await state.localChatTest.issueKey()),
+    );
+    return;
+  }
+
+  if (path === "/api/local/chat-test/message") {
+    requireLiveLocalAction(state, "Local chat testing");
+    requireReadyLocalChatTester(state);
+    enforceRateLimit(state, path);
+    const wantsStream = requestAcceptsEventStream(request);
+    const stream = wantsStream ? startLocalChatTestStream(response) : null;
+    const requestController = wantsStream ? new AbortController() : null;
+    const abortOnClose = () => {
+      if (!response.writableEnded) requestController?.abort();
+    };
+    response.once("close", abortOnClose);
+    try {
+      const result = createSafeLocalChatTestResponse(
+        await state.localChatTest.message(body, {
+          ...(stream
+            ? {
+                onEvent: (event, data) => stream.send(event, data),
+                signal: requestController.signal,
+              }
+            : {}),
+        }),
+      );
+      if (stream) stream.complete(result);
+      else sendJson(response, 200, result);
+    } catch (error) {
+      if (stream) {
+        stream.fail(error?.statusCode === 504 ? "timeout" : "upstream_failed");
+      } else {
+        throw error;
+      }
+    } finally {
+      response.off("close", abortOnClose);
+      stream?.dispose();
+      if (body && typeof body === "object") {
+        body.encryptedCredential = undefined;
+        body.input = undefined;
+      }
+    }
+    return;
+  }
+
+  if (path === "/api/local/chat-test/reset") {
+    requireLiveLocalAction(state, "Local chat testing");
+    requireReadyLocalChatTester(state);
+    enforceRateLimit(state, path);
+    await state.localChatTest.reset(body);
+    sendJson(response, 200, { forgotten: true });
+    return;
+  }
+
   if (path === "/api/oauth/cancel") {
     requireLiveLocalAction(state, "Live ChatGPT sign-in");
     const login = state.oauthLogin;
@@ -670,12 +862,14 @@ async function handleApi(request, response, path, state) {
       state.localInstallInFlight = true;
       acquiredInstallLock = true;
       state.localPlan = null;
+      state.localInstalledTarget = null;
       const result = await state.services.installLocalEndpoint({
         plan: pending.plan,
         apiKey: body.apiKey,
         confirmed: body.confirmed,
       });
 
+      state.localInstalledTarget = pending.plan.target;
       sendJson(response, 200, createSafeLocalInstallResult(result));
     } finally {
       if (acquiredInstallLock) {
@@ -707,6 +901,7 @@ async function handleApi(request, response, path, state) {
 
     state.localCredentialRotationInFlight = true;
     try {
+      state.localChatTest.resetAll?.();
       const result = await state.services.prepareLocalClientCredentialRotation({
         target: validateLocalTarget(body.target),
       });
@@ -749,6 +944,7 @@ async function handleApi(request, response, path, state) {
     state.localCredentialRotationPending = null;
     state.localCredentialRotationInFlight = true;
     try {
+      state.localChatTest.resetAll?.();
       const result = await state.services.activateLocalClientCredentialRotation({
         target: pending.target,
         clientCredential: body.clientCredential,
@@ -1079,9 +1275,13 @@ export async function startWizardServer({
     throw new TypeError("A strong wizard session token is required.");
   }
 
+  const resolvedServices = { ...defaultServices, ...services };
   const state = {
     sessionToken,
-    services: { ...defaultServices, ...services },
+    services: resolvedServices,
+    localChatTest:
+      resolvedServices.localChatTest ??
+      resolvedServices.createLocalChatTestService(),
     uiFiles: uiFiles ?? (await loadDefaultUiFiles()),
     origin: "http://127.0.0.1",
     connection: null,
@@ -1094,6 +1294,7 @@ export async function startWizardServer({
     oauthLoginStartInFlight: false,
     oauthLoginStartPromise: null,
     localPlan: null,
+    localInstalledTarget: null,
     localInstallInFlight: false,
     localCredentialRotationInFlight: false,
     localCredentialRotationPending: null,
@@ -1122,6 +1323,7 @@ export async function startWizardServer({
     origin: state.origin,
     async close() {
       state.closing = true;
+      state.localChatTest.dispose?.();
       await waitForBoundedResult(
         state.oauthLoginStartPromise,
         state.oauthShutdownWaitMs,