relmio 0.3.1 → 0.4.1

package/src/web/server.js

@@ -1,4 +1,4 @@
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { createServer } from "node:http";
 
@@ -18,10 +18,20 @@ import {
   validatePort,
 } from "../domain/validation.js";
 import { SIDECAR_HOSTNAME } from "../domain/templates.js";
+import { createLocalDeploymentPlan } from "../domain/local-endpoints.js";
+import {
+  attestLocalCodexInstallation,
+  getLocalDockerStatus,
+  installLocalEndpoint,
+  resolveLocalInstallRoot,
+  restartLocalCodex,
+} from "../services/local-installer.js";
+import { startCodexDeviceLogin } from "../services/codex-login.js";
 
 const MAX_BODY_BYTES = 32 * 1024;
 const RATE_LIMIT_WINDOW_MS = 15 * 60 * 1000;
 const RATE_LIMIT_MAX = 10;
+const OAUTH_SHUTDOWN_WAIT_MS = 2_000;
 
 const defaultServices = {
   getAuthStatus,
@@ -32,6 +42,12 @@ const defaultServices = {
   discoverN8n,
   discoverNetworks,
   installSidecar,
+  attestLocalCodexInstallation,
+  getLocalDockerStatus,
+  installLocalEndpoint,
+  resolveLocalInstallRoot,
+  restartLocalCodex,
+  startCodexDeviceLogin,
 };
 
 function setSecurityHeaders(response) {
@@ -95,6 +111,37 @@ function enforceRateLimit(state, key) {
   state.rateLimits.set(key, recent);
 }
 
+function waitForBoundedResult(promise, milliseconds) {
+  if (!promise) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        resolvePromise(false);
+      }
+    }, milliseconds);
+    Promise.resolve(promise).then(
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolvePromise(true);
+        }
+      },
+      () => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          resolvePromise(true);
+        }
+      },
+    );
+  });
+}
+
 function readJsonBody(request) {
   return new Promise((resolve, reject) => {
     const chunks = [];
@@ -168,21 +215,52 @@ function safeErrorMessage(error) {
   if (
     message.length > 240 ||
     /[\r\n]/u.test(message) ||
-    /(?:access|refresh)[_-]?token|private[_-]?key|\/Users\//iu.test(message)
+    /(?:access|refresh)[_-]?token|private[_-]?key|\bsk-[A-Za-z0-9_-]{8,}|\bBearer\s+\S+|\/(?:Users|home|private|tmp|var|opt|docker)\/|[A-Za-z]:\\/iu.test(
+      message,
+    )
   ) {
     return "The request could not be completed safely.";
   }
   return message;
 }
 
+async function cancelOAuthLogin(state, login) {
+  try {
+    await login.attempt.cancel();
+  } catch {
+    if (state.oauthLogin === login) {
+      login.status = "error";
+      login.retryBlocked = true;
+      login.error =
+        "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.";
+    }
+    state.oauthRetryBlocked = true;
+    state.oauthStartupError =
+      "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.";
+    throw Object.assign(
+      new Error(
+        "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.",
+      ),
+      { retryBlocked: true, statusCode: 409 },
+    );
+  }
+
+  if (state.oauthLogin === login && login.status === "pending") {
+    login.status = "cancelled";
+  }
+}
+
 async function loadDefaultUiFiles() {
   const files = await Promise.all([
     readFile(new URL("../ui/index.html", import.meta.url), "utf8"),
+    readFile(new URL("../ui/local.html", import.meta.url), "utf8"),
     readFile(new URL("../ui/app.js", import.meta.url), "utf8"),
+    readFile(new URL("../ui/local.js", import.meta.url), "utf8"),
     readFile(new URL("../ui/oauth-popup.js", import.meta.url), "utf8"),
     readFile(new URL("../ui/theme.js", import.meta.url), "utf8"),
     readFile(new URL("../ui/time.js", import.meta.url), "utf8"),
     readFile(new URL("../ui/styles.css", import.meta.url), "utf8"),
+    readFile(new URL("../ui/local.css", import.meta.url), "utf8"),
     readFile(new URL("../ui/icons/monitor.svg", import.meta.url), "utf8"),
     readFile(new URL("../ui/icons/sun.svg", import.meta.url), "utf8"),
     readFile(new URL("../ui/icons/moon.svg", import.meta.url), "utf8"),
@@ -190,17 +268,76 @@ async function loadDefaultUiFiles() {
 
   return {
     "/": files[0],
-    "/app.js": files[1],
-    "/oauth-popup.js": files[2],
-    "/theme.js": files[3],
-    "/time.js": files[4],
-    "/styles.css": files[5],
-    "/icons/monitor.svg": files[6],
-    "/icons/sun.svg": files[7],
-    "/icons/moon.svg": files[8],
+    "/local": files[1],
+    "/app.js": files[2],
+    "/local.js": files[3],
+    "/oauth-popup.js": files[4],
+    "/theme.js": files[5],
+    "/time.js": files[6],
+    "/styles.css": files[7],
+    "/local.css": files[8],
+    "/icons/monitor.svg": files[9],
+    "/icons/sun.svg": files[10],
+    "/icons/moon.svg": files[11],
+  };
+}
+
+function createSafeLocalPlan(plan) {
+  return {
+    target: plan.target,
+    label: plan.label,
+    bindHost: plan.bindHost,
+    port: plan.port,
+    endpoint: plan.endpoint,
+    protocol: plan.protocol,
+    upstreamAuth: plan.upstreamAuth,
+    allowedOrigins: [...plan.allowedOrigins],
+    browserClients: plan.browserClients,
+    experimental: plan.experimental,
+    managedPath: plan.managedPath,
+  };
+}
+
+function createSafeLocalInstallResult(result) {
+  return {
+    target: result.target,
+    endpoint: result.endpoint,
+    protocol: result.protocol,
+    clientCredential: result.clientCredential,
+    credentialShownOnce: result.credentialShownOnce === true,
+    models: Array.isArray(result.models) ? [...result.models] : [],
+    deploymentMode: result.deploymentMode,
+    experimental: result.experimental === true,
+    browserClients: result.browserClients === true,
   };
 }
 
+function createSafeDockerStatus(status, previewMode) {
+  if (previewMode || status?.dockerAvailable !== true) {
+    return {
+      dockerAvailable: false,
+      ...(previewMode ? { previewMode: true } : {}),
+      ...(!previewMode && status?.unsupportedPlatform === true
+        ? { unsupportedPlatform: true }
+        : {}),
+    };
+  }
+  return {
+    dockerAvailable: true,
+    dockerVersion: status.dockerVersion,
+    composeVersion: status.composeVersion,
+  };
+}
+
+function requireLiveLocalAction(state, action) {
+  if (state.previewMode) {
+    throw Object.assign(
+      new Error(`${action} is disabled in sanitized preview mode.`),
+      { statusCode: 403 },
+    );
+  }
+}
+
 async function handleApi(request, response, path, state) {
   requireApiToken(request, state);
   requireSameOrigin(request, state);
@@ -217,9 +354,42 @@ async function handleApi(request, response, path, state) {
 
   if (request.method === "GET" && path === "/api/oauth/status") {
     const login = state.oauthLogin;
+    sendJson(response, 200, {
+      status: login?.status ?? (state.oauthStartupError ? "error" : "idle"),
+      ...(login ? { attemptId: login.attemptId } : {}),
+      ...(login?.status === "error"
+        ? { error: login.error }
+        : state.oauthStartupError
+          ? { error: state.oauthStartupError }
+          : {}),
+      ...(state.oauthRetryBlocked || login?.retryBlocked === true
+        ? { retryBlocked: true }
+        : {}),
+    });
+    return;
+  }
+
+  if (request.method === "GET" && path === "/api/local/docker/status") {
+    const status = state.previewMode
+      ? null
+      : await state.services.getLocalDockerStatus();
+    sendJson(
+      response,
+      200,
+      createSafeDockerStatus(status, state.previewMode),
+    );
+    return;
+  }
+
+  if (
+    request.method === "GET" &&
+    path === "/api/local/codex/login/status"
+  ) {
+    const login = state.codexLogin;
     sendJson(response, 200, {
       status: login?.status ?? "idle",
       ...(login?.status === "error" ? { error: login.error } : {}),
+      ...(state.previewMode ? { previewMode: true } : {}),
     });
     return;
   }
@@ -238,42 +408,268 @@ async function handleApi(request, response, path, state) {
         { statusCode: 403 },
       );
     }
+    if (state.closing) {
+      throw Object.assign(new Error("The local wizard is closing."), {
+        statusCode: 409,
+      });
+    }
+    if (state.oauthRetryBlocked || state.oauthLogin?.retryBlocked === true) {
+      throw Object.assign(
+        new Error(
+          "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.",
+        ),
+        { retryBlocked: true, statusCode: 409 },
+      );
+    }
+    if (state.oauthLoginStartInFlight) {
+      throw Object.assign(
+        new Error("A ChatGPT sign-in start is already in progress."),
+        { statusCode: 409 },
+      );
+    }
     enforceRateLimit(state, path);
-    if (state.oauthLogin?.status === "pending") {
-      state.oauthLogin.attempt.cancel();
-      try {
-        await state.oauthLogin.attempt.completion;
-      } catch {
-        // Starting again intentionally replaces the previous local attempt.
+    state.oauthLoginStartInFlight = true;
+    state.oauthStartupError = null;
+    let startAttempted = false;
+    let startPromise;
+    try {
+      const previousLogin = state.oauthLogin;
+      if (previousLogin?.status === "pending") {
+        await cancelOAuthLogin(state, previousLogin);
+      }
+
+      if (state.closing) {
+        throw Object.assign(new Error("The local wizard is closing."), {
+          statusCode: 409,
+        });
+      }
+      if (
+        state.oauthLogin === previousLogin &&
+        previousLogin?.status !== "pending" &&
+        previousLogin?.retryBlocked !== true
+      ) {
+        state.oauthLogin = null;
       }
+      startAttempted = true;
+      startPromise = Promise.resolve(state.services.startOAuthLogin());
+      state.oauthLoginStartPromise = startPromise;
+      const attempt = await startPromise;
+      const login = {
+        attempt,
+        attemptId: randomUUID(),
+        error: null,
+        retryBlocked: false,
+        status: "pending",
+      };
+      state.oauthLogin = login;
+      attempt.completion.then(
+        () => {
+          if (
+            state.oauthLogin === login &&
+            login.status === "pending" &&
+            !state.closing
+          ) {
+            login.status = "success";
+          }
+        },
+        (error) => {
+          if (
+            state.oauthLogin === login &&
+            login.status === "pending" &&
+            !state.closing
+          ) {
+            login.status = "error";
+            login.error = safeErrorMessage(error);
+            if (error?.retryBlocked === true) {
+              login.retryBlocked = true;
+              state.oauthRetryBlocked = true;
+              state.oauthStartupError = login.error;
+            }
+          }
+        },
+      );
+      if (state.closing) {
+        try {
+          await cancelOAuthLogin(state, login);
+        } catch {
+          // The server is already closing and must not restart this helper.
+        }
+        throw Object.assign(new Error("The local wizard is closing."), {
+          statusCode: 409,
+        });
+      }
+      sendJson(response, 200, {
+        authorizationUrl: attempt.authorizationUrl,
+        attemptId: login.attemptId,
+      });
+      return;
+    } catch (error) {
+      const message = safeErrorMessage(error);
+      if (startAttempted) {
+        state.oauthStartupError = message;
+      }
+      if (error?.retryBlocked === true) {
+        state.oauthRetryBlocked = true;
+        state.oauthStartupError = message;
+      }
+      throw error;
+    } finally {
+      if (state.oauthLoginStartPromise === startPromise) {
+        state.oauthLoginStartPromise = null;
+      }
+      state.oauthLoginStartInFlight = false;
     }
+  }
 
-    const attempt = await state.services.startOAuthLogin();
-    const login = {
-      attempt,
-      error: null,
-      status: "pending",
-    };
-    state.oauthLogin = login;
-    attempt.completion.then(
-      () => {
-        if (state.oauthLogin === login) {
-          login.status = "success";
+  const body = await readJsonBody(request);
+
+  if (path === "/api/oauth/cancel") {
+    requireLiveLocalAction(state, "Live ChatGPT sign-in");
+    const login = state.oauthLogin;
+    if (
+      !login ||
+      login.status !== "pending" ||
+      !body ||
+      typeof body !== "object" ||
+      Array.isArray(body) ||
+      typeof body.attemptId !== "string" ||
+      body.attemptId !== login.attemptId
+    ) {
+      throw Object.assign(
+        new Error("The ChatGPT sign-in attempt has already changed. Start again."),
+        { statusCode: 409 },
+      );
+    }
+    await cancelOAuthLogin(state, login);
+    sendJson(response, 200, {
+      status: login.status,
+      attemptId: login.attemptId,
+    });
+    return;
+  }
+
+  if (path === "/api/local/plan") {
+    const plan = createLocalDeploymentPlan({
+      target: body.target,
+      port: body.port,
+      allowedOrigins: body.allowedOrigins,
+    });
+    const planId = randomUUID();
+    state.localPlan = { planId, plan };
+    sendJson(response, 200, {
+      planId,
+      plan: createSafeLocalPlan(plan),
+    });
+    return;
+  }
+
+  if (path === "/api/local/install") {
+    let acquiredInstallLock = false;
+    try {
+      requireLiveLocalAction(state, "Local endpoint installation");
+      enforceRateLimit(state, path);
+      if (state.localInstallInFlight) {
+        throw Object.assign(
+          new Error("A local endpoint installation is already in progress."),
+          { statusCode: 409 },
+        );
+      }
+      const pending = state.localPlan;
+      if (!pending || !tokenMatches(body.planId, pending.planId)) {
+        throw new Error(
+          "Review a fresh local endpoint plan before installing.",
+        );
+      }
+
+      state.localInstallInFlight = true;
+      acquiredInstallLock = true;
+      state.localPlan = null;
+      const result = await state.services.installLocalEndpoint({
+        plan: pending.plan,
+        apiKey: body.apiKey,
+        confirmed: body.confirmed,
+      });
+
+      sendJson(response, 200, createSafeLocalInstallResult(result));
+    } finally {
+      if (acquiredInstallLock) {
+        state.localInstallInFlight = false;
+      }
+      body.apiKey = undefined;
+    }
+    return;
+  }
+
+  if (path === "/api/local/codex/login") {
+    requireLiveLocalAction(state, "Local Codex sign-in");
+    enforceRateLimit(state, path);
+    if (state.codexLoginStartInFlight) {
+      throw Object.assign(
+        new Error("A local Codex sign-in start is already in progress."),
+        { statusCode: 409 },
+      );
+    }
+
+    state.codexLoginStartInFlight = true;
+    try {
+      const installDirectory = await state.services.resolveLocalInstallRoot({
+        target: "codex-chatgpt",
+      });
+      const { dockerHost, projectName } =
+        await state.services.attestLocalCodexInstallation({
+          installDirectory,
+        });
+
+      const previous = state.codexLogin;
+      if (previous?.status === "pending") {
+        state.codexLogin = null;
+        previous.cancel();
+        try {
+          await previous.completion;
+        } catch {
+          // A fresh attempt intentionally supersedes the old device-code login.
         }
-      },
-      (error) => {
-        if (state.oauthLogin === login) {
-          login.status = "error";
-          login.error = safeErrorMessage(error);
+      }
+
+      const attempt = await state.services.startCodexDeviceLogin({
+        installDirectory,
+        dockerHost,
+        projectName,
+      });
+      const login = {
+        cancel: attempt.cancel,
+        completion: attempt.completion,
+        error: null,
+        status: "pending",
+      };
+      state.codexLogin = login;
+      void (async () => {
+        try {
+          await login.completion;
+          if (state.codexLogin !== login || state.closing) {
+            return;
+          }
+          await state.services.restartLocalCodex({ installDirectory });
+          if (state.codexLogin === login && !state.closing) {
+            login.status = "success";
+          }
+        } catch (error) {
+          if (state.codexLogin === login && !state.closing) {
+            login.status = "error";
+            login.error = safeErrorMessage(error);
+          }
         }
-      },
-    );
-    sendJson(response, 200, { authorizationUrl: attempt.authorizationUrl });
+      })();
+      sendJson(response, 200, {
+        verificationUrl: attempt.verificationUrl,
+        userCode: attempt.userCode,
+      });
+    } finally {
+      state.codexLoginStartInFlight = false;
+    }
     return;
   }
 
-  const body = await readJsonBody(request);
-
   if (path === "/api/ssh/fingerprint") {
     enforceRateLimit(state, path);
     const host = validateHostname(body.host);
@@ -431,7 +827,7 @@ function createRequestHandler(state) {
           ? "text/javascript; charset=utf-8"
           : path.endsWith(".svg")
             ? "image/svg+xml; charset=utf-8"
-            : path === "/styles.css"
+            : path.endsWith(".css")
               ? "text/css; charset=utf-8"
               : "text/html; charset=utf-8";
       const contents = state.uiFiles[path];
@@ -444,6 +840,7 @@ function createRequestHandler(state) {
       if (!response.headersSent) {
         sendJson(response, error.statusCode ?? 400, {
           error: safeErrorMessage(error),
+          ...(error.retryBlocked === true ? { retryBlocked: true } : {}),
         });
       } else {
         response.end();
@@ -458,6 +855,7 @@ export async function startWizardServer({
   uiFiles,
   port = 0,
   previewMode = false,
+  oauthShutdownWaitMs = OAUTH_SHUTDOWN_WAIT_MS,
 } = {}) {
   if (typeof sessionToken !== "string" || sessionToken.length < 32) {
     throw new TypeError("A strong wizard session token is required.");
@@ -465,7 +863,7 @@ export async function startWizardServer({
 
   const state = {
     sessionToken,
-    services,
+    services: { ...defaultServices, ...services },
     uiFiles: uiFiles ?? (await loadDefaultUiFiles()),
     origin: "http://127.0.0.1",
     connection: null,
@@ -473,8 +871,18 @@ export async function startWizardServer({
     discovery: null,
     networksByContainer: new Map(),
     oauthLogin: null,
+    oauthRetryBlocked: false,
+    oauthStartupError: null,
+    oauthLoginStartInFlight: false,
+    oauthLoginStartPromise: null,
+    localPlan: null,
+    localInstallInFlight: false,
+    codexLogin: null,
+    codexLoginStartInFlight: false,
     rateLimits: new Map(),
     previewMode: previewMode === true,
+    oauthShutdownWaitMs,
+    closing: false,
   };
   const server = createServer(createRequestHandler(state));
   server.requestTimeout = 330_000;
@@ -492,10 +900,27 @@ export async function startWizardServer({
   return {
     origin: state.origin,
     async close() {
-      state.oauthLogin?.attempt.cancel();
+      state.closing = true;
+      await waitForBoundedResult(
+        state.oauthLoginStartPromise,
+        state.oauthShutdownWaitMs,
+      );
+      if (state.oauthLogin?.status === "pending") {
+        try {
+          await cancelOAuthLogin(state, state.oauthLogin);
+        } catch {
+          // The bounded OAuth cancellation result must not prevent server shutdown.
+        }
+      }
+      const codexLogin = state.codexLogin;
+      state.codexLogin = null;
+      codexLogin?.cancel();
       state.connection?.close();
       state.connection = null;
-      await new Promise((resolve) => server.close(resolve));
+      await waitForBoundedResult(
+        new Promise((resolve) => server.close(resolve)),
+        state.oauthShutdownWaitMs,
+      );
     },
   };
 }