import {  isAtomCommandInterrupted,  squashAtomCommandFailure,  type AtomCommandResult,} from "@t3tools/client-runtime/state/runtime";import {  ANTIGRAVITY_AUTH_METHODS,  type AntigravityAuthMethod,  type EnvironmentId,  type ProviderAuthState,  type ProviderInstanceId,  type ServerProvider,} from "@t3tools/contracts";import { useRef, useState } from "react"; import { writeTextToClipboard } from "../../hooks/useCopyToClipboard";import { ensureLocalApi } from "../../localApi";import { useEnvironmentQuery } from "../../state/query";import { serverEnvironment } from "../../state/server";import { useAtomCommand } from "../../state/use-atom-command";import { Button } from "../ui/button";import { Input } from "../ui/input"; interface ProviderSetupSectionProps {  readonly environmentId: EnvironmentId;  readonly environmentLabel: string;  readonly instanceId: ProviderInstanceId;  readonly provider: ServerProvider | undefined;  readonly binaryPath?: string | undefined;  readonly authMethod?: AntigravityAuthMethod | undefined;  readonly enabled: boolean;  readonly readOnly: boolean;  readonly onEnable: () => void;} const AUTH_PHASE_LABELS: Record<ProviderAuthState["phase"], string> = {  idle: "Sign in with your Google account.",  starting: "Starting Google sign-in.",  waiting: "Waiting for Google sign-in.",  verifying: "Checking Google sign-in and available models.",  succeeded: "Google sign-in complete.",  failed: "Google sign-in failed.",  cancelled: "Google sign-in cancelled.",}; /** API key methods skip the browser, so the phases read as a credential check. */const CREDENTIAL_PHASE_LABELS: Record<ProviderAuthState["phase"], string> = {  idle: "Connect with the credentials in the provider settings.",  starting: "Checking credentials.",  waiting: "Checking credentials.",  verifying: "Checking credentials and available models.",  succeeded: "Connected.",  failed: "Could not connect with the configured credentials.",  cancelled: "Connection cancelled.",}; /** Read the configured method from the instance config. Unknown values fall back to personal. */export function readAntigravityAuthMethod(config: unknown): AntigravityAuthMethod {  const value =    config !== null && typeof config === "object" && "authMethod" in config      ? config.authMethod      : undefined;  return (    ANTIGRAVITY_AUTH_METHODS.find((method) => method.value === value)?.value ?? "oauth-personal"  );} /** Setup state belongs to the selected environment and is never saved in client settings. */export function ProviderSetupSection(props: ProviderSetupSectionProps) {  return (    <section aria-label="Antigravity setup" className="grid gap-3 text-xs">      <p>Antigravity runs on {props.environmentLabel}.</p>      {!props.enabled ? (        <div className="flex flex-wrap items-center gap-2">          <span className="text-muted-foreground">Enable it to use it in threads.</span>          {!props.readOnly ? (            <Button size="xs" variant="outline" onClick={props.onEnable}>              Enable Antigravity            </Button>          ) : null}        </div>      ) : null}      {props.readOnly ? (        <p className="text-muted-foreground">This connection cannot change provider setup.</p>      ) : props.provider?.setup === undefined ? (        <p className="text-muted-foreground">          Update this environment to install Antigravity and sign in with Google here.        </p>      ) : (        <ProviderSetupActions          key={`${props.environmentId}:${props.instanceId}`}          environmentId={props.environmentId}          environmentLabel={props.environmentLabel}          instanceId={props.instanceId}          provider={props.provider}          binaryPath={props.binaryPath}          authMethod={props.authMethod ?? "oauth-personal"}          enabled={props.enabled}        />      )}    </section>  );} function ProviderSetupActions({  environmentId,  environmentLabel,  instanceId,  provider,  enabled,  binaryPath,  authMethod,}: Pick<  ProviderSetupSectionProps,  "environmentId" | "environmentLabel" | "instanceId" | "enabled" | "binaryPath"> & {  readonly provider: ServerProvider;  readonly authMethod: AntigravityAuthMethod;}) {  const target = { environmentId, input: { instanceId } };  const usesBrowser = authMethod === "oauth-personal" || authMethod === "oauth-business";  const phaseLabels = usesBrowser ? AUTH_PHASE_LABELS : CREDENTIAL_PHASE_LABELS;  const methodLabel =    ANTIGRAVITY_AUTH_METHODS.find((method) => method.value === authMethod)?.label ??    "Google account";  const authQuery = useEnvironmentQuery(serverEnvironment.providerAuthState(target));  const installQuery = useEnvironmentQuery(serverEnvironment.providerInstallState(target));  const auth = authQuery.data;  const installation = installQuery.data;  const commandOptions = { reportFailure: false, reportDefect: false };  const startAuth = useAtomCommand(serverEnvironment.startProviderAuth, commandOptions);  const completeAuth = useAtomCommand(serverEnvironment.completeProviderAuth, commandOptions);  const cancelAuth = useAtomCommand(serverEnvironment.cancelProviderAuth, commandOptions);  const logoutAuth = useAtomCommand(serverEnvironment.logoutProviderAuth, commandOptions);  const startInstall = useAtomCommand(serverEnvironment.startProviderInstall, commandOptions);  const cancelInstall = useAtomCommand(serverEnvironment.cancelProviderInstall, commandOptions);  const removeInstall = useAtomCommand(    serverEnvironment.removeProviderInstallation,    commandOptions,  );  const [pendingLabel, setPendingLabel] = useState<string | null>(null);  const pendingRef = useRef(false);  const [error, setError] = useState<string | null>(null);  const [callbackDraft, setCallbackDraft] = useState({ flowId: null as string | null, value: "" });  const [copiedFlowId, setCopiedFlowId] = useState<string | null>(null);  const callbackUrl = callbackDraft.flowId === auth?.flowId ? callbackDraft.value : "";  const authActive =    auth?.phase === "starting" || auth?.phase === "waiting" || auth?.phase === "verifying";  const installActive =    installation?.phase === "downloading" ||    installation?.phase === "extracting" ||    installation?.phase === "verifying";  const usesCustomBinary = Boolean(binaryPath?.trim());  const installed =    provider.installed || (!usesCustomBinary && installation?.installedVersion != null);  const authenticated = provider.auth.status === "authenticated";  const authStatusMessage =    auth === null      ? "Reading sign-in status."      : authActive || auth.phase === "failed" || auth.phase === "cancelled"        ? (auth.message ?? phaseLabels[auth.phase])        : authenticated          ? usesBrowser            ? "Signed in with Google."            : "Connected."          : auth.phase === "idle" && auth.message            ? auth.message            : phaseLabels.idle;  const authorizationUrl = auth?.phase === "waiting" ? auth.authorizationUrl : null;  const queryError = authQuery.error ?? installQuery.error;  const actionsDisabled = pendingLabel !== null || queryError !== null;  const installationStatusMessage =    installation?.phase === "downloading"      ? `Downloading ${(installation.downloadedBytes / 1_000_000).toFixed(1)} MB${installation.totalBytes === null ? "" : ` of ${(installation.totalBytes / 1_000_000).toFixed(1)} MB`}.`      : installation?.phase === "extracting"        ? "Extracting Antigravity."        : installation?.phase === "verifying"          ? "Checking the downloaded runtime."          : installed            ? "Antigravity is installed."            : usesCustomBinary              ? enabled                ? "The configured Antigravity runtime is unavailable."                : "The configured Antigravity runtime has not been checked."              : "Install the official Antigravity runtime before signing in.";   async function runCommand<A, E>(    label: string,    request: () => Promise<AtomCommandResult<A, E>>,  ): Promise<boolean> {    if (pendingRef.current) return false;    pendingRef.current = true;    setPendingLabel(label);    setError(null);    try {      const result = await request();      if (result._tag === "Failure") {        if (!isAtomCommandInterrupted(result)) {          const failure = squashAtomCommandFailure(result);          setError(failure instanceof Error ? failure.message : "Provider setup failed.");        }        return false;      }      return true;    } catch {      setError("Provider setup failed. Try again.");      return false;    } finally {      pendingRef.current = false;      setPendingLabel(null);    }  }   async function openSignInPage() {    if (!authorizationUrl) return;    try {      await ensureLocalApi().shell.openExternal(authorizationUrl);      setError(null);    } catch {      setError("Could not open the sign-in page. Copy the link and open it in your browser.");    }  }   async function copySignInLink() {    if (!authorizationUrl) return;    try {      await writeTextToClipboard(authorizationUrl, "Google sign-in link");      setCopiedFlowId(auth?.flowId ?? null);      setError(null);    } catch {      setError("Could not copy the sign-in link. Use Open sign-in page.");    }  }   async function submitCallback() {    const flowId = auth?.flowId;    if (!flowId || !callbackUrl.trim() || auth.phase !== "waiting") return;    const accepted = await runCommand("Checking redirect", () =>      completeAuth({ environmentId, input: { instanceId, flowId, callbackUrl } }),    );    if (accepted) {      setCallbackDraft({ flowId: null, value: "" });    }  }   async function signOut() {    const confirmed = await ensureLocalApi().dialogs.confirm(      `${usesBrowser ? "Sign out of Google" : "Disconnect"} for ${provider.displayName ?? "Antigravity"} on ${environmentLabel}? This stops its running threads. Thread history is kept.`,    );    if (confirmed) {      await runCommand("Signing out", () => logoutAuth(target));    }  }   async function removeRuntime() {    const confirmed = await ensureLocalApi().dialogs.confirm(      `Remove the downloaded Antigravity runtime from ${environmentLabel}? Google sign-in and thread history are kept.`,    );    if (confirmed) {      await runCommand("Removing runtime", () => removeInstall(target));    }  }   return (    <div className="grid gap-3">      <div className="grid gap-2">        <p className="font-medium">Runtime</p>        <p role="status" className="text-muted-foreground">          {installationStatusMessage}        </p>        {installation?.phase === "downloading" &&        installation.totalBytes !== null &&        installation.totalBytes > 0 ? (          <progress            aria-label="Antigravity download"            className="h-1 w-full accent-foreground"            value={installation.downloadedBytes}            max={installation.totalBytes}          />        ) : null}        {installation?.message && installation.message !== installationStatusMessage ? (          <p className="text-muted-foreground [overflow-wrap:anywhere]">{installation.message}</p>        ) : null}        {usesCustomBinary ? (          <p className="text-muted-foreground">            This instance uses the binary path below. Installing a managed runtime does not change            that path.          </p>        ) : null}        {!installed && !usesCustomBinary && !installActive && installation?.totalBytes ? (          <p className="text-muted-foreground">            Downloads {Math.ceil(installation.totalBytes / 1_000_000)} MB from Google.          </p>        ) : null}        {!installed && !provider.setup?.canInstall ? (          <p className="text-muted-foreground">            Automatic installation is unavailable here. Set an existing binary path below or use a            supported remote environment.          </p>        ) : null}        <div className="flex flex-wrap gap-2">          {installActive && installation.operationId ? (            <Button              size="xs"              variant="outline"              disabled={actionsDisabled}              onClick={() => {                const operationId = installation.operationId;                if (!operationId) return;                void runCommand("Cancelling installation", () =>                  cancelInstall({ environmentId, input: { instanceId, operationId } }),                );              }}            >              Cancel installation            </Button>          ) : !installActive && provider.setup?.canInstall ? (            <Button              size="xs"              variant="outline"              disabled={actionsDisabled || installation === null || authActive}              onClick={() => void runCommand("Starting installation", () => startInstall(target))}            >              {installation?.installedVersion                ? installation.version && installation.version !== installation.installedVersion                  ? "Update Antigravity"                  : "Reinstall Antigravity"                : installation?.phase === "failed" || installation?.phase === "cancelled"                  ? "Retry installation"                  : installed                    ? "Install managed runtime"                    : "Install Antigravity"}            </Button>          ) : null}          {installation?.canRemove && !installActive ? (            <Button              size="xs"              variant="ghost"              disabled={actionsDisabled || authActive}              onClick={() => void removeRuntime()}            >              Remove downloaded runtime            </Button>          ) : null}        </div>      </div>       <div className="grid gap-2 border-t border-border/60 pt-3">        <p className="font-medium">{methodLabel}</p>        <p role="status" className="text-muted-foreground [overflow-wrap:anywhere]">          {authStatusMessage}        </p>        {authorizationUrl ? (          <>            <div className="flex flex-wrap gap-2">              <Button size="xs" variant="outline" onClick={() => void openSignInPage()}>                Open sign-in page              </Button>              <Button size="xs" variant="ghost" onClick={() => void copySignInLink()}>                {copiedFlowId === auth?.flowId ? "Link copied" : "Copy sign-in link"}              </Button>            </div>            {auth?.expiresAt ? (              <p className="text-muted-foreground">                Link expires at{" "}                <time dateTime={auth.expiresAt}>                  {new Date(auth.expiresAt).toLocaleTimeString([], {                    hour: "numeric",                    minute: "2-digit",                  })}                </time>                .              </p>            ) : null}            <form              className="grid gap-2"              onSubmit={(event) => {                event.preventDefault();                void submitCallback();              }}            >              <label htmlFor={`provider-callback-${instanceId}`}>                If the final localhost page does not load, paste its full URL here.              </label>              <Input                id={`provider-callback-${instanceId}`}                size="sm"                type="url"                autoComplete="off"                spellCheck={false}                placeholder="http://127.0.0.1:..."                value={callbackUrl}                maxLength={16_384}                disabled={actionsDisabled}                onChange={(event) =>                  setCallbackDraft({ flowId: auth?.flowId ?? null, value: event.target.value })                }              />              <Button                size="xs"                variant="outline"                type="submit"                className="w-fit"                disabled={actionsDisabled || !callbackUrl.trim()}              >                Continue              </Button>            </form>          </>        ) : auth?.phase === "waiting" ? (          <p className="text-muted-foreground">            Sign-in is open in another client. Complete or cancel it there.          </p>        ) : null}        <div className="flex flex-wrap gap-2">          {authActive && auth?.flowId ? (            <Button              size="xs"              variant="ghost"              disabled={actionsDisabled}              onClick={() => {                const flowId = auth.flowId;                if (!flowId) return;                void runCommand("Cancelling sign-in", () =>                  cancelAuth({ environmentId, input: { instanceId, flowId } }),                );              }}            >              Cancel sign-in            </Button>          ) : !authActive && !authenticated && provider.setup?.canAuthenticate ? (            <Button              size="xs"              variant="outline"              disabled={actionsDisabled || !installed || auth === null || installActive}              onClick={() => void runCommand("Starting sign-in", () => startAuth(target))}            >              {usesBrowser                ? auth?.phase === "failed" || auth?.phase === "cancelled"                  ? "Retry Google sign-in"                  : "Sign in with Google"                : auth?.phase === "failed" || auth?.phase === "cancelled"                  ? "Retry connection"                  : "Connect"}            </Button>          ) : null}          {!authActive && provider.setup?.canAuthenticate ? (            <Button              size="xs"              variant={authenticated ? "outline" : "ghost"}              disabled={actionsDisabled || auth === null}              onClick={() => void signOut()}            >              {usesBrowser ? "Sign out of Google" : "Disconnect"}            </Button>          ) : null}        </div>      </div>       {pendingLabel ? <p role="status">{pendingLabel}.</p> : null}      {error || queryError ? (        <div className="grid gap-2">          <p role="alert" className="text-destructive [overflow-wrap:anywhere]">            {error ?? queryError}          </p>          {queryError ? (            <Button              size="xs"              variant="outline"              className="w-fit"              onClick={() => {                authQuery.refresh();                installQuery.refresh();              }}            >              Retry setup status            </Button>          ) : null}        </div>      ) : null}    </div>  );}