mirror of
https://github.com/outline/outline.git
synced 2026-11-22 05:51:43 +03:00
* feat: Support OAuth Client ID Metadata Documents for MCP clients MCP clients can send an https URL as their client_id. The server fetches the metadata document at that URL and caches one team-less client row per URL, so MCP works on the root domain without dynamic registration. Closes #14010 * fix: Address review findings for client ID metadata documents - Only count unexpired tokens when cleaning up metadata document clients - Reject backslashes, whitespace and trailing host dots in client_id URLs - Strip trailing dots before installation host comparisons - Type clientSecret as nullable * fix: Keep OAuth clients with pending authorization codes during cleanup * refactor: Simplify client ID metadata document handling - Gate metadata document fetches on the MCP preference inside the helper - Add isMCPClient getter and a shared client ID prefix constant - Enforce the team/metadata document CHECK in both directions - Index oauthClientId on OAuth token and code tables - Reuse parseDomain, clamp and time helpers * revert: Remove pending authorization code check from OAuth client cleanup * fix: Block all special-use addresses when fetching client metadata documents ALLOWED_PRIVATE_IP_ADDRESSES no longer applies to client ID metadata document requests (draft -02 section 8.6). The fetch wrapper takes an allowIPAddressList option to override the environment list. * fix: Reject empty userinfo in client metadata document URLs https://@host and https://:@host have a userinfo component that the URL parser drops, so check the raw authority (draft -02 section 3). * fix: Accept a root path in client metadata document URLs Draft -02 section 3 marks a root path as NOT RECOMMENDED, not invalid, so https://example.com/ is a valid client_id. A URL with no path is still rejected. * fix: Reject client metadata documents with private key material A jwks key with private or symmetric members (d, p, q, dp, dq, qi, oth, k) makes the document invalid, so it is not cached (draft -02 section 4.1). Public keys are still ignored. * fix: Respect no-cache, no-store and Age for client metadata documents no-store and no-cache now expire the cached document at once, so it is fetched again before the next authorization. Freshness from max-age or Expires (measured from Date) is reduced by Age before clamping (draft -02 section 5.2). * feat: Copy DCR and CIMD client logos to file storage in the background logo_uri was rendered directly on the consent screen, which lets the logo host track users and change the image at any time (draft -02 sections 8.8 and 9.2). A background task now fetches the logo with the strict fetch rules, accepts only PNG, JPEG, GIF and WebP by their leading bytes, and stores it content addressed in the public bucket. Requests never wait for the upload. * fix: Match loopback redirect URIs on any port Native apps such as Claude Code register http://localhost/callback and then listen on a free port, so an exact match rejected them. Loopback redirect URIs now match on any port (RFC 8252 section 7.3); the scheme, host and path must still match, and other URIs still match exactly. * fix: Only break the redirect URL mid-word on the consent screen break-all on the whole notice split words such as "continue" in the loopback warning. It now applies only to the redirect URL. * chore: Shorten the loopback warning on the consent screen * fix: Show the punycode host of client metadata documents on the consent screen A lookalike Unicode host was shown as written. Hostnames now come from a shared getHostname helper that returns the punycode form. * refactor: Move image type detection to ImageHelper and use it for avatars Avatars and integration logos copied from a URL are now stored only if they are PNG, JPEG, GIF or WebP, with the content type detected from the file data rather than the remote host. * fix: Address review findings for OAuth client logos and metadata caching - Count the time since the Date header as age when caching metadata documents, so a document is not cached past its Expires time - Log logo scheduling failures instead of failing registration requests - Run dynamic client registration in a transaction - Delete copied logos from storage when no client uses them * fix: Store one logo per OAuth client and return a distinct metadata document error - Logos are stored per client, so a file is only deleted when its own client stops using it. This removes the reference count and its race. - A metadata document that cannot be fetched or is invalid now returns invalid_client_metadata with the reason, not a 404. Network errors are only logged. - Move scheduleOptional to BaseTask so that any task can use it.
479 lines
12 KiB
TypeScript
479 lines
12 KiB
TypeScript
import { escapeRegExp } from "es-toolkit/compat";
|
|
import env from "../env";
|
|
import { isBrowser } from "./browser";
|
|
import { parseDomain } from "./domains";
|
|
|
|
/**
|
|
* Prepends the CDN url to the given path (If a CDN is configured).
|
|
*
|
|
* @param path The path to prepend the CDN url to.
|
|
* @returns The path with the CDN url prepended.
|
|
*/
|
|
export function cdnPath(path: string): string {
|
|
return `${env.CDN_URL ?? ""}${path}`;
|
|
}
|
|
|
|
/**
|
|
* Extracts the file name from a given url.
|
|
*
|
|
* @param url The url to extract the file name from.
|
|
* @returns The file name.
|
|
*/
|
|
export function fileNameFromUrl(url: string) {
|
|
try {
|
|
const parsed = new URL(url);
|
|
return parsed.pathname.split("/").pop();
|
|
} catch (_err) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given string is a link to inside the application.
|
|
*
|
|
* @param url The url to check.
|
|
* @returns True if the url is internal, false otherwise.
|
|
*/
|
|
export function isInternalUrl(href: string) {
|
|
// empty strings are never internal
|
|
if (href === "") {
|
|
return false;
|
|
}
|
|
|
|
// relative paths are always internal
|
|
if (href[0] === "/") {
|
|
return true;
|
|
}
|
|
|
|
const outline = isBrowser
|
|
? parseDomain(window.location.href)
|
|
: parseDomain(env.URL);
|
|
const domain = parseDomain(href);
|
|
|
|
return (
|
|
(outline.host === domain.host && outline.port === domain.port) ||
|
|
(isBrowser &&
|
|
window.location.hostname === domain.host &&
|
|
window.location.port === domain.port)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given string is a link to a document.
|
|
*
|
|
* @param url The url to check.
|
|
* @returns True if a document, false otherwise.
|
|
*/
|
|
export function isDocumentUrl(url: string) {
|
|
try {
|
|
const parsed = new URL(url, env.URL);
|
|
return (
|
|
isInternalUrl(url) &&
|
|
(parsed.pathname.startsWith("/doc/") || parsed.pathname.startsWith("/d/"))
|
|
);
|
|
} catch (_err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the given string is a link to a collection.
|
|
*
|
|
* @param url The url to check.
|
|
* @returns True if a collection, false otherwise.
|
|
*/
|
|
export function isCollectionUrl(url: string) {
|
|
try {
|
|
const parsed = new URL(url, env.URL);
|
|
return isInternalUrl(url) && parsed.pathname.startsWith("/collection/");
|
|
} catch (_err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
type UrlOptions = {
|
|
/** Require the url to have a hostname. */
|
|
requireHostname?: boolean;
|
|
/** Require the url not to use HTTP, custom protocols are ok. */
|
|
requireHttps?: boolean;
|
|
/** Require the url to have a protocol. */
|
|
requireProtocol?: boolean;
|
|
};
|
|
|
|
/**
|
|
* Returns true if the given string is a url.
|
|
*
|
|
* @param text The url to check.
|
|
* @param options Parsing options.
|
|
* @returns True if a url, false otherwise.
|
|
*/
|
|
export function isUrl(
|
|
text: string,
|
|
{ requireProtocol = true, requireHostname, requireHttps }: UrlOptions = {}
|
|
) {
|
|
if (text.match(/\n/)) {
|
|
return false;
|
|
}
|
|
|
|
if (!requireProtocol && text.startsWith("www.")) {
|
|
const parts = text.split(".");
|
|
if (parts.length < 2) {
|
|
return false;
|
|
}
|
|
|
|
text = `https://${text}`;
|
|
}
|
|
|
|
try {
|
|
const url = new URL(text);
|
|
const blockedProtocols = ["javascript:", "file:", "vbscript:", "data:"];
|
|
|
|
if (blockedProtocols.includes(url.protocol)) {
|
|
return false;
|
|
}
|
|
if (requireHttps && url.protocol === "http:") {
|
|
return false;
|
|
}
|
|
if (url.hostname) {
|
|
return true;
|
|
}
|
|
|
|
return (
|
|
url.protocol !== "" &&
|
|
(url.pathname.startsWith("//") || url.pathname.startsWith("http")) &&
|
|
!requireHostname
|
|
);
|
|
} catch (_err) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Schemes that are never treated as private-use, either because they are web
|
|
* schemes validated elsewhere or because they can execute or embed content.
|
|
*/
|
|
const nonPrivateUseSchemes = new Set([
|
|
"http",
|
|
"https",
|
|
"ftp",
|
|
"ws",
|
|
"wss",
|
|
"file",
|
|
"data",
|
|
"javascript",
|
|
"vbscript",
|
|
"blob",
|
|
"about",
|
|
]);
|
|
|
|
/**
|
|
* Returns true if the given url uses a private-use URI scheme, as registered
|
|
* by native apps to receive OAuth redirects (RFC 8252 section 7.1), for
|
|
* example `com.example.app:/oauth2redirect` or `myapp://callback`.
|
|
*
|
|
* @param text The url to check.
|
|
* @returns True if the url uses a private-use URI scheme, false otherwise.
|
|
*/
|
|
export function isPrivateUseSchemeUrl(text: string) {
|
|
if (/\s/.test(text)) {
|
|
return false;
|
|
}
|
|
|
|
let url: URL;
|
|
try {
|
|
url = new URL(text);
|
|
} catch (_err) {
|
|
return false;
|
|
}
|
|
|
|
const scheme = url.protocol.slice(0, -1).toLowerCase();
|
|
if (nonPrivateUseSchemes.has(scheme)) {
|
|
return false;
|
|
}
|
|
|
|
// Require a destination after the scheme, e.g. reject a bare "myapp:".
|
|
return !!url.host || (url.pathname !== "" && url.pathname !== "/");
|
|
}
|
|
|
|
/**
|
|
* Check if a URI is a loopback address (localhost, 127.0.0.1, or [::1]).
|
|
*
|
|
* @param uri - the redirect URI to check.
|
|
* @returns true if the URI targets a loopback address.
|
|
*/
|
|
export function isLoopbackUri(uri: string | undefined): boolean {
|
|
if (!uri) {
|
|
return false;
|
|
}
|
|
try {
|
|
const url = new URL(uri);
|
|
return (
|
|
url.hostname === "localhost" ||
|
|
url.hostname === "127.0.0.1" ||
|
|
url.hostname === "[::1]"
|
|
);
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the hostname of a URL. Internationalized hostnames are returned in
|
|
* their punycode form.
|
|
*
|
|
* @param url the URL to parse.
|
|
* @returns the hostname, or undefined if the URL cannot be parsed.
|
|
*/
|
|
export function getHostname(url: string | undefined): string | undefined {
|
|
if (!url) {
|
|
return undefined;
|
|
}
|
|
try {
|
|
return new URL(url).hostname;
|
|
} catch {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Temporary prefix applied to links in document that are not yet persisted.
|
|
*/
|
|
export const creatingUrlPrefix = "creating#";
|
|
|
|
/**
|
|
* Returns true if the given string is a link to outside the application.
|
|
*
|
|
* @param url The url to check.
|
|
* @returns True if the url is external, false otherwise.
|
|
*/
|
|
export function isExternalUrl(url: string) {
|
|
return (
|
|
!!url &&
|
|
!isInternalUrl(url) &&
|
|
!url.startsWith(creatingUrlPrefix) &&
|
|
(!env.CDN_URL || !url.startsWith(env.CDN_URL))
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Returns match if the given string is a base64 encoded url.
|
|
*
|
|
* @param url The url to check.
|
|
* @returns A RegExp match if the url is base64, false otherwise.
|
|
*/
|
|
export function isBase64Url(url: string) {
|
|
const match = url.match(/^data:([a-z]+\/[^;]+);base64,(.*)/i);
|
|
return match ? match : false;
|
|
}
|
|
|
|
const allowedSchemes = [
|
|
"mailto:",
|
|
"sms:",
|
|
"fax:",
|
|
"tel:",
|
|
"geo:",
|
|
"maps:",
|
|
"magnet:",
|
|
];
|
|
|
|
const allowedImageDataUris = [
|
|
"data:image/png;base64,",
|
|
"data:image/jpeg;base64,",
|
|
"data:image/gif;base64,",
|
|
"data:image/webp;base64,",
|
|
"data:image/avif;base64,",
|
|
];
|
|
|
|
/**
|
|
* For use in the editor, this function will ensure that a url is
|
|
* potentially valid, and filter out unsupported and malicious protocols.
|
|
*
|
|
* @param url The url to sanitize
|
|
* @returns The sanitized href
|
|
*/
|
|
export function sanitizeUrl(url: string | null | undefined) {
|
|
if (!url) {
|
|
return undefined;
|
|
}
|
|
|
|
// Surrounding whitespace, a newline in particular, would otherwise fail
|
|
// validation and have a scheme prepended to an already qualified url.
|
|
const trimmed = url.trim();
|
|
const lower = trimmed.toLowerCase();
|
|
if (
|
|
!isUrl(trimmed, { requireHostname: false }) &&
|
|
!trimmed.startsWith("/") &&
|
|
!trimmed.startsWith("#") &&
|
|
!allowedSchemes.some((scheme) => lower.startsWith(scheme))
|
|
) {
|
|
return `https://${trimmed}`;
|
|
}
|
|
return trimmed;
|
|
}
|
|
|
|
/**
|
|
* For use in the editor on image-like elements, this function will ensure
|
|
* that a src is potentially valid. In addition to the protocols allowed by
|
|
* `sanitizeUrl`, base64-encoded image data URIs are permitted (excluding
|
|
* SVG, which can contain inline scripts).
|
|
*
|
|
* @param src The src to sanitize.
|
|
* @returns The sanitized src.
|
|
*/
|
|
export function sanitizeImageSrc(src: string | null | undefined) {
|
|
if (!src) {
|
|
return undefined;
|
|
}
|
|
|
|
const lower = src.toLowerCase();
|
|
if (allowedImageDataUris.some((scheme) => lower.startsWith(scheme))) {
|
|
return src;
|
|
}
|
|
return sanitizeUrl(src);
|
|
}
|
|
|
|
/**
|
|
* Returns a regex to match urls that begin with the given url's origin.
|
|
*
|
|
* @param url The url to create a regex for.
|
|
* @returns A regex anchored to the origin, a path and query may follow.
|
|
*/
|
|
export function urlRegex(url: string | null | undefined): RegExp | undefined {
|
|
if (!url || !isUrl(url)) {
|
|
return undefined;
|
|
}
|
|
|
|
const urlObj = new URL(sanitizeUrl(url) as string);
|
|
|
|
return new RegExp(`^${escapeRegExp(`${urlObj.protocol}//${urlObj.host}`)}`);
|
|
}
|
|
|
|
/**
|
|
* Parse the share identifier from a given url.
|
|
*
|
|
* @param url The url to parse.
|
|
* @returns A share identifier or undefined if not found.
|
|
*/
|
|
export function parseShareIdFromUrl(url: string): string | undefined {
|
|
if (url[0] === "/") {
|
|
url = `${env.URL}${url}`;
|
|
}
|
|
|
|
let pathname;
|
|
try {
|
|
pathname = new URL(url).pathname;
|
|
} catch (_err) {
|
|
return;
|
|
}
|
|
|
|
const split = pathname.split("/");
|
|
const indexOfS = split.indexOf("s");
|
|
|
|
if (indexOfS >= 0) {
|
|
const shareId = split[indexOfS + 1];
|
|
if (shareId) {
|
|
// Remove trailing format like .md
|
|
const dotIndex = shareId.indexOf(".");
|
|
return dotIndex >= 0 ? shareId.substring(0, dotIndex) : shareId;
|
|
}
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Extracts LIKELY urls from the given text, note this does not validate the urls.
|
|
*
|
|
* @param text The text to extract urls from.
|
|
* @returns An array of likely urls.
|
|
*/
|
|
export function getUrls(text: string) {
|
|
return Array.from(text.match(/(?:https?):\/\/[^\s]+/gi) || []);
|
|
}
|
|
|
|
/**
|
|
* Adds the port that the application is publicly reachable on to a url that
|
|
* does not specify one. A proxy commonly forwards a Host header without the
|
|
* public port, so urls derived from an incoming request would otherwise point
|
|
* at the wrong address.
|
|
*
|
|
* @param url the url to modify, may be relative.
|
|
* @returns the url with the port added, if one was missing.
|
|
*/
|
|
export function addMissingUrlPort(url: string): string {
|
|
let port;
|
|
try {
|
|
port = new URL(env.URL).port;
|
|
} catch (_err) {
|
|
return url;
|
|
}
|
|
|
|
if (!port) {
|
|
return url;
|
|
}
|
|
|
|
try {
|
|
const parsed = new URL(url);
|
|
if (parsed.port) {
|
|
return url;
|
|
}
|
|
parsed.port = port;
|
|
return parsed.toString();
|
|
} catch (_err) {
|
|
// Relative urls are resolved against the current origin and need no port.
|
|
return url;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the fragment (hash) from a url, if present.
|
|
*
|
|
* @param url The url to modify.
|
|
* @returns The url without its fragment.
|
|
*/
|
|
export function removeUrlFragment(url: string): string {
|
|
try {
|
|
const parsed = new URL(url);
|
|
parsed.hash = "";
|
|
return parsed.toString();
|
|
} catch (_err) {
|
|
return url.split("#")[0];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes a suffix from the end of a url's pathname, if present. The url is
|
|
* parsed rather than string-replaced so that a matching substring elsewhere in
|
|
* the url (such as the hostname) is not affected.
|
|
*
|
|
* @param url The url to modify.
|
|
* @param suffix The pathname suffix to remove (e.g. `/edit`).
|
|
* @returns The url with the suffix removed from the end of its pathname.
|
|
*/
|
|
export function removeUrlPathSuffix(url: string, suffix: string): string {
|
|
try {
|
|
const parsed = new URL(url);
|
|
if (parsed.pathname.endsWith(suffix)) {
|
|
parsed.pathname = parsed.pathname.slice(0, -suffix.length);
|
|
}
|
|
return parsed.toString();
|
|
} catch (_err) {
|
|
return url.endsWith(suffix) ? url.slice(0, -suffix.length) : url;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Converts a url to a display friendly format, removing the protocol and trailing slash.
|
|
*
|
|
* @param url The url to convert.
|
|
* @returns The display friendly url.
|
|
*/
|
|
export function toDisplayUrl(url: string) {
|
|
try {
|
|
const parsed = new URL(url);
|
|
return parsed.host + (parsed.pathname === "/" ? "" : parsed.pathname);
|
|
} catch {
|
|
return url;
|
|
}
|
|
}
|