Handles ambiguous slash URLs in web paths

tzarebczan · tzarebczan · commit e380c3a7e374 · 2026-02-07T17:00:14.000-05:00
Addresses an issue where URLs with a slash but without a leading "@" could be misinterpreted.

Implements a new `resolveSlashUrl` function to handle cases such as malformed channel URLs (missing "@" prefix) and names with claim IDs (using "/" instead of ":").

This change ensures proper resolution and redirection for these ambiguous URLs, improving user experience and preventing broken links, particularly when shared on platforms like Grok and Twitter.

Removes now-unnecessary code related to correcting channel paths within the `withResolvedClaimRender` higher-order component and lbryURI.js.

Prioritizes full claim ID resolution

Improves slash URL resolution by prioritizing the name#claimid interpretation when the second part of the URL is a 40-character hexadecimal string (full claim ID).

This prevents misinterpretation of content names that might coincidentally look like claim IDs and ensures that content can be reliably resolved.
diff --git a/ui/hocs/withResolvedClaimRender/view.jsx b/ui/hocs/withResolvedClaimRender/view.jsx
@@ -1,6 +1,5 @@
 // @flow
 import React from 'react';
-import { useHistory, useLocation } from 'react-router-dom';
 
 import Spinner from 'component/spinner';
 import Button from 'component/button';
@@ -34,47 +33,6 @@ type Props = {
   doOpenModal: (string, {}) => void,
 };
 
-/**
- * Checks if a web URL path might be missing the @ prefix for the channel name.
- * Returns a corrected path with @ if applicable, or null if not applicable.
- * This handles cases like "/channel:id/content:id" which should be "/@channel:id/content:id"
- * (e.g., malformed URLs from Grok/Twitter that omit the @)
- */
-function getCorrectedChannelPath(pathname: string): ?string {
-  try {
-    // Remove leading slash
-    const webPath = pathname.startsWith('/') ? pathname.slice(1) : pathname;
-
-    // Must have a slash with content after it (channel/content pattern)
-    const slashIndex = webPath.indexOf('/');
-    if (slashIndex === -1 || slashIndex === webPath.length - 1) {
-      return null;
-    }
-
-    const firstPart = webPath.substring(0, slashIndex);
-    const secondPart = webPath.substring(slashIndex + 1);
-
-    // First part should not already start with @
-    if (firstPart.startsWith('@')) {
-      return null;
-    }
-
-    // Both parts should have content (non-empty name before any modifiers)
-    // Modifiers in web URLs use : instead of #
-    const firstNameMatch = firstPart.match(/^[^#:$*]+/);
-    const secondNameMatch = secondPart.match(/^[^#:$*]+/);
-
-    if (!firstNameMatch || !firstNameMatch[0] || !secondNameMatch || !secondNameMatch[0]) {
-      return null;
-    }
-
-    // Return the corrected path with @ prefix
-    return `/@${webPath}`;
-  } catch (e) {
-    return null;
-  }
-}
-
 const withResolvedClaimRender = (ClaimRenderComponent: FunctionalComponentParam) => {
   const ResolvedClaimRender = (props: Props) => {
     const {
@@ -102,19 +60,8 @@ const withResolvedClaimRender = (ClaimRenderComponent: FunctionalComponentParam)
       ...otherProps
     } = props;
 
-    const { replace: historyReplace } = useHistory();
-    const location = useLocation();
     const { streamName, /* channelName, */ isChannel } = parseURI(uri);
 
-    // Check if the browser URL is missing @ prefix and redirect if needed
-    // This handles malformed URLs from Grok/Twitter like "/channel:id/content:id"
-    const correctedPath = getCorrectedChannelPath(location.pathname);
-    React.useEffect(() => {
-      if (correctedPath) {
-        historyReplace(correctedPath + location.search + location.hash);
-      }
-    }, [correctedPath, historyReplace, location.search, location.hash]);
-
     const claimIsRestricted = !claimIsMine && (geoRestriction !== null || isClaimBlackListed || isClaimFiltered);
 
     const resolveRequired =
@@ -158,11 +105,6 @@ const withResolvedClaimRender = (ClaimRenderComponent: FunctionalComponentParam)
       }
     }, [resolveRequired, resolveClaim]);
 
-    // If URL needs correction, show loading while redirect happens
-    if (correctedPath) {
-      return <LoadingSpinner text={__('Resolving...')} />;
-    }
-
     if (!hasClaim) {
       if (hasClaim === undefined) {
         return <LoadingSpinner text={__('Resolving...')} />;
diff --git a/web/src/html.js b/web/src/html.js
@@ -21,7 +21,8 @@ const {
 const { fetchStreamUrl } = require('./fetchStreamUrl');
 const { lbryProxy: Lbry } = require('../lbry');
 const { getHomepageJsonV1 } = require('./getHomepageJSON');
-const { buildURI, parseURI, normalizeClaimUrl, getCorrectedChannelWebPath } = require('./lbryURI');
+const { buildURI, parseURI, normalizeClaimUrl } = require('./lbryURI');
+const { resolveSlashUrl } = require('./resolveSlashUrl');
 const fs = require('fs');
 const PAGES = require('../../ui/constants/pages');
 const path = require('path');
@@ -665,16 +666,6 @@ async function getHtml(ctx) {
     let parsedUri, claimUri;
     let pathToUse = requestPath.slice(1);
 
-    // Check if URL is missing @ prefix (e.g., malformed URLs from Grok/Twitter)
-    const correctedPath = getCorrectedChannelWebPath(pathToUse);
-    if (correctedPath) {
-      // Redirect to the corrected URL with @ prefix, preserving query string
-      // Use encodeURI to handle special characters like parentheses
-      const queryString = ctx.querystring ? `?${ctx.querystring}` : '';
-      ctx.redirect(encodeURI(`/${correctedPath}`) + queryString);
-      return;
-    }
-
     try {
       parsedUri = parseURI(normalizeClaimUrl(pathToUse));
       claimUri = buildURI({ ...parsedUri, startTime: undefined }, true);
@@ -683,7 +674,36 @@ async function getHtml(ctx) {
       return err.message;
     }
 
-    const claim = await resolveClaimOrRedirect(ctx, claimUri);
+    // If the path has "/" without "@", parseURI drops the second segment
+    // (e.g., "Creator/video" → lbry://Creator). Try alternate interpretations first.
+    let claim;
+    const resolved = await resolveSlashUrl(pathToUse);
+
+    if (resolved) {
+      const queryString = ctx.querystring ? `?${ctx.querystring}` : '';
+
+      if (resolved.type === 'channel') {
+        // Malformed channel URL — redirect to the corrected @-prefixed path
+        ctx.redirect(encodeURI(`/@${pathToUse}`) + queryString);
+        return;
+      }
+
+      if (resolved.type === 'claimid') {
+        // name/claimid — redirect to canonical URL so the client-side app works
+        const canonicalPath = resolved.claim.canonical_url?.replace('lbry://', '').replace(/#/g, ':');
+        if (canonicalPath) {
+          ctx.redirect(`/${canonicalPath}` + queryString);
+          return;
+        }
+        claim = resolved.claim;
+        claimUri = resolved.uri;
+      }
+    }
+
+    if (!claim) {
+      claim = await resolveClaimOrRedirect(ctx, claimUri);
+    }
+
     const referrerQuery = escapeHtmlProperty(getParameterByName('r', ctx.request.url));
 
     if (claim) {
diff --git a/web/src/lbryURI.js b/web/src/lbryURI.js
@@ -359,95 +359,6 @@ function normalizeClaimUrl(url) {
   return normalizeURI(url.replace(/:/g, '#'));
 }
 
-/**
- * Checks if a URI might be missing the @ prefix for the channel name.
- * Returns a corrected URI with @ if applicable, or null if not applicable.
- * This handles cases like "channel:id/content:id" which should be "@channel:id/content:id"
- * (e.g., malformed URLs from Grok/Twitter that omit the @)
- */
-function getCorrectedChannelUri(uri) {
-  try {
-    // Check if the URI has a path separator (indicating channel/content pattern)
-    // but doesn't have a channel name (meaning no @ was detected)
-    const parsed = parseURI(uri);
-
-    // If it already has a channelName, the @ is present - no correction needed
-    if (parsed.channelName) {
-      return null;
-    }
-
-    // Check if the raw URI contains a "/" followed by more content (channel/content pattern)
-    // Remove lbry:// protocol for checking
-    const uriWithoutProtocol = uri.replace(/^lbry:\/\//, '');
-    const slashIndex = uriWithoutProtocol.indexOf('/');
-
-    // Must have a slash with content after it (channel/content pattern)
-    if (slashIndex === -1 || slashIndex === uriWithoutProtocol.length - 1) {
-      return null;
-    }
-
-    const firstPart = uriWithoutProtocol.substring(0, slashIndex);
-    const secondPart = uriWithoutProtocol.substring(slashIndex + 1);
-
-    // First part should not already start with @
-    if (firstPart.startsWith('@')) {
-      return null;
-    }
-
-    // Both parts should have content (non-empty after any modifiers are stripped)
-    const firstNameMatch = firstPart.match(/^[^#:$*]+/);
-    const secondNameMatch = secondPart.match(/^[^#:$*]+/);
-
-    if (!firstNameMatch || !firstNameMatch[0] || !secondNameMatch || !secondNameMatch[0]) {
-      return null;
-    }
-
-    // Build the corrected URI with @ prefix
-    return `lbry://@${uriWithoutProtocol}`;
-  } catch (e) {
-    return null;
-  }
-}
-
-/**
- * Checks if a web URL path might be missing the @ prefix for the channel name.
- * Returns a corrected path with @ if applicable, or null if not applicable.
- * This works on raw web paths BEFORE they are parsed into lbry:// URIs.
- *
- * Example: "JustMe:05/content:0" -> "@JustMe:05/content:0"
- */
-function getCorrectedChannelWebPath(webPath) {
-  try {
-    // Must have a slash with content after it (channel/content pattern)
-    const slashIndex = webPath.indexOf('/');
-    if (slashIndex === -1 || slashIndex === webPath.length - 1) {
-      return null;
-    }
-
-    const firstPart = webPath.substring(0, slashIndex);
-    const secondPart = webPath.substring(slashIndex + 1);
-
-    // First part should not already start with @
-    if (firstPart.startsWith('@')) {
-      return null;
-    }
-
-    // Both parts should have content (non-empty name before any modifiers)
-    // Modifiers in web URLs use : instead of #
-    const firstNameMatch = firstPart.match(/^[^#:$*]+/);
-    const secondNameMatch = secondPart.match(/^[^#:$*]+/);
-
-    if (!firstNameMatch || !firstNameMatch[0] || !secondNameMatch || !secondNameMatch[0]) {
-      return null;
-    }
-
-    // Return the corrected path with @ prefix
-    return `@${webPath}`;
-  } catch (e) {
-    return null;
-  }
-}
-
 module.exports = {
   parseURI,
   buildURI,
@@ -459,6 +370,4 @@ module.exports = {
   isURIClaimable,
   splitBySeparator,
   convertToShareLink,
-  getCorrectedChannelUri,
-  getCorrectedChannelWebPath,
 };
diff --git a/web/src/oEmbed.js b/web/src/oEmbed.js
@@ -9,7 +9,7 @@ const {
   escapeHtmlProperty,
 } = require('../../ui/util/web');
 const { lbryProxy: Lbry } = require('../lbry');
-const { getCorrectedChannelWebPath } = require('./lbryURI');
+const { resolveSlashUrl } = require('./resolveSlashUrl');
 
 Lbry.setDaemonConnectionString(PROXY_URL);
 
@@ -18,22 +18,26 @@ Lbry.setDaemonConnectionString(PROXY_URL);
 // ****************************************************************************
 
 async function getClaim(requestUrl) {
-  // Extract the path from the URL and check for missing @ prefix
-  let webPath = requestUrl.replace(`${URL}/`, '');
-  const correctedPath = getCorrectedChannelWebPath(webPath);
-  if (correctedPath) {
-    webPath = correctedPath;
-  }
-
+  const webPath = requestUrl.replace(`${URL}/`, '');
   const uri = `lbry://${webPath}`;
 
   let claim, error;
-  try {
-    const response = await Lbry.resolve({ urls: [uri] });
-    if (response && response[uri] && !response[uri].error) {
-      claim = response[uri];
-    }
-  } catch {}
+
+  // Try alternate interpretations for ambiguous slash URLs (missing @, name/claimid)
+  const resolved = await resolveSlashUrl(webPath);
+  if (resolved) {
+    claim = resolved.claim;
+  }
+
+  // Fall back to resolving as-is (handles @channel/content, single-segment, etc.)
+  if (!claim) {
+    try {
+      const response = await Lbry.resolve({ urls: [uri] });
+      if (response && response[uri] && !response[uri].error) {
+        claim = response[uri];
+      }
+    } catch {}
+  }
 
   if (!claim) {
     error = 'The URL is invalid or is not associated with any claim.';
diff --git a/web/src/resolveSlashUrl.js b/web/src/resolveSlashUrl.js
@@ -0,0 +1,64 @@
+const { lbryProxy: Lbry } = require('../lbry');
+
+/**
+ * Resolves ambiguous URLs that have "/" without "@".
+ *
+ * In LBRY URLs, "/" is always a channel/content separator (requiring @).
+ * When we see "foo/bar" without "@", it could be:
+ *   1) A name with claim ID: foo:bar (someone used "/" instead of ":")
+ *   2) A malformed channel URL: @foo/bar (missing @ prefix, e.g., from Grok/Twitter)
+ *
+ * Priority:
+ *   - If second part is exactly 40 hex chars (full claim ID), try name:claimid first
+ *   - Otherwise, try @channel/content first
+ *   - Falls back to the other interpretation if the first doesn't resolve
+ *
+ * @param {string} webPath - The web path without leading slash (e.g., "Creator/video-title")
+ * @returns {Promise<{ claim: Object, uri: string, type: 'channel'|'claimid' } | null>}
+ */
+async function resolveSlashUrl(webPath) {
+  const slashIdx = webPath.indexOf('/');
+  if (slashIdx <= 0 || webPath.startsWith('@')) {
+    return null;
+  }
+
+  const secondPart = webPath.substring(slashIdx + 1);
+  const isHexClaimId = /^[0-9a-f]+$/.test(secondPart) && secondPart.length <= 40;
+  const isFullClaimId = isHexClaimId && secondPart.length === 40;
+
+  // If the second part is exactly 40 hex chars (full claim ID), prioritize name:claimid
+  // interpretation since content names don't look like "ca00cbe17cb76...".
+  if (isFullClaimId) {
+    try {
+      const fixedUri = `lbry://${webPath.substring(0, slashIdx)}#${secondPart}`;
+      const response = await Lbry.resolve({ urls: [fixedUri] });
+      if (response && response[fixedUri] && !response[fixedUri].error) {
+        return { claim: response[fixedUri], uri: fixedUri, type: 'claimid' };
+      }
+    } catch {}
+  }
+
+  // Try as @channel/content (malformed URLs from Grok/Twitter)
+  try {
+    const withAtUri = `lbry://@${webPath}`;
+    const response = await Lbry.resolve({ urls: [withAtUri] });
+    if (response && response[withAtUri] && !response[withAtUri].error) {
+      return { claim: response[withAtUri], uri: withAtUri, type: 'channel' };
+    }
+  } catch {}
+
+  // Try as name#claimid (partial claim ID, or full ID that didn't resolve above)
+  if (isHexClaimId && !isFullClaimId) {
+    try {
+      const fixedUri = `lbry://${webPath.substring(0, slashIdx)}#${secondPart}`;
+      const response = await Lbry.resolve({ urls: [fixedUri] });
+      if (response && response[fixedUri] && !response[fixedUri].error) {
+        return { claim: response[fixedUri], uri: fixedUri, type: 'claimid' };
+      }
+    } catch {}
+  }
+
+  return null;
+}
+
+module.exports = { resolveSlashUrl };
