feat(chrome-extension): detect geospatial services (#1967)

* feat(chrome-extension): detect geospatial services

* fix(chrome-extension): hand services to add data

* fix(chrome-extension): scope detected services to pages

* fix(chrome-extension): harden service lifecycle

* fix(chrome-extension): detect services in embedded maps

* fix(chrome-extension): show services on raw responses

* fix(chrome-extension): make detected services addable

Service detection never stored anything in a real browser. The page scope
seeded a tab's document set from the main_frame request's documentId, but
Chrome sets no documentId on a navigation request: the document does not
exist yet. The set stayed empty, every later request was rejected, and the
earlier page-scoping, embedded-map and raw-response fixes were all inert.
Scope by retiring the previous page's documents instead, which needs no id
on the navigation itself and so covers raw responses and iframes too.

A detected endpoint was also not enough to add a layer. Each result now
carries the layer the page asked for, passed as serviceLayer/serviceStyle
and prefilled into the matching form field:

- WMS LAYERS and WFS typeName, with WFS operation parameters stripped from
  the endpoint rather than left on it
- a WMTS GetTile request rewritten into the tile template that produced it
- the ArcGIS layer index, which a bare FeatureServer URL loses: GeoLibre
  then falls back to the service's first layer and draws the wrong one
- the style document a vector tileset needs, since its source layers live
  in the style and not in the tile URL

Results are listed per layer, as one endpoint can serve many. Two false
positives are gone as well: a style's glyph ranges are no longer offered as
a tile service, and a documentation link whose wording mentions a format is
no longer read as a dataset.

Verified end to end against live WMS, WMTS, WFS, OGC API Features, ArcGIS,
XYZ and vector tile sites: each adds a layer that draws, with no typing.

* Address Claude and CodeRabbit review feedback

- Draw the page boundary when a navigation starts rather than when it
  completes. A tile or service request made by the incoming page can finish
  before that page's own HTML does, and retiring documents at completion
  swept up the new page's document along with the outgoing one's, rejecting
  everything it went on to request.
- Require an OGC format parameter before treating a bare /collections as an
  OGC API service. The path is an ordinary REST and storefront route as well,
  so on its own it put unrelated services in the popup. /collections/<id>/items
  is specific enough to stand alone and is unchanged.
- Tell a selection holding one service and one file apart from a selection
  holding two services, which shared a message that only described the latter.
- Filter the deep-link source kind through masHidesDataSource, as every other
  path that opens the Add Data dialog from outside the component already does.
  Inert today, since no service kind is MAS-hidden.
- Point the README's CORS note at the service being fetched rather than at a
  static file, which described the wrong failure mode for a detected service.

* Address Claude review feedback

- Skip the storage read for a candidate already at the head of a tab's list.
  Panning a slippy map resolves nearly every tile to the same candidate, and
  the dedup check only fired after the read it was meant to avoid.
- Fill in a vector tileset's style when the style document completes after the
  tiles it describes. Either request can finish first, and an entry recorded
  without a style leaves Add Data with no source layers to resolve.
- Narrow the page test in the document scanner. Any trailing slash counted as
  a page, which silently dropped hint-based detection for REST endpoints that
  conventionally end in one; a directory-style URL now counts as a page only
  when the link text reads its slug back, which is what the documentation
  links that motivated the rule look like.
- Cover both watcher behaviors with a test that drives background.mjs through
  a stub of the extension APIs, which nothing exercised before.

* Address Claude review feedback

- Ignore the WMS and WFS form caches when a deep link supplies the endpoint.
  A link whose service was detected without a layer (a GetCapabilities hit,
  say) paired its fresh endpoint with the layer or feature type left over from
  whichever service the dialog was last used for, which submits a request the
  new service cannot answer. The WMS style is cleared with the layer for the
  same reason.
- Keep a document marked for retirement when a straggling request from the
  outgoing page completes mid-navigation. It was moved back among the incoming
  page's documents and so outlived the navigation it should not have survived.

Author: giswqs

apps/geolibre-desktop/src/components/layout/AddDataDialog.tsx

@@ -44,6 +44,16 @@ interface AddDataDialogProps {
    * clicked PostGIS table.
    */
   initialPostgres?: OpenAddDataPostgres;
+  /** Service URL supplied by a browser-extension deep link. */
+  initialUrl?: string;
+  /**
+   * The layer that deep link asked for — a WMS `LAYERS` value, a WFS feature
+   * type, a vector tile source layer. Prefilled so the form the extension opens
+   * is complete rather than an endpoint the user must still name a layer on.
+   */
+  initialLayer?: string;
+  /** Style document accompanying a deep-linked vector tileset. */
+  initialStyleUrl?: string;
 }
 
 /**
@@ -55,20 +65,29 @@ function renderSource(
   kind: AddDataKind,
   initialDeckVizKind: string | undefined,
   initialPostgres: OpenAddDataPostgres | undefined,
+  initialUrl: string | undefined,
+  initialLayer: string | undefined,
+  initialStyleUrl: string | undefined,
 ) {
   switch (kind) {
     case "xyz":
-      return <XyzSource />;
+      return <XyzSource initialUrl={initialUrl} />;
     case "wms":
-      return <WmsSource />;
+      return <WmsSource initialUrl={initialUrl} initialLayers={initialLayer} />;
     case "wfs":
-      return <WfsSource />;
+      return <WfsSource initialUrl={initialUrl} initialTypeName={initialLayer} />;
     case "wmts":
-      return <WmtsSource />;
+      return <WmtsSource initialUrl={initialUrl} />;
     case "ogc-features":
-      return <OgcFeaturesSource />;
+      return <OgcFeaturesSource initialUrl={initialUrl} />;
     case "ogc-vector-tiles":
-      return <OgcVectorTilesSource />;
+      return (
+        <OgcVectorTilesSource
+          initialUrl={initialUrl}
+          initialStyleUrl={initialStyleUrl}
+          initialSourceLayers={initialLayer}
+        />
+      );
     case "gpx":
       return <GpxSource />;
     case "georss":
@@ -84,7 +103,7 @@ function renderSource(
     case "mbtiles":
       return <MbtilesSource />;
     case "arcgis":
-      return <ArcGISSource />;
+      return <ArcGISSource initialUrl={initialUrl} />;
     case "postgres":
       return <PostgresSource initialPostgres={initialPostgres} />;
     case "video":
@@ -107,6 +126,9 @@ export function AddDataDialog({
   onOpenChange,
   initialDeckVizKind,
   initialPostgres,
+  initialUrl,
+  initialLayer,
+  initialStyleUrl,
 }: AddDataDialogProps) {
   const { t } = useTranslation();
   const open = kind !== null;
@@ -158,7 +180,14 @@ export function AddDataDialog({
 
         {kind ? (
           <AddDataShellProvider value={contextValue}>
-            {renderSource(kind, initialDeckVizKind, initialPostgres)}
+            {renderSource(
+              kind,
+              initialDeckVizKind,
+              initialPostgres,
+              initialUrl,
+              initialLayer,
+              initialStyleUrl,
+            )}
           </AddDataShellProvider>
         ) : null}
       </DialogContent>

apps/geolibre-desktop/src/components/layout/TopToolbar.tsx

@@ -114,6 +114,7 @@ import { IS_MAS_BUILD } from "../../lib/build-flags";
 import { masHidesDataSource } from "../../lib/mas-build";
 import { IS_STORE_BUILD } from "../../lib/updates";
 import { AddDataDialog, type AddDataKind } from "./AddDataDialog";
+import { serviceUrlParameter } from "../../lib/data-url";
 import {
   OPEN_ADD_DATA_EVENT,
   type OpenAddDataDetail,
@@ -1030,7 +1031,16 @@ export function TopToolbar({
       {} as Record<ToolbarMapControl, boolean>,
     ),
   );
-  const [addDataKind, setAddDataKind] = useState<AddDataKind | null>(null);
+  const [initialService, setInitialService] = useState(() =>
+    viewer || typeof window === "undefined" ? null : serviceUrlParameter(window.location.search),
+  );
+  const [addDataKind, setAddDataKind] = useState<AddDataKind | null>(() => {
+    const kind = initialService?.kind as AddDataKind | undefined;
+    // Every other path that opens this dialog from outside the component
+    // filters MAS-hidden sources first; a deep link must not be the way around
+    // that, even though no service kind is hidden today.
+    return kind && !masHidesDataSource(kind) ? kind : null;
+  });
   const [addDataTargetGroupId, setAddDataTargetGroupId] = useState<string | null>(null);
   const addDataInitialLayerIdsRef = useRef<Set<string>>(new Set());
   // Every path that opens the dialog outside the OPEN_ADD_DATA_EVENT listener
@@ -2086,6 +2096,13 @@ export function TopToolbar({
         mapControllerRef={mapControllerRef}
         initialDeckVizKind={addDataDeckVizKind}
         initialPostgres={addDataPostgres}
+        initialUrl={addDataKind === initialService?.kind ? initialService.url : undefined}
+        initialLayer={
+          addDataKind === initialService?.kind ? (initialService.layer ?? undefined) : undefined
+        }
+        initialStyleUrl={
+          addDataKind === initialService?.kind ? (initialService.styleUrl ?? undefined) : undefined
+        }
         onOpenChange={(open: boolean) => {
           if (!open) {
             if (addDataTargetGroupId) {
@@ -2098,6 +2115,7 @@ export function TopToolbar({
               }
             }
             setAddDataKind(null);
+            setInitialService(null);
             setAddDataTargetGroupId(null);
             setAddDataDeckVizKind(undefined);
             setAddDataPostgres(undefined);

apps/geolibre-desktop/src/components/layout/add-data/sources/ArcGISSource.tsx

@@ -39,12 +39,12 @@ const URL_PLACEHOLDER_KEYS = {
   "image-service": "addData.arcgis.imageServiceUrlPlaceholder",
 } as const satisfies Record<ArcGISLayerType, string>;
 
-export function ArcGISSource() {
+export function ArcGISSource({ initialUrl = "" }: { initialUrl?: string }) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.arcgis.defaultName"));
   const [arcgisLayerType, setArcgisLayerType] = useState<ArcGISLayerType>("feature");
   const [arcgisSourceType, setArcgisSourceType] = useState<ArcGISSourceType>("url");
-  const [arcgisUrl, setArcgisUrl] = useState("");
+  const [arcgisUrl, setArcgisUrl] = useState(initialUrl);
   const [arcgisItemId, setArcgisItemId] = useState("");
   const [arcgisPortalUrl, setArcgisPortalUrl] = useState("");
   const [arcgisAccessToken, setArcgisAccessToken] = useState("");

apps/geolibre-desktop/src/components/layout/add-data/sources/OgcFeaturesSource.tsx

@@ -43,18 +43,22 @@ interface OgcFeaturesSample {
  * feature count is reached, because a single `/items` request returns only one
  * server-sized page.
  */
-export function OgcFeaturesSource() {
+export function OgcFeaturesSource({ initialUrl = "" }: { initialUrl?: string }) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.ogcFeatures.defaultName"));
-  const [endpoint, setEndpoint] = useState(ogcFeaturesFormCache?.endpoint ?? "");
-  const [collectionId, setCollectionId] = useState(ogcFeaturesFormCache?.collectionId ?? "");
+  const [endpoint, setEndpoint] = useState(initialUrl || ogcFeaturesFormCache?.endpoint || "");
+  // See WmsSource: submitting prefers this field over the collection id in the
+  // URL, so a value cached from another service would quietly request that
+  // collection from the deep-linked one.
+  const serviceCache = initialUrl ? null : ogcFeaturesFormCache;
+  const [collectionId, setCollectionId] = useState(serviceCache?.collectionId ?? "");
   const [maxFeatures, setMaxFeatures] = useState(
     ogcFeaturesFormCache?.maxFeatures ?? String(DEFAULT_OGC_FEATURES_MAX_FEATURES),
   );
   const [bbox, setBbox] = useState(ogcFeaturesFormCache?.bbox ?? "");
   const [datetime, setDatetime] = useState(ogcFeaturesFormCache?.datetime ?? "");
   const [collectionOptions, setCollectionOptions] = useState<OgcFeaturesCollectionOption[]>(
-    ogcFeaturesFormCache?.options ?? [],
+    serviceCache?.options ?? [],
   );
   const [isRetrieving, setIsRetrieving] = useState(false);
   const [retrieveError, setRetrieveError] = useState<string | null>(null);

apps/geolibre-desktop/src/components/layout/add-data/sources/OgcVectorTilesSource.tsx

@@ -18,12 +18,20 @@ interface OgcSample {
  * API TileJSON often omits them). Rendering uses GeoLibre's default per-source
  * layer styling; the style's own paint is not applied.
  */
-export function OgcVectorTilesSource() {
+export function OgcVectorTilesSource({
+  initialUrl = "",
+  initialStyleUrl = "",
+  initialSourceLayers = "",
+}: {
+  initialUrl?: string;
+  initialStyleUrl?: string;
+  initialSourceLayers?: string;
+}) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.ogcVectorTiles.defaultName"));
-  const [tilesUrl, setTilesUrl] = useState("");
-  const [styleUrl, setStyleUrl] = useState("");
-  const [sourceLayersText, setSourceLayersText] = useState("");
+  const [tilesUrl, setTilesUrl] = useState(initialUrl);
+  const [styleUrl, setStyleUrl] = useState(initialStyleUrl);
+  const [sourceLayersText, setSourceLayersText] = useState(initialSourceLayers);
 
   // Cancel the in-flight metadata/style/collections fetches if the dialog closes
   // mid-request, so a slow response cannot add the layer after the user leaves.

apps/geolibre-desktop/src/components/layout/add-data/sources/WfsSource.tsx

@@ -31,19 +31,28 @@ interface WfsFormCache {
 }
 let wfsFormCache: WfsFormCache | null = null;
 
-export function WfsSource() {
+export function WfsSource({
+  initialUrl = "",
+  initialTypeName = "",
+}: {
+  initialUrl?: string;
+  initialTypeName?: string;
+}) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.wfs.defaultName"));
-  const [wfsEndpoint, setWfsEndpoint] = useState(wfsFormCache?.endpoint ?? "");
-  const [wfsTypeName, setWfsTypeName] = useState(wfsFormCache?.typeName ?? "");
+  const [wfsEndpoint, setWfsEndpoint] = useState(initialUrl || wfsFormCache?.endpoint || "");
+  // See WmsSource: a deep link's endpoint must not inherit the feature type or
+  // the retrieved type list cached from an unrelated service.
+  const serviceCache = initialUrl ? null : wfsFormCache;
+  const [wfsTypeName, setWfsTypeName] = useState(initialTypeName || (serviceCache?.typeName ?? ""));
   const [wfsVersion, setWfsVersion] = useState(wfsFormCache?.version ?? "2.0.0");
   const [wfsOutputFormat, setWfsOutputFormat] = useState(
     wfsFormCache?.outputFormat ?? "application/json",
   );
   const [wfsSrsName, setWfsSrsName] = useState(wfsFormCache?.srsName ?? "EPSG:4326");
   const [wfsMaxFeatures, setWfsMaxFeatures] = useState(wfsFormCache?.maxFeatures ?? "1000");
   const [typeOptions, setTypeOptions] = useState<WfsFeatureTypeOption[]>(
-    wfsFormCache?.options ?? [],
+    serviceCache?.options ?? [],
   );
   const [isRetrieving, setIsRetrieving] = useState(false);
   const [retrieveError, setRetrieveError] = useState<string | null>(null);

apps/geolibre-desktop/src/components/layout/add-data/sources/WmsSource.tsx

@@ -38,28 +38,40 @@ interface WmsFormCache {
 }
 let wmsFormCache: WmsFormCache | null = null;
 
-export function WmsSource() {
+export function WmsSource({
+  initialUrl = "",
+  initialLayers = "",
+}: {
+  initialUrl?: string;
+  initialLayers?: string;
+}) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.wms.defaultName"));
-  const [wmsEndpoint, setWmsEndpoint] = useState(wmsFormCache?.endpoint ?? "");
-  const [wmsLayers, setWmsLayers] = useState(wmsFormCache?.layers ?? "");
-  const [wmsStyles, setWmsStyles] = useState(wmsFormCache?.styles ?? "");
+  const [wmsEndpoint, setWmsEndpoint] = useState(initialUrl || wmsFormCache?.endpoint || "");
+  // A deep link brings its own service, so everything the cache holds *about a
+  // service* belongs to a different one: its layers, styles, retrieved layer
+  // list and negotiated version. Pairing a fresh endpoint with any of those
+  // would describe a service this form is no longer pointed at. Generic
+  // preferences (image format, transparency, tile size) still carry over.
+  const serviceCache = initialUrl ? null : wmsFormCache;
+  const [wmsLayers, setWmsLayers] = useState(initialLayers || (serviceCache?.layers ?? ""));
+  const [wmsStyles, setWmsStyles] = useState(serviceCache?.styles ?? "");
   const [wmsFormat, setWmsFormat] = useState(wmsFormCache?.format ?? "image/png");
   const [wmsTransparent, setWmsTransparent] = useState(wmsFormCache?.transparent ?? true);
   const [wmsTileSize, setWmsTileSize] = useState(wmsFormCache?.tileSize ?? "256");
-  const [wmsVersion, setWmsVersion] = useState(wmsFormCache?.version ?? "1.1.1");
+  const [wmsVersion, setWmsVersion] = useState(serviceCache?.version ?? "1.1.1");
   // True while the version has an explicit source — the selector, a pasted
   // URL's VERSION parameter, or a saved service entry. Capabilities
   // auto-detection only fills the version in when no explicit source exists.
   // Mirrored in a ref so the async retrieve handler reads the value current at
   // response time, not the one captured when the button was clicked.
-  const [versionTouched, setVersionTouched] = useState(wmsFormCache?.versionTouched ?? false);
+  const [versionTouched, setVersionTouched] = useState(serviceCache?.versionTouched ?? false);
   const versionTouchedRef = useRef(versionTouched);
   const markVersionTouched = (touched: boolean) => {
     versionTouchedRef.current = touched;
     setVersionTouched(touched);
   };
-  const [layerOptions, setLayerOptions] = useState<WmsLayerOption[]>(wmsFormCache?.options ?? []);
+  const [layerOptions, setLayerOptions] = useState<WmsLayerOption[]>(serviceCache?.options ?? []);
   const [isRetrieving, setIsRetrieving] = useState(false);
   const [retrieveError, setRetrieveError] = useState<string | null>(null);
   const layerListId = useId();

apps/geolibre-desktop/src/components/layout/add-data/sources/WmtsSource.tsx

@@ -7,10 +7,10 @@ import { ServiceLibrarySection } from "../ServiceLibrarySection";
 import { serviceFieldString, type ServiceFields } from "../service-library";
 import { AddDataSourceForm, SampleDataSelect, useAddDataSource } from "../shared";
 
-export function WmtsSource() {
+export function WmtsSource({ initialUrl = "" }: { initialUrl?: string }) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.wmts.defaultName"));
-  const [wmtsUrl, setWmtsUrl] = useState("");
+  const [wmtsUrl, setWmtsUrl] = useState(initialUrl);
   const [wmtsTileSize, setWmtsTileSize] = useState("256");
 
   const getFields = (): ServiceFields => ({

apps/geolibre-desktop/src/components/layout/add-data/sources/XyzSource.tsx

@@ -12,10 +12,10 @@ import { ServiceLibrarySection } from "../ServiceLibrarySection";
 import { serviceFieldBoolean, serviceFieldString, type ServiceFields } from "../service-library";
 import { AddDataSourceForm, SampleDataSelect, useAddDataSource } from "../shared";
 
-export function XyzSource() {
+export function XyzSource({ initialUrl = "" }: { initialUrl?: string }) {
   const { t } = useTranslation();
   const source = useAddDataSource(t("addData.xyz.defaultName"));
-  const [xyzUrl, setXyzUrl] = useState("");
+  const [xyzUrl, setXyzUrl] = useState(initialUrl);
   const [xyzTileSize, setXyzTileSize] = useState("256");
   const [xyzShortUrl, setXyzShortUrl] = useState(false);
 

apps/geolibre-desktop/src/hooks/useStartupProject.ts

@@ -1,7 +1,7 @@
 import { useAppStore, type MapProjection } from "@geolibre/core";
 import { useEffect, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { dataUrlParameters } from "../lib/data-url";
+import { dataUrlParameters, serviceUrlParameter } from "../lib/data-url";
 import { isTauri } from "../lib/is-tauri";
 import { projectUrlFromLocation } from "../lib/project-url";
 import { planStartup, startupDefaultProjection, type StartupPlan } from "../lib/startup-project";
@@ -36,6 +36,7 @@ const RESTORE_GATE_TIMEOUT_MS = 10_000;
 function hasExplicitLaunchPayload(): boolean {
   if (projectUrlFromLocation() !== null) return true;
   if (dataUrlParameters(window.location.search) !== null) return true;
+  if (serviceUrlParameter(window.location.search) !== null) return true;
   return false;
 }