splent-cli 1.22.2__tar.gz → 1.23.0__tar.gz

{splent_cli-1.22.2/src/splent_cli.egg-info → splent_cli-1.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.22.2
+Version: 1.23.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 Project-URL: Homepage, https://github.com/diverso-lab/splent_cli

{splent_cli-1.22.2 → splent_cli-1.23.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.22.2"
+version = "1.23.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/check/check_contracts.py

@@ -17,6 +17,7 @@ import click
 import tomllib
 
 from splent_cli.services import context, marketplace, spl_store
+from splent_cli.utils import forge
 
 
 def _snapshot_version_key(pyproject_path: Path) -> tuple:
@@ -65,7 +66,7 @@ def _local_contract_requires(workspace: str, package: str) -> list[str] | None:
 
 
 def _exists_remotely(org: str | None, package: str) -> bool:
-    """Whether a feature not present locally at least exists on GitHub.
+    """Whether a feature not present locally at least exists on the forge.
 
     Answers True whenever the question cannot be settled: no org to look
     under, no network, a rate limit, anything unexpected. A diagnostic that
@@ -78,10 +79,27 @@ def _exists_remotely(org: str | None, package: str) -> bool:
     import urllib.error
     import urllib.request
 
-    # The UVL writes the org the way GitHub spells it ("splent-io"), which is
-    # not the way the filesystem does ("splent_io"), so it is used verbatim.
-    url = f"https://github.com/{org}/{package}"
-    request = urllib.request.Request(url, method="HEAD")
+    # The UVL writes the org the way the forge spells it ("splent-io"), which
+    # is not the way the filesystem does ("splent_io"), so it is used verbatim.
+    #
+    # GitHub keeps the anonymous HEAD against the web URL it has always used.
+    # A self-hosted forge is far likelier to keep its repositories private, and
+    # a private repository answers 404 to a stranger, which would read here as
+    # a feature nobody ever wrote. When such a forge gives us a token we ask
+    # its API instead, with GET because Gitea-compatible routes are registered
+    # for GET alone and answer a HEAD with 405.
+    token = None if forge.is_github() else forge.token()
+    if token:
+        request = urllib.request.Request(
+            f"{forge.api_base()}/repos/{org}/{package}",
+            headers={
+                "Authorization": f"token {token}",
+                "Accept": "application/json",
+                "User-Agent": "splent-cli",
+            },
+        )
+    else:
+        request = urllib.request.Request(forge.web_url(org, package), method="HEAD")
     try:
         with urllib.request.urlopen(request, timeout=10) as response:
             return response.status < 400
@@ -230,7 +248,7 @@ def check_contracts(spl_name):
             click.secho(
                 f"  ✗ {short} is offered by the model but does not exist: "
                 f"{meta.get('org')}/{meta['package']} is not in this workspace, "
-                f"not in the cache and not on GitHub",
+                f"not in the cache and not on {forge.host()}",
                 fg="red",
             )
             click.echo(

splent_cli-1.23.0/src/splent_cli/commands/check/check_github.py

@@ -0,0 +1,126 @@
+import os
+import urllib.request
+import urllib.error
+import json
+import click
+
+from splent_cli.utils import forge
+
+
+@click.command(
+    "check:github",
+    short_help="Verify forge credentials from .env (GITHUB_USER / forge token)",
+)
+def check_github():
+    # The command keeps its name, but the forge it checks is whatever the
+    # workspace is configured against: github.com by default, a self-hosted
+    # Forgejo when SPLENT_FORGE_HOST says so.
+    forge_host = forge.host()
+    token_var = forge.token_env_name()
+
+    click.echo(click.style(f"\n{forge_host} Credentials Check\n", fg="cyan", bold=True))
+
+    user = os.getenv("GITHUB_USER", "").strip()
+    # Resolved through forge so a self-hosted forge reads SPLENT_FORGE_TOKEN
+    # while GitHub keeps reading GITHUB_TOKEN, as it always has.
+    token = (forge.token() or "").strip()
+
+    # --- presence checks ---
+    if not user:
+        click.echo(click.style("[✖] ", fg="red") + "GITHUB_USER not set in .env")
+        click.secho(
+            "   Run 'splent tokens:setup' for setup instructions.", fg="bright_black"
+        )
+        raise SystemExit(1)
+    click.echo(click.style("[✔] ", fg="green") + f"GITHUB_USER = {user}")
+
+    if not token:
+        click.echo(click.style("[✖] ", fg="red") + f"{token_var} not set in .env")
+        click.secho(
+            "   Run 'splent tokens:setup' for setup instructions.", fg="bright_black"
+        )
+        raise SystemExit(1)
+
+    masked = token[:4] + "*" * (len(token) - 8) + token[-4:]
+    click.echo(click.style("[✔] ", fg="green") + f"{token_var} = {masked}")
+
+    # --- API call ---
+    # Vendor media types are GitHub's own; a Gitea-compatible forge does not
+    # know them and answers plain JSON, so they are only sent to GitHub.
+    headers = {
+        "Authorization": f"token {token}",
+        "Accept": "application/json",
+        "User-Agent": "splent-cli",
+    }
+    if forge.is_github():
+        headers["Accept"] = "application/vnd.github+json"
+        headers["X-GitHub-Api-Version"] = "2022-11-28"
+
+    click.echo(f"\nContacting the {forge_host} API...")
+    req = urllib.request.Request(f"{forge.api_base()}/user", headers=headers)
+
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            rate_remaining = resp.headers.get("X-RateLimit-Remaining", "?")
+            rate_limit = resp.headers.get("X-RateLimit-Limit", "?")
+    except urllib.error.HTTPError as e:
+        if e.code == 401:
+            click.echo(
+                click.style("[✖] ", fg="red")
+                + "Token invalid or expired (401 Unauthorized)"
+            )
+            click.secho(
+                "   Run 'splent tokens:setup' for instructions on obtaining a valid token.",
+                fg="bright_black",
+            )
+        elif e.code == 403:
+            click.echo(
+                click.style("[✖] ", fg="red")
+                + "Token lacks required permissions (403 Forbidden)"
+            )
+            scope = "repo" if forge.is_github() else "write:repository"
+            click.secho(
+                f"   Run 'splent tokens:setup', the token needs the '{scope}' scope.",
+                fg="bright_black",
+            )
+        else:
+            click.echo(
+                click.style("[✖] ", fg="red") + f"{forge_host} API error: HTTP {e.code}"
+            )
+        raise SystemExit(1)
+    except urllib.error.URLError as e:
+        click.echo(click.style("[✖] ", fg="red") + f"Network error: {e.reason}")
+        raise SystemExit(1)
+
+    # --- validate identity ---
+    api_login = data.get("login", "")
+    if api_login.lower() != user.lower():
+        click.echo(
+            click.style("[⚠] ", fg="yellow")
+            + f"Token belongs to '{api_login}', but GITHUB_USER is '{user}'"
+        )
+    else:
+        click.echo(click.style("[✔] ", fg="green") + f"Authenticated as {api_login}")
+
+    # GitHub calls the display name "name"; a Gitea-compatible forge calls it
+    # "full_name", so without the fallback every Forgejo check reported "-".
+    name = data.get("name") or data.get("full_name") or "-"
+    click.echo(click.style("[✔] ", fg="green") + f"Name: {name}")
+
+    # The plan and the rate limit headers are GitHub's alone. A Gitea-compatible
+    # forge answers /user without either, and printing "-" and "?/? remaining"
+    # would read as a fault rather than as an absence.
+    if forge.is_github():
+        plan = (data.get("plan") or {}).get("name", "-")
+        click.echo(click.style("[✔] ", fg="green") + f"Plan: {plan}")
+        click.echo(
+            click.style("[✔] ", fg="green")
+            + f"Rate limit: {rate_remaining}/{rate_limit} remaining"
+        )
+
+    click.echo()
+    click.secho(f"Credentials for {forge_host} OK.", fg="green")
+
+
+cli_command = check_github

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/feature/feature_fork.py

@@ -5,32 +5,46 @@ import requests
 from splent_cli.commands.feature.feature_clone import feature_clone
 from splent_cli.utils.cache_utils import make_feature_writable
 from splent_cli.services import context
+from splent_cli.utils import forge
 from splent_cli.utils.feature_utils import normalize_namespace
 
 
+def _forge_label() -> str:
+    """How to name the forge in a message: the brand on GitHub, the host elsewhere."""
+    return "GitHub" if forge.is_github() else forge.host()
+
+
 @click.command(
     "feature:fork",
-    short_help="Fork a feature on GitHub and clone it locally",
+    short_help="Fork a feature on the forge and clone it locally",
 )
 @click.argument("feature_name", required=True)
 @click.option(
     "--version", "-v", default="v1.0.0", help="Feature version (default: v1.0.0)"
 )
 def feature_fork(feature_name, version):
-    token = os.getenv("GITHUB_TOKEN")
+    token = forge.token()
     github_user = os.getenv("GITHUB_USER")
 
     if not token or not github_user:
-        click.secho("✖ Error: GITHUB_TOKEN and GITHUB_USER must be set", fg="red")
+        click.secho(
+            f"✖ Error: {forge.token_env_name()} and GITHUB_USER must be set", fg="red"
+        )
         raise SystemExit(1)
 
-    upstream_owner = "splent-io"
-    api_url = f"https://api.github.com/repos/{upstream_owner}/{feature_name}/forks"
+    upstream_owner = os.getenv("SPLENT_DEFAULT_ORG", "splent-io")
+    api_url = f"{forge.api_base()}/repos/{upstream_owner}/{feature_name}/forks"
     headers = {
         "Authorization": f"token {token}",
-        "Accept": "application/vnd.github+json",
+        "Accept": (
+            "application/vnd.github+json" if forge.is_github() else "application/json"
+        ),
     }
 
+    # `default_branch_only` is a GitHub-only key. Gitea-compatible forges reject
+    # nothing but understand nothing either, so they get an empty body.
+    payload = {"default_branch_only": False} if forge.is_github() else {}
+
     click.secho(
         f"🔁 Forking {upstream_owner}/{feature_name} into {github_user}...", fg="cyan"
     )
@@ -38,17 +52,17 @@ def feature_fork(feature_name, version):
         resp = requests.post(
             api_url,
             headers=headers,
-            json={"default_branch_only": False},
+            json=payload,
             timeout=30,
         )
     except requests.RequestException as e:
-        click.secho(f"❌ Could not reach GitHub: {e}", fg="red")
+        click.secho(f"❌ Could not reach {_forge_label()}: {e}", fg="red")
         raise SystemExit(2)
 
     if resp.status_code in (403, 429):
         click.secho(
-            "⚠ GitHub API rate limit or access denied. "
-            "Set GITHUB_TOKEN to a token with repo scope and try again.",
+            f"⚠ {_forge_label()} API rate limit or access denied. "
+            f"Set {forge.token_env_name()} to a token with repo scope and try again.",
             fg="yellow",
         )
         if os.getenv("SPLENT_DEBUG"):
@@ -73,22 +87,24 @@ def feature_fork(feature_name, version):
         raise SystemExit(2)
     click.secho(f"🌐 Fork created: {fork_html_url}", fg="green")
 
-    # Esperar a que GitHub lo procese
+    # Esperar a que la forja lo procese
     for i in range(5):
         try:
             r = requests.get(
-                f"https://api.github.com/repos/{github_user}/{feature_name}",
+                f"{forge.api_base()}/repos/{github_user}/{feature_name}",
                 headers=headers,
                 timeout=30,
             )
         except requests.RequestException as e:
-            click.secho(f"⌛ Waiting for GitHub to process fork... ({e})", fg="yellow")
+            click.secho(
+                f"⌛ Waiting for {_forge_label()} to process fork... ({e})", fg="yellow"
+            )
             time.sleep(3)
             continue
         if r.status_code == 200:
             click.secho("✅ Fork is ready.", fg="green")
             break
-        click.secho("⌛ Waiting for GitHub to process fork...", fg="yellow")
+        click.secho(f"⌛ Waiting for {_forge_label()} to process fork...", fg="yellow")
         time.sleep(3)
     else:
         click.secho("⚠ Fork may still be processing.", fg="yellow")

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/feature/feature_release.py

@@ -138,7 +138,12 @@ def _extract_templates(src_dir: Path) -> list[str]:
 
 
 def _extract_template_hook_slots(src_dir: Path) -> list[str]:
-    """Extract hook slot names declared in templates via get_template_hooks(...)."""
+    """Extract hook slot names declared in templates.
+
+    A template opens a slot either by iterating ``get_template_hooks(name)``
+    or by asking for the joined output with ``render_template_hooks(name)``
+    (the form used when the template keeps a fallback for an empty slot).
+    """
     templates_dir = src_dir / "templates"
     if not templates_dir.exists():
         return []
@@ -146,7 +151,9 @@ def _extract_template_hook_slots(src_dir: Path) -> list[str]:
     for html_file in templates_dir.rglob("*.html"):
         text = html_file.read_text()
         slots.update(
-            re.findall(r"""get_template_hooks\s*\(\s*['"]([^'"]+)['"]""", text)
+            re.findall(
+                r"""(?:get|render)_template_hooks\s*\(\s*['"]([^'"]+)['"]""", text
+            )
         )
     return sorted(slots)
 

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/feature/feature_unlock.py

@@ -4,6 +4,7 @@ import tomllib
 import click
 import requests
 from splent_cli.services import context, compose
+from splent_cli.utils import forge
 from splent_cli.utils.cache_utils import make_feature_writable
 from splent_cli.utils.proc import run
 from splent_cli.utils.io_utils import load_toml, atomic_write
@@ -62,6 +63,9 @@ def _git_out(path: str, *args) -> subprocess.CompletedProcess:
 def ensure_git_main(path: str, ns_git: str, name: str):
     from splent_cli.utils.git_url import build_git_url
 
+    # build_git_url() resolves the host and transport through the forge module,
+    # so rewriting origin here is also what repoints a checkout cloned from a
+    # previous forge at the one the workspace is configured for now.
     remote_url, _ = build_git_url(ns_git, name)
     r = _git_out(path, "remote", "get-url", "origin")
     if r.returncode == 0:
@@ -193,18 +197,20 @@ def _compile_assets(workspace: str, product_path: str, name: str):
 # =====================================================================
 def _warn_no_push_access(ns_git: str, name: str):
     """Print a warning if the user cannot push to the repo. Non-blocking."""
-    token = os.getenv("GITHUB_TOKEN")
+    token = forge.token()
     if not token:
         return  # no token = can't check, don't nag
 
     headers = {
-        "Accept": "application/vnd.github+json",
+        "Accept": (
+            "application/vnd.github+json" if forge.is_github() else "application/json"
+        ),
         "Authorization": f"token {token}",
         "User-Agent": "splent-cli",
     }
     try:
         resp = requests.get(
-            f"https://api.github.com/repos/{ns_git}/{name}",
+            f"{forge.api_base()}/repos/{ns_git}/{name}",
             headers=headers,
             timeout=5,
         )

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/product/product_build.py

@@ -644,6 +644,24 @@ def product_build(no_image, skip_preflight):
 
             click.echo(f"\n🐳 Building Docker image: {product}:{version}...")
 
+            # A feature that is not published to PyPI is installed from git
+            # inside the builder stage, and the URL for that is built from the
+            # forge settings. The build sees none of the workspace environment,
+            # so forward whichever of them is configured. The token is
+            # deliberately not forwarded: a build arg is recorded in the image
+            # metadata, so the repositories reached this way must be readable
+            # anonymously.
+            forge_args = []
+            for var in (
+                "SPLENT_FORGE_HOST",
+                "SPLENT_FORGE_SSH_HOST",
+                "SPLENT_FORGE_SSH_PORT",
+                "SPLENT_FORGE_API",
+            ):
+                value = os.getenv(var)
+                if value:
+                    forge_args += ["--build-arg", f"{var}={value}"]
+
             try:
                 subprocess.run(
                     [
@@ -653,6 +671,7 @@ def product_build(no_image, skip_preflight):
                         f"{product}:{version}",
                         "-t",
                         f"{product}:latest",
+                        *forge_args,
                         "-f",
                         dockerfile,
                         workspace,

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/commands/tokens_setup.py

@@ -1,9 +1,11 @@
 import click
 
+from splent_cli.utils import forge
+
 
 @click.command(
     "tokens:setup",
-    short_help="Print setup instructions for GitHub and PyPI tokens.",
+    short_help="Print setup instructions for the git forge and PyPI tokens.",
 )
 def tokens():
     """
@@ -14,21 +16,39 @@ def tokens():
     click.secho("  Required tokens for SPLENT", bold=True)
     click.echo(click.style(f"  {'─' * 56}", fg="bright_black"))
 
-    # ── GitHub ────────────────────────────────────────────────────────
+    # ── Forge ─────────────────────────────────────────────────────────
+    # The variable to set, the settings path and the scopes all depend on the
+    # forge this workspace points at, so the section is written from forge
+    # instead of from a github.com literal.
     click.echo()
-    click.secho("  GITHUB_TOKEN", fg="cyan", bold=True)
+    click.secho(f"  {forge.token_env_name()}", fg="cyan", bold=True)
     click.echo("  Used by: feature:release, feature:versions, feature:upgrade,")
     click.echo("           feature:search, check:github")
     click.echo()
     click.echo("  How to get it:")
-    click.echo("    1. Go to github.com → Settings → Developer settings")
-    click.echo("       → Personal access tokens → Tokens (classic)")
-    click.echo("    2. Generate new token (classic)")
-    click.echo("    3. Enable scope: repo  (full control of private repos)")
-    click.echo("    4. Copy the token (shown only once)")
-    click.echo()
-    click.secho("  Add to your .env:", fg="bright_black")
-    click.echo("    GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxx")
+    if forge.is_github():
+        click.echo("    1. Go to github.com → Settings → Developer settings")
+        click.echo("       → Personal access tokens → Tokens (classic)")
+        click.echo("    2. Generate new token (classic)")
+        click.echo("    3. Enable scope: repo  (full control of private repos)")
+        click.echo("    4. Copy the token (shown only once)")
+        click.echo()
+        click.secho("  Add to your .env:", fg="bright_black")
+        click.echo(f"    {forge.token_env_name()}=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxx")
+    else:
+        # Forgejo and Gitea keep tokens under Applications, and their scopes are
+        # per resource instead of GitHub's single 'repo'. Releasing a feature
+        # writes to a repository and, for an org-owned one, to the org itself.
+        click.echo(f"    1. Go to {forge.host()} → Settings → Applications")
+        click.echo("       → Access Tokens")
+        click.echo("    2. Generate new token")
+        click.echo("    3. Enable scopes: write:repository and write:organization")
+        click.echo("    4. Copy the token (shown only once)")
+        click.echo()
+        click.secho("  Add to your .env:", fg="bright_black")
+        click.echo(
+            f"    {forge.token_env_name()}=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+        )
 
     # ── PyPI ──────────────────────────────────────────────────────────
     click.echo()

{splent_cli-1.22.2 → splent_cli-1.23.0}/src/splent_cli/services/index_refresh.py

@@ -1,16 +1,24 @@
 """Ask the marketplace index to rebuild itself.
 
 The published index is what the marketplace serves, and it is built by a
-GitHub Actions workflow that runs on a push to its own repository, on a
-schedule, or on demand. A feature release or an SPL publication happens in
-a different repository, so neither of them used to reach it: the index
-caught up on the next cron run, hours later, and the only way to see a
-release in production sooner was to press the button by hand.
+CI workflow that runs on a push to its own repository, on a schedule, or
+on demand. A feature release or an SPL publication happens in a different
+repository, so neither of them used to reach it: the index caught up on
+the next cron run, hours later, and the only way to see a release in
+production sooner was to press the button by hand.
 
 Releasing now asks for the rebuild as its last step. It is deliberately
 best effort: the release itself is already done and irreversible by then,
 so a token without workflow scope, or a network that is down, is reported
 and never turns a finished release into a failure.
+
+Asking on demand is one POST to the workflow dispatch endpoint, which
+GitHub and Gitea-compatible forges spell the same way and answer to the
+same ``{"ref": ...}`` body. Only the headers differ, since GitHub's vendor
+media type and API version pin mean nothing elsewhere and the credential
+is read from the ``token`` scheme rather than ``Bearer``. A forge that
+does not implement the endpoint answers 404, which is already handled the
+same way as any other refusal.
 """
 
 import json
@@ -20,6 +28,8 @@ import urllib.request
 
 import click
 
+from splent_cli.utils import forge
+
 INDEX_REPO = os.getenv("SPLENT_INDEX_REPO", "splent-io/splent_index")
 INDEX_WORKFLOW = os.getenv("SPLENT_INDEX_WORKFLOW", "build-index.yml")
 INDEX_REF = os.getenv("SPLENT_INDEX_REF", "main")
@@ -28,22 +38,46 @@ TIMEOUT_SECONDS = 15
 
 def _api_url() -> str:
     return (
-        f"https://api.github.com/repos/{INDEX_REPO}"
+        f"{forge.api_base()}/repos/{INDEX_REPO}"
         f"/actions/workflows/{INDEX_WORKFLOW}/dispatches"
     )
 
 
+def _headers(token: str) -> dict:
+    """Request headers in the forge's own spelling.
+
+    GitHub wants its vendor media type, its API version pin and a bearer
+    credential. A Gitea-compatible forge understands none of the three and
+    reads the credential from the ``token`` scheme, so it gets plain JSON.
+    """
+    if forge.is_github():
+        return {
+            "Accept": "application/vnd.github+json",
+            "Authorization": f"Bearer {token}",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+            "User-Agent": "splent-cli",
+        }
+    return {
+        "Accept": "application/json",
+        "Authorization": f"token {token}",
+        "Content-Type": "application/json",
+        "User-Agent": "splent-cli",
+    }
+
+
 def request_rebuild(*, quiet: bool = False) -> bool:
-    """Trigger the index build workflow. True when GitHub accepted it.
+    """Trigger the index build workflow. True when the forge accepted it.
 
     Never raises: the caller has already published something.
     """
-    token = os.getenv("GITHUB_TOKEN")
+    token = forge.token()
     if not token:
         if not quiet:
             click.secho(
-                "  index    no GITHUB_TOKEN, so the marketplace index was not "
-                "asked to rebuild. It will catch up on its own schedule.",
+                f"  index    no {forge.token_env_name()}, so the marketplace "
+                "index was not asked to rebuild. It will catch up on its own "
+                "schedule.",
                 fg="yellow",
             )
         return False
@@ -52,13 +86,7 @@ def request_rebuild(*, quiet: bool = False) -> bool:
         _api_url(),
         data=json.dumps({"ref": INDEX_REF}).encode(),
         method="POST",
-        headers={
-            "Accept": "application/vnd.github+json",
-            "Authorization": f"Bearer {token}",
-            "X-GitHub-Api-Version": "2022-11-28",
-            "Content-Type": "application/json",
-            "User-Agent": "splent-cli",
-        },
+        headers=_headers(token),
     )
 
     try:
@@ -66,11 +94,13 @@ def request_rebuild(*, quiet: bool = False) -> bool:
             accepted = response.status in (200, 201, 204)
     except urllib.error.HTTPError as error:
         if not quiet:
-            hint = (
-                " The token needs the workflow scope."
-                if error.code in (403, 404)
-                else ""
-            )
+            hint = ""
+            if error.code in (403, 404):
+                hint = (
+                    " The token needs the workflow scope."
+                    if forge.is_github()
+                    else " The token needs write access to the index repository."
+                )
             click.secho(
                 f"  index    the marketplace index refused the rebuild "
                 f"({error.code}).{hint} It will catch up on its own schedule.",
@@ -80,8 +110,8 @@ def request_rebuild(*, quiet: bool = False) -> bool:
     except Exception:
         if not quiet:
             click.secho(
-                "  index    could not reach GitHub to rebuild the marketplace "
-                "index. It will catch up on its own schedule.",
+                f"  index    could not reach {forge.host()} to rebuild the "
+                "marketplace index. It will catch up on its own schedule.",
                 fg="yellow",
             )
         return False