relmio 0.4.0 → 0.5.0

package/src/services/oauth.js

@@ -10,6 +10,10 @@ const LOGIN_URL_TIMEOUT_MS = 15_000;
 const LOGIN_TIMEOUT_MS = 300_000;
 const PROCESS_TIMEOUT_MS = LOGIN_TIMEOUT_MS + 15_000;
 const CREDENTIAL_POLL_INTERVAL_MS = 100;
+const PROCESS_TERMINATION_GRACE_MS = 1_000;
+const PROCESS_TERMINATION_FORCE_WAIT_MS = 1_000;
+const TERMINATION_UNCONFIRMED_MESSAGE =
+  "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.";
 const LOGIN_URL_PREFIX = "OpenAI OAuth login URL: ";
 const OPENAI_AUTH_ORIGIN = "https://auth.openai.com";
 const SUPPORTED_LOOPBACK_REDIRECT_HOSTNAMES = new Set([
@@ -206,6 +210,11 @@ export async function startOAuthLogin({
   spawnProcess = spawn,
   createPendingId = randomUUID,
   waitForCredentialPoll = wait,
+  killProcess = process.kill,
+  terminationGraceMs = PROCESS_TERMINATION_GRACE_MS,
+  terminationForceWaitMs = PROCESS_TERMINATION_FORCE_WAIT_MS,
+  createTimer = setTimeout,
+  clearTimer = clearTimeout,
 } = {}) {
   const npxInvocation = createNpxInvocation({ platform, env, execPath });
   const authPath = resolveAuthPath({ env, homeDirectory });
@@ -241,6 +250,7 @@ export async function startOAuthLogin({
         shell: false,
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: true,
+        ...(platform === "win32" ? {} : { detached: true }),
       },
     );
   } catch (error) {
@@ -251,6 +261,7 @@ export async function startOAuthLogin({
   }
   const loginOutput = { stdout: "", stderr: "" };
   let loginOutputBytes = 0;
+  let cancelAttempt = () => Promise.resolve();
   let resolveAuthorizationUrl;
   let rejectAuthorizationUrl;
   let authorizationUrlSettled = false;
@@ -280,7 +291,9 @@ export async function startOAuthLogin({
       settleAuthorizationUrl(
         new Error("The sign-in command returned too much output."),
       );
-      child.kill?.("SIGTERM");
+      void requestCancellation("The sign-in command returned too much output.").catch(
+        () => {},
+      );
       return;
     }
     loginOutput[stream] += output;
@@ -291,7 +304,7 @@ export async function startOAuthLogin({
       }
     } catch (error) {
       settleAuthorizationUrl(error);
-      child.kill?.("SIGTERM");
+      void requestCancellation(error.message).catch(() => {});
     }
   };
 
@@ -346,24 +359,273 @@ export async function startOAuthLogin({
     settleProcessClose(null, code);
   });
 
-  const loginUrlTimeout = setTimeout(() => {
-    settleAuthorizationUrl(
-      new Error("The sign-in command did not provide a fresh login link."),
+  const loginUrlTimeout = createTimer(() => {
+    const error = new Error(
+      "The sign-in command did not provide a fresh login link.",
     );
-    child.kill?.("SIGTERM");
+    settleAuthorizationUrl(error);
+    void requestCancellation(error.message).catch(() => {});
   }, LOGIN_URL_TIMEOUT_MS);
 
-  const savePendingCredential = async () => {
-    await readAuthContents({
-      authPath: pendingAuthPath,
-      fileSystem,
+  let keepPollingForCredential = true;
+  let cancellationRequested = false;
+  let rejectCancellation;
+  const cancellationPromise = new Promise((_, rejectPromise) => {
+    rejectCancellation = rejectPromise;
+  });
+  cancellationPromise.catch(() => {});
+
+  const promotionAuthPath = `${pendingAuthPath}.ready`;
+  let credentialPromotion;
+  let promotionPhase = "idle";
+  const promotionCancellationWaitMs =
+    terminationGraceMs + terminationForceWaitMs;
+  const createRetryBlockedError = () =>
+    Object.assign(new Error(TERMINATION_UNCONFIRMED_MESSAGE), {
+      retryBlocked: true,
     });
-    await fileSystem.chmod(pendingAuthPath, 0o600);
-    await fileSystem.copyFile(pendingAuthPath, authPath);
-    await fileSystem.chmod(authPath, 0o600);
+  const assertPromotionActive = () => {
+    if (cancellationRequested) {
+      throw new Error("ChatGPT sign-in did not finish. Start a fresh login.");
+    }
+  };
+  const savePendingCredential = () => {
+    if (credentialPromotion) {
+      return credentialPromotion;
+    }
+
+    credentialPromotion = (async () => {
+      promotionPhase = "staging";
+      try {
+        assertPromotionActive();
+        await readAuthContents({
+          authPath: pendingAuthPath,
+          fileSystem,
+        });
+        assertPromotionActive();
+        await fileSystem.chmod(pendingAuthPath, 0o600);
+        assertPromotionActive();
+        await fileSystem.copyFile(pendingAuthPath, promotionAuthPath);
+        assertPromotionActive();
+        await fileSystem.chmod(promotionAuthPath, 0o600);
+        assertPromotionActive();
+        promotionPhase = "committing";
+        await fileSystem.rename(promotionAuthPath, authPath);
+        promotionPhase = "committed";
+        await fileSystem.chmod(authPath, 0o600);
+      } catch (error) {
+        if (cancellationRequested && promotionPhase !== "committed") {
+          promotionPhase = "cancelled";
+        }
+        throw error;
+      }
+    })();
+    credentialPromotion.catch(() => {});
+    return credentialPromotion;
+  };
+
+  const waitForBoundedResult = (promise, milliseconds) =>
+    new Promise((resolvePromise) => {
+      let settled = false;
+      const timer = createTimer(() => {
+        if (!settled) {
+          settled = true;
+          resolvePromise(false);
+        }
+      }, milliseconds);
+      promise.then(
+        () => {
+          if (!settled) {
+            settled = true;
+            clearTimer(timer);
+            resolvePromise(true);
+          }
+        },
+        () => {
+          if (!settled) {
+            settled = true;
+            clearTimer(timer);
+            resolvePromise(true);
+          }
+        },
+      );
+    });
+
+  const waitForDuration = (milliseconds) =>
+    new Promise((resolvePromise) => {
+      createTimer(() => resolvePromise(true), milliseconds);
+    });
+
+  const waitForTaskkill = (taskkill, milliseconds) =>
+    new Promise((resolvePromise) => {
+      let settled = false;
+      const finish = (confirmed) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimer(timer);
+        resolvePromise(confirmed);
+      };
+      const timer = createTimer(() => finish(false), milliseconds);
+      taskkill?.once?.("error", () => finish(false));
+      taskkill?.once?.("close", (code) => finish(code === 0));
+      if (!taskkill?.once) {
+        finish(false);
+      }
+    });
+
+  let terminationPromise;
+  const terminateProcessTree = () => {
+    if (terminationPromise) {
+      return terminationPromise;
+    }
+
+    terminationPromise = (async () => {
+      const hasChildPid = Number.isSafeInteger(child.pid) && child.pid > 0;
+
+      if (platform === "win32" && hasChildPid) {
+        const runTaskkill = async (force, timeout) => {
+          try {
+            const taskkill = spawnProcess(
+              "taskkill",
+              ["/pid", String(child.pid), "/t", ...(force ? ["/f"] : [])],
+              {
+                shell: false,
+                stdio: "ignore",
+                windowsHide: true,
+              },
+            );
+            return await waitForTaskkill(taskkill, timeout);
+          } catch {
+            return false;
+          }
+        };
+        if (
+          (await runTaskkill(false, terminationGraceMs)) ||
+          (await runTaskkill(true, terminationForceWaitMs))
+        ) {
+          return;
+        }
+      } else if (hasChildPid) {
+        const processGroupIsGone = () => {
+          try {
+            killProcess(-child.pid, 0);
+            return false;
+          } catch (error) {
+            return error?.code === "ESRCH";
+          }
+        };
+        try {
+          killProcess(-child.pid, "SIGTERM");
+        } catch {
+          // The group may have already exited between launch and cancellation.
+        }
+        if (
+          processGroupIsGone() ||
+          ((await waitForDuration(terminationGraceMs)) && processGroupIsGone())
+        ) {
+          return;
+        }
+        try {
+          killProcess(-child.pid, "SIGKILL");
+        } catch {
+          // A final process-group check below determines whether it is gone.
+        }
+        if (
+          processGroupIsGone() ||
+          ((await waitForDuration(terminationForceWaitMs)) &&
+            processGroupIsGone())
+        ) {
+          return;
+        }
+      } else {
+        try {
+          child.kill?.("SIGTERM");
+        } catch {
+          // The process may have already exited before cancellation.
+        }
+        if (
+          processCloseSettled ||
+          (await waitForBoundedResult(
+            processClosePromise,
+            terminationGraceMs,
+          ))
+        ) {
+          return;
+        }
+        try {
+          child.kill?.("SIGKILL");
+        } catch {
+          // The direct child is only a last resort when no PID is available.
+        }
+        if (
+          processCloseSettled ||
+          (await waitForBoundedResult(
+            processClosePromise,
+            terminationForceWaitMs,
+          ))
+        ) {
+          return;
+        }
+      }
+
+      throw createRetryBlockedError();
+    })();
+    return terminationPromise;
+  };
+
+  cancelAttempt = async (
+    message = "ChatGPT sign-in stopped. Start a fresh login.",
+  ) => {
+    if (!cancellationRequested) {
+      cancellationRequested = true;
+      keepPollingForCredential = false;
+      rejectCancellation(new Error(message));
+    }
+    let promotionError;
+    try {
+      if (
+        credentialPromotion &&
+        !(await waitForBoundedResult(
+          credentialPromotion,
+          promotionCancellationWaitMs,
+        ))
+      ) {
+        promotionError = createRetryBlockedError();
+      }
+    } catch {
+      // Cancellation intentionally abandons a staged but unpromoted credential.
+    }
+    if (
+      promotionPhase === "committing" ||
+      promotionPhase === "committed"
+    ) {
+      promotionError = createRetryBlockedError();
+    }
+    let terminationError;
+    try {
+      await terminateProcessTree();
+    } catch (error) {
+      terminationError = error;
+    }
+    if (promotionError) {
+      throw promotionError;
+    }
+    if (terminationError) {
+      throw terminationError;
+    }
+  };
+
+  let cancellationResult;
+  const requestCancellation = (message) => {
+    if (!cancellationResult) {
+      cancellationResult = cancelAttempt(message);
+      cancellationResult.catch(() => {});
+    }
+    return cancellationResult;
   };
 
-  let keepPollingForCredential = true;
   const pendingCredentialPromise = (async () => {
     await authorizationUrlPromise;
     while (keepPollingForCredential) {
@@ -384,8 +646,9 @@ export async function startOAuthLogin({
 
   const completion = (async () => {
     let processTimeout;
+    let completedSuccessfully = false;
     try {
-      return await Promise.race([
+      const result = await Promise.race([
         pendingCredentialPromise,
         processClosePromise.then(async (code) => {
           if (code !== 0) {
@@ -396,27 +659,51 @@ export async function startOAuthLogin({
           await savePendingCredential();
           return { success: true };
         }),
+        cancellationPromise,
         new Promise((_, rejectPromise) => {
-          processTimeout = setTimeout(() => {
-            child.kill?.("SIGTERM");
-            rejectPromise(
-              new Error("The sign-in request expired. Start a fresh login."),
+          processTimeout = createTimer(() => {
+            const error = new Error(
+              "The sign-in request expired. Start a fresh login.",
             );
+            void requestCancellation(error.message).catch(() => {});
+            rejectPromise(error);
           }, PROCESS_TIMEOUT_MS);
         }),
       ]);
+      completedSuccessfully = result.success === true;
+      return result;
     } finally {
       keepPollingForCredential = false;
-      clearTimeout(processTimeout);
-      clearTimeout(loginUrlTimeout);
-      if (!processCloseSettled) {
-        child.kill?.("SIGTERM");
+      clearTimer(processTimeout);
+      clearTimer(loginUrlTimeout);
+      try {
+        await credentialPromotion;
+      } catch {
+        // A cancellation can abandon an attempt-local staged credential.
+      }
+      if (cancellationResult) {
+        try {
+          await cancellationResult;
+        } catch (error) {
+          if (error?.retryBlocked === true) {
+            throw error;
+          }
+        }
+      }
+      const committedBeforeFailure =
+        !completedSuccessfully && promotionPhase === "committed";
+      if (!completedSuccessfully || !processCloseSettled) {
+        await terminateProcessTree();
       }
       try {
         await fileSystem.rm(pendingAuthPath, { force: true });
+        await fileSystem.rm(promotionAuthPath, { force: true });
       } catch {
         // A failed cleanup must not hide the actionable sign-in result.
       }
+      if (committedBeforeFailure) {
+        throw createRetryBlockedError();
+      }
     }
   })();
   completion.catch(() => {});
@@ -435,22 +722,30 @@ export async function startOAuthLogin({
         },
       ),
     ]);
-    clearTimeout(loginUrlTimeout);
+    clearTimer(loginUrlTimeout);
     return {
       authorizationUrl,
       completion,
       cancel() {
-        child.kill?.("SIGTERM");
+        return requestCancellation();
       },
     };
   } catch (error) {
-    clearTimeout(loginUrlTimeout);
-    child.kill?.("SIGTERM");
+    clearTimer(loginUrlTimeout);
+    let retryBlocked = false;
     try {
-      await completion;
+      await requestCancellation(error.message);
+    } catch {
+      retryBlocked = true;
+    }
+    try {
+      await waitForBoundedResult(completion, promotionCancellationWaitMs);
     } catch {
       // Preserve the more specific authorization-link error.
     }
+    if (retryBlocked) {
+      error.retryBlocked = true;
+    }
     throw error;
   }
 }

package/src/ui/app.js

@@ -10,6 +10,10 @@ const state = {
   discovery: null,
   networks: null,
   installAttempted: false,
+  oauthAttemptId: null,
+  oauthRetryBlocked: false,
+  oauthLoginGeneration: 0,
+  oauthLoginWindow: null,
 };
 
 const element = (id) => document.getElementById(id);
@@ -245,16 +249,63 @@ function validateAuthorizationUrl(value) {
   return url.toString();
 }
 
-async function waitForOAuthCompletion() {
+function validateOAuthAttemptId(value) {
+  if (typeof value !== "string" || !/^[0-9a-f-]{8,128}$/iu.test(value)) {
+    throw new Error(
+      "The wizard returned an unexpected sign-in attempt. Start again.",
+    );
+  }
+  return value;
+}
+
+function setOAuthStopControlVisible(visible) {
+  const stopButton = element("stop-login-button");
+  stopButton.hidden = !visible;
+  stopButton.disabled = !visible;
+  stopButton.setAttribute("aria-busy", "false");
+}
+
+function blockOAuthRetry() {
+  state.oauthRetryBlocked = true;
+  state.oauthAttemptId = null;
+  state.oauthLoginWindow?.close?.();
+  state.oauthLoginWindow = null;
+  element("login-link").hidden = true;
+  element("login-link").removeAttribute("href");
+  setOAuthStopControlVisible(false);
+  const loginButton = element("login-button");
+  setBusy(loginButton, false);
+  loginButton.disabled = true;
+}
+
+async function waitForOAuthCompletion(expectedAttemptId) {
   for (let attempt = 0; attempt < 330; attempt += 1) {
     const result = await api("/api/oauth/status");
+    if (result.retryBlocked === true) {
+      const error = new Error(
+        result.error ??
+          "ChatGPT sign-in could not be stopped safely. Close the sign-in helper, then restart Relmio.",
+      );
+      error.oauthRetryBlocked = true;
+      throw error;
+    }
+    if (result.attemptId !== expectedAttemptId) {
+      throw new Error(
+        "The ChatGPT sign-in was replaced by a newer attempt. Start again.",
+      );
+    }
     if (result.status === "success") {
       return;
     }
     if (result.status === "error") {
-      throw new Error(
+      const error = new Error(
         result.error ?? "ChatGPT sign-in did not finish. Start again.",
       );
+      error.oauthRetryBlocked = result.retryBlocked === true;
+      throw error;
+    }
+    if (result.status === "cancelled") {
+      throw new Error("ChatGPT sign-in was stopped. Start again.");
     }
     await delay(attempt < 40 ? 250 : 1_000);
   }
@@ -324,7 +375,9 @@ async function api(path, { method = "GET", body } = {}) {
     );
   }
   if (!response.ok) {
-    throw new Error(result.error ?? "The request failed.");
+    const error = new Error(result.error ?? "The request failed.");
+    error.oauthRetryBlocked = result.retryBlocked === true;
+    throw error;
   }
   return result;
 }
@@ -450,13 +503,21 @@ async function discover() {
 
 element("login-button").addEventListener("click", async (event) => {
   const button = event.currentTarget;
+  if (state.oauthRetryBlocked) {
+    return;
+  }
   const loginLink = element("login-link");
+  const loginGeneration = state.oauthLoginGeneration + 1;
+  state.oauthLoginGeneration = loginGeneration;
+  state.oauthAttemptId = null;
   const loginWindow = window.open("about:blank", "_blank");
+  state.oauthLoginWindow = loginWindow;
   let loginWindowNavigated = false;
   prepareOAuthPopup(loginWindow);
   clearError();
   loginLink.hidden = true;
   loginLink.removeAttribute("href");
+  setOAuthStopControlVisible(false);
   setBusy(button, true, "Waiting for browser sign-in…");
   setMessage(
     "Preparing a fresh ChatGPT sign-in. The existing local credential will be replaced only after sign-in succeeds.",
@@ -467,6 +528,12 @@ element("login-button").addEventListener("click", async (event) => {
       body: {},
     });
     const authorizationUrl = validateAuthorizationUrl(result.authorizationUrl);
+    const attemptId = validateOAuthAttemptId(result.attemptId);
+    if (state.oauthLoginGeneration !== loginGeneration) {
+      return;
+    }
+    state.oauthAttemptId = attemptId;
+    setOAuthStopControlVisible(true);
     loginLink.href = authorizationUrl;
     loginLink.hidden = false;
     if (loginWindow) {
@@ -477,7 +544,10 @@ element("login-button").addEventListener("click", async (event) => {
     setMessage(
       "Complete the newly opened sign-in within five minutes. If no tab opened, use “Open fresh ChatGPT sign-in” below. If an OpenAI OAuth browser extension intercepts the callback, disable it temporarily and start again.",
     );
-    await waitForOAuthCompletion();
+    await waitForOAuthCompletion(attemptId);
+    if (state.oauthLoginGeneration !== loginGeneration) {
+      return;
+    }
     loginLink.hidden = true;
     loginLink.removeAttribute("href");
     await refreshAuthStatus({ fresh: true });
@@ -485,9 +555,66 @@ element("login-button").addEventListener("click", async (event) => {
     if (loginWindow && !loginWindowNavigated) {
       loginWindow.close();
     }
-    showError(error);
+    if (state.oauthLoginGeneration === loginGeneration) {
+      if (error.oauthRetryBlocked === true) {
+        blockOAuthRetry();
+      }
+      showError(error);
+    }
   } finally {
-    setBusy(button, false);
+    if (state.oauthLoginGeneration === loginGeneration) {
+      state.oauthAttemptId = null;
+      state.oauthLoginWindow = null;
+      setOAuthStopControlVisible(false);
+      setBusy(button, false);
+      if (state.oauthRetryBlocked) {
+        button.disabled = true;
+      }
+    }
+  }
+});
+
+element("stop-login-button").addEventListener("click", async (event) => {
+  const stopButton = event.currentTarget;
+  const attemptId = state.oauthAttemptId;
+  const loginGeneration = state.oauthLoginGeneration;
+  if (typeof attemptId !== "string") {
+    return;
+  }
+  clearError();
+  setBusy(stopButton, true, "Stopping sign-in…");
+  try {
+    const result = await api("/api/oauth/cancel", {
+      method: "POST",
+      body: { attemptId },
+    });
+    if (
+      state.oauthLoginGeneration !== loginGeneration ||
+      result.attemptId !== attemptId ||
+      result.status !== "cancelled"
+    ) {
+      return;
+    }
+    state.oauthLoginGeneration += 1;
+    state.oauthAttemptId = null;
+    state.oauthLoginWindow?.close?.();
+    state.oauthLoginWindow = null;
+    element("login-link").hidden = true;
+    element("login-link").removeAttribute("href");
+    setBusy(element("login-button"), false);
+    setOAuthStopControlVisible(false);
+    setMessage("ChatGPT sign-in stopped. You can start again.");
+  } catch (error) {
+    if (state.oauthLoginGeneration === loginGeneration) {
+      if (error.oauthRetryBlocked === true) {
+        state.oauthLoginGeneration += 1;
+        blockOAuthRetry();
+      }
+      showError(error);
+      if (!state.oauthRetryBlocked) {
+        setBusy(stopButton, false);
+      }
+    }
   }
 });
 

package/src/ui/index.html

@@ -203,6 +203,9 @@
           >
             Open fresh ChatGPT sign-in
           </a>
+          <button id="stop-login-button" class="button secondary" type="button" hidden>
+            Stop ChatGPT sign-in
+          </button>
           <button id="signin-next" class="button primary" type="button" disabled>
             Continue to VPS
           </button>