sailfork / t3code-github / packages/ shared/ src/ codexAuthHandoff.ts

import { EnvironmentId, ProviderInstanceId } from "@t3tools/contracts";
import * as Schema from "effect/Schema";
import { providerAuthReturnUrl } from "./providerAuthReturnUrl.ts";

export const CodexAuthHandoff = Schema.Struct({
  authorizationUrl: Schema.String.check(Schema.isMaxLength(16_384)),
  returnUrl: Schema.String.check(Schema.isMaxLength(4_096)),
  environmentId: EnvironmentId,
  instanceId: ProviderInstanceId,
  flowId: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
});
export type CodexAuthHandoff = typeof CodexAuthHandoff.Type;
const Delivery = Schema.Struct({
  environmentId: EnvironmentId,
  instanceId: ProviderInstanceId,
  flowId: Schema.NonEmptyString.check(Schema.isMaxLength(128)),
  callbackUrl: Schema.String.check(Schema.isMaxLength(16_384)),
  returnHash: Schema.String.check(Schema.isMaxLength(128)),
});

const encodeHandoff = Schema.encodeSync(Schema.fromJsonString(CodexAuthHandoff));
const decodeHandoff = Schema.decodeUnknownSync(Schema.fromJsonString(CodexAuthHandoff));
const encodeDelivery = Schema.encodeSync(Schema.fromJsonString(Delivery));
const decodeDelivery = Schema.decodeUnknownSync(Schema.fromJsonString(Delivery));

export function codexAuthorizationRequest(value: string) {
  const url = new URL(value);
  if (
    value.length > 16_384 ||
    url.origin !== "https://auth.openai.com" ||
    url.pathname !== "/api/accounts/authorize" ||
    url.username ||
    url.password ||
    url.hash
  )
    throw new Error("Invalid ChatGPT sign-in request.");
  const single = (key: string) => {
    const values = url.searchParams.getAll(key);
    if (values.length !== 1 || !values[0]) throw new Error("Invalid ChatGPT sign-in request.");
    return values[0];
  };
  const redirectUri = single("redirect_uri");
  const redirect = new URL(redirectUri);
  const state = single("state");
  if (
    !/^http:\/\/127\.0\.0\.1:[1-9]\d{0,4}\/auth\/callback$/u.test(redirectUri) ||
    Number(redirect.port) > 65_535 ||
    !/^[\w-]{16,128}$/u.test(state) ||
    single("response_type") !== "code" ||
    single("code_challenge_method") !== "S256" ||
    !/^[\w-]{43}$/u.test(single("code_challenge")) ||
    !/^(dynamic_agent_client|oaiapp_[\w-]+)$/u.test(single("client_id"))
  )
    throw new Error("Invalid ChatGPT sign-in request.");
  return { authorizationUrl: url.toString(), redirectUri, state };
}

export function codexCallbackUrl(value: string, redirectUri: string, state: string) {
  const expected = new URL(redirectUri);
  const pasted = value.trimStart();
  // Browsers can hide `http://` in the address bar, so a pasted callback may lack it.
  const callback = new URL(
    /^[a-z][a-z\d+.-]*:\/\//iu.test(pasted) ? pasted : `${expected.protocol}//${pasted}`,
  );
  const states = callback.searchParams.getAll("state");
  const codes = callback.searchParams.getAll("code");
  const errors = callback.searchParams.getAll("error");
  const clients = callback.searchParams.getAll("client_id");
  if (
    value.length > 16_384 ||
    callback.origin !== expected.origin ||
    callback.pathname !== expected.pathname ||
    callback.username ||
    callback.password ||
    callback.hash ||
    states.length !== 1 ||
    states[0] !== state ||
    clients.length > 1 ||
    (clients.length === 1 && !/^oaiapp_[\w-]+$/u.test(clients[0]!)) ||
    !(
      (codes.length === 1 && Boolean(codes[0]) && errors.length === 0) ||
      (errors.length === 1 && Boolean(errors[0]) && codes.length === 0)
    )
  )
    throw new Error("This redirect URL does not belong to the current sign-in.");
  return callback;
}

export function codexAuthHandoffUrl(input: CodexAuthHandoff, development = false) {
  const url = new URL(`${development ? "t3code-dev" : "t3code"}://auth/codex`);
  url.searchParams.set("request", encodeHandoff(input));
  return url.toString();
}

export function readCodexAuthHandoff(value: string, development: boolean) {
  try {
    const url = new URL(value);
    if (
      value.length > 32_768 ||
      url.protocol !== (development ? "t3code-dev:" : "t3code:") ||
      url.host !== "auth" ||
      url.pathname !== "/codex" ||
      url.username ||
      url.password ||
      url.hash ||
      url.searchParams.getAll("request").length !== 1
    )
      return undefined;
    const input = decodeHandoff(url.searchParams.get("request"));
    codexAuthorizationRequest(input.authorizationUrl);
    if (!providerAuthReturnUrl(input.returnUrl)) return undefined;
    return input;
  } catch {
    return undefined;
  }
}

/** Codes travel in a fragment, never in hosted web requests or a token store on the helper. */
export function codexAuthDeliveryUrl(input: CodexAuthHandoff, callbackUrl: string) {
  const request = codexAuthorizationRequest(input.authorizationUrl);
  codexCallbackUrl(callbackUrl, request.redirectUri, request.state);
  const destination = providerAuthReturnUrl(input.returnUrl);
  if (!destination) throw new Error("Invalid T3 Code return address.");
  const url = new URL(destination);
  const delivery = {
    environmentId: input.environmentId,
    instanceId: input.instanceId,
    flowId: input.flowId,
    callbackUrl,
    returnHash: url.hash,
  };
  url.hash = `codex-auth=${encodeURIComponent(encodeDelivery(delivery))}`;
  return url.toString();
}

export function readCodexAuthDelivery(value: string) {
  try {
    const url = new URL(value);
    if (!url.hash.startsWith("#codex-auth=") || url.hash.length > 32_768) return undefined;
    const input = decodeDelivery(decodeURIComponent(url.hash.slice("#codex-auth=".length)));
    const destination = providerAuthReturnUrl(value);
    if (!destination) return undefined;
    const returnUrl = new URL(destination);
    returnUrl.hash = input.returnHash;
    const sanitized = providerAuthReturnUrl(returnUrl.toString());
    if (!sanitized) return undefined;
    return { ...input, returnUrl: sanitized };
  } catch {
    return undefined;
  }
}