snowflake-sandbox-python 0.2.2a4__py3-none-any.whl → 0.2.2a6__py3-none-any.whl

snowflake/cli_sandbox/_egress_flags.py

@@ -10,14 +10,10 @@ Spellings, chosen to match what the CLI already does elsewhere:
 * ``--eai NAME`` — repeatable, like ``--env``. Names an External Access Integration
   whose network rules the platform resolves; that is the only way to reach a host
   outside the built-in baseline.
-* ``--secret ENV_VAR=DB.SCHEMA.NAME@host[,host]`` — repeatable. The env var comes
+* ``--secret ENV_VAR=DB.SCHEMA.NAME[@host[,host]]`` — repeatable. The env var comes
   first because that is the order ``--env KEY=VAL`` established, and it is the half
-  you read inside the sandbox. Omitting ``ENV_VAR=`` takes the SDK's derived
-  ``CNG_SECRET_<FQN>`` name. The ``@host`` scopes where the credential may be sent and
-  is **always required**: the SDK refuses an unscoped credential rather than let it
-  egress anywhere. (Its error text says ``host=`` becomes optional once an EAI supplies
-  the hosts — that is not implemented; an EAI does not relax the requirement, verified
-  against `compile_egress`.)
+  you read inside the sandbox. The ``@host`` scopes where the credential may be sent
+  and is required unless an ``--eai`` supplies the host grant.
 * ``--no-default-egress`` — the closed level: Snowflake and its stages only, no
   baseline package-manager hosts. An ``--eai`` still grants on top of it, which is
   why this is not called ``--no-egress``.
@@ -27,7 +23,7 @@ from __future__ import annotations
 
 import typer
 
-from snowflake.sandbox.egress import Egress, compile_egress
+from snowflake.sandbox.egress import Egress, compile_egress, compile_secrets
 from snowflake.sandbox.secret import Secret
 
 __all__ = ["EAI_HELP", "NO_DEFAULT_EGRESS_HELP", "SECRET_HELP", "build_egress"]
@@ -38,10 +34,17 @@ EAI_HELP = (
     "readable or the platform refuses the create."
 )
 
+OUTBOUND_WIF_HOST_HELP = (
+    "Host that gets a Snowflake workload identity token as Authorization: Bearer, so it "
+    "can verify the calling account without a stored secret; repeatable. An exact host "
+    "or a leading-dot suffix (.example.com). It does not open egress: the host must also "
+    "be reachable, e.g. through --eai."
+)
+
 SECRET_HELP = (
-    "Snowflake SECRET to inject, as ENV_VAR=DB.SCHEMA.NAME@host[,host]; repeatable. "
-    "The @host scopes where the credential may be sent and is required. Omit ENV_VAR= "
-    "for the derived CNG_SECRET_<FQN> name."
+    "Snowflake SECRET to inject, as ENV_VAR=DB.SCHEMA.NAME[@host[,host]]; repeatable. "
+    "The @host scopes where the credential may be sent and is required unless an "
+    "--eai supplies the host grant. ENV_VAR= is required."
 )
 
 NO_DEFAULT_EGRESS_HELP = (
@@ -64,6 +67,8 @@ def _parse_secret(raw: str) -> Secret:
         env_var, spec = env_var.strip(), spec.strip()
         if not env_var:
             raise typer.BadParameter(f"empty env var in {raw!r} (expected ENV_VAR=DB.SCHEMA.NAME)")
+    else:
+        raise typer.BadParameter(f"{raw!r}: expected ENV_VAR=DB.SCHEMA.NAME[@host]")
 
     hosts: tuple[str, ...] = ()
     if "@" in spec:
@@ -89,38 +94,42 @@ def build_egress(
     eai: list[str] | None,
     secret: list[str] | None,
     no_default_egress: bool,
+    outbound_wif_host: list[str] | None = None,
 ) -> tuple[Egress | None, tuple[Secret, ...]]:
     """`(egress, secrets)` for these flags — both empty when none were given.
 
     Two values because that is the shape `Sandbox.create()` takes: secrets are authored
-    alongside egress but are their own argument (they nest under egress only on the
-    wire, where `compile_egress` puts them).
+    alongside egress and sent as their own top-level create field.
 
     `None` rather than an empty `Egress` when nothing was passed, so the create body
     stays byte-identical to today's for every existing caller.
     """
     integrations = tuple(dict.fromkeys(name.strip() for name in (eai or []) if name.strip()))
     secrets = tuple(_parse_secret(raw) for raw in (secret or []))
-    if not integrations and not secrets and not no_default_egress:
+    wif_hosts = tuple(dict.fromkeys(h.strip() for h in (outbound_wif_host or []) if h.strip()))
+    if not integrations and not secrets and not no_default_egress and not wif_hosts:
         return None, ()
 
-    egress = Egress(
-        external_access_integrations=integrations,
-        # Uses the current parameter name. The CLI FLAG stays `--no-default-egress`: it is
-        # released, renaming it would break users' scripts, and that is a separate decision
-        # from the library parameter's name. So the flag spelling and the parameter spelling
-        # differ here deliberately — the alternative is the CLI depending on a deprecated
-        # parameter, which is worse.
-        **({"allow_public_package_registries": False} if no_default_egress else {}),
-    )
     # Validate now, not at create time. `compile_egress` is pure and is what the client
     # runs anyway -- but it runs *after* connecting, so a mistyped host pair otherwise
     # costs a Snowflake round trip before saying so. These are usage errors; they should
-    # cost nothing.
+    # cost nothing. Egress() is inside the try too: it rejects a bad --outbound-wif-host.
     from snowflake.sandbox.exceptions import SandboxError
 
     try:
-        compile_egress(egress, secrets)
+        egress = Egress(
+            external_access_integrations=integrations,
+            # Uses the current parameter name. The CLI FLAG stays `--no-default-egress`: it
+            # is released, renaming it would break users' scripts, and that is a separate
+            # decision from the library parameter's name. So the flag spelling and the
+            # parameter spelling differ here deliberately — the alternative is the CLI
+            # depending on a deprecated parameter, which is worse. None is unset, which
+            # sends nothing for the level.
+            allow_public_package_registries=False if no_default_egress else None,
+            outbound_wif_hosts=wif_hosts,
+        )
+        compile_egress(egress, ())
+        compile_secrets(secrets, has_eai=bool(integrations))
     except SandboxError as exc:
         raise typer.BadParameter(str(exc)) from exc
     return egress, secrets

snowflake/cli_sandbox/_git_repo_flags.py

@@ -0,0 +1,58 @@
+"""`--git-repo` / `--git-integration`: mount Git repositories into a run's sandbox.
+
+* ``--git-repo URL[=MOUNT_PATH]`` — repeatable. The first ``=`` starts the mount path.
+* ``--git-integration NAME`` — the ``EXTERNAL_APPLICATION`` integration every
+  ``--git-repo`` is cloned through, one per run.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+if TYPE_CHECKING:
+    from snowflake.sandbox.git_repo import GitRepo
+
+__all__ = ["GIT_INTEGRATION_HELP", "GIT_REPO_HELP", "build_git_repos"]
+
+GIT_REPO_HELP = (
+    "Git repository to mount, as an https URL with an optional =MOUNT_PATH "
+    "(default /mnt/repos/<repo>); repeatable. Needs --git-integration. The default "
+    "branch is mounted writable, and git push from the sandbox has no credential."
+)
+
+GIT_INTEGRATION_HELP = (
+    "Snowflake EXTERNAL_APPLICATION integration that every --git-repo is cloned "
+    "through, with your own authorization of it."
+)
+
+
+def build_git_repos(raw: list[str] | None, integration: str | None) -> tuple[GitRepo, ...]:
+    """The `GitRepo`s for these flags, or a `typer.BadParameter`."""
+    from snowflake.sandbox.exceptions import SandboxError
+    from snowflake.sandbox.git_repo import GitRepo, validate_git_repos
+
+    if not raw:
+        if integration:
+            raise typer.BadParameter("--git-integration needs at least one --git-repo.")
+        return ()
+    if not integration:
+        raise typer.BadParameter(
+            "--git-repo needs --git-integration NAME, the EXTERNAL_APPLICATION "
+            "integration the repository is cloned through."
+        )
+    repos: list[GitRepo] = []
+    for spec in raw:
+        url, _, mount_path = spec.strip().partition("=")
+        try:
+            repos.append(
+                GitRepo(url.strip(), integration=integration, mount_path=mount_path.strip())
+            )
+        except SandboxError as exc:
+            raise typer.BadParameter(f"--git-repo {spec!r}: {exc}") from exc
+    try:
+        validate_git_repos(repos)
+    except SandboxError as exc:
+        raise typer.BadParameter(f"--git-repo: {exc}") from exc
+    return tuple(repos)

snowflake/cli_sandbox/_lifecycle_command.py

@@ -0,0 +1,108 @@
+"""``snow sandbox suspend`` and ``snow sandbox resume``.
+
+The CLI counterparts to ``Sandbox.suspend()`` / ``Sandbox.resume()``. Snowflake
+suspends an idle sandbox on its own timer; these let an operator bank a sandbox's
+state on demand, and wake one without running anything in it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+
+# From _common, where these are DEFINED. Importing them via _get_command (which
+# re-exports them) is an implicit re-export and mypy rejects it.
+from snowflake.cli_sandbox._common import (
+    _CONN_HELP,
+    _USE_SNOW_CONN_HELP,
+    _apply_connection,
+    _resolve_sandbox_id,
+)
+
+
+def _suspend_command(
+    sandbox: str = typer.Argument(..., help="Sandbox name (or id) to suspend."),
+    use_snow_connection: bool = typer.Option(
+        True,
+        "--use-snow-connection/--no-snow-connection",
+        help=_USE_SNOW_CONN_HELP,
+    ),
+    connection: str | None = typer.Option(
+        None,
+        "--connection",
+        "-c",
+        help=_CONN_HELP,
+    ),
+    **options: Any,
+) -> None:
+    """Suspend a sandbox: snapshot its filesystem and tear the container down.
+
+    The sandbox keeps its files; the next thing that touches it brings it back on
+    that snapshot with a fresh process tree. Already-suspended is success.
+
+    Example:
+        snow sandbox suspend SANDBOX
+    """
+    from snowflake.cli_sandbox._adapter import sdk_connection
+    from snowflake.sandbox.exceptions import SandboxError
+    from snowflake.sandbox.sync_client import get_sandbox
+
+    _apply_connection(use_snow_connection, connection)
+    try:
+        # The SYNC client: AsyncSandbox.connect is itself a coroutine, so a bare
+        # asyncio.run(sb.suspend()) on its result would fail on a coroutine object.
+        # get_sandbox(), not Sandbox.connect(): _resolve_sandbox_id already turned a
+        # name into a cntr_ id, and connect() resolves its argument as a NAME -- so
+        # feeding it an id fails with "no sandbox named cntr_...".
+        #
+        # The SYNC client throughout: AsyncSandbox.connect is itself a coroutine, so a
+        # bare asyncio.run(sb.suspend()) on its result fails on a coroutine object.
+        get_sandbox(_resolve_sandbox_id(sandbox), connection=sdk_connection()).suspend()
+    except SandboxError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(f"suspended {sandbox}")
+
+
+def _resume_command(
+    sandbox: str = typer.Argument(..., help="Sandbox name (or id) to resume."),
+    use_snow_connection: bool = typer.Option(
+        True,
+        "--use-snow-connection/--no-snow-connection",
+        help=_USE_SNOW_CONN_HELP,
+    ),
+    connection: str | None = typer.Option(
+        None,
+        "--connection",
+        "-c",
+        help=_CONN_HELP,
+    ),
+    **options: Any,
+) -> None:
+    """Wake a suspended sandbox without running anything in it.
+
+    Rarely needed -- anything that touches a sandbox resumes it anyway -- so this
+    is for paying the cold start up front. Returns once the resume is under way,
+    not once the sandbox is serving.
+
+    Example:
+        snow sandbox resume SANDBOX
+    """
+    from snowflake.cli_sandbox._adapter import sdk_connection
+    from snowflake.sandbox.exceptions import SandboxError
+    from snowflake.sandbox.sync_client import get_sandbox
+
+    _apply_connection(use_snow_connection, connection)
+    try:
+        # get_sandbox(), not Sandbox.connect(): _resolve_sandbox_id already turned a
+        # name into a cntr_ id, and connect() resolves its argument as a NAME.
+        get_sandbox(_resolve_sandbox_id(sandbox), connection=sdk_connection()).resume()
+    except SandboxError as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    typer.echo(f"resuming {sandbox}")
+
+
+_SUSPEND_HELP = "Suspend a sandbox, snapshotting its filesystem.\n\nExample:\n    snow sandbox suspend SANDBOX\n"
+_RESUME_HELP = "Resume a suspended sandbox.\n\nExample:\n    snow sandbox resume SANDBOX\n"

snowflake/cli_sandbox/_remote_command.py

@@ -0,0 +1,168 @@
+"""CLI entry points for SSH, local TCP forwarding and the desktop page."""
+
+from __future__ import annotations
+
+import asyncio
+import sys
+from contextlib import redirect_stdout
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import typer
+
+from snowflake.cli_sandbox._common import (
+    _CONN_HELP,
+    _USE_SNOW_CONN_HELP,
+    _apply_connection,
+    _resolve_sandbox_id,
+)
+from snowflake.sandbox.exceptions import SandboxError
+
+if TYPE_CHECKING:
+    from snowflake.sandbox.config import Config
+
+_SSH_HELP = "Connect with OpenSSH over an authenticated sandbox tunnel. Requires OpenSSH on PATH.\n\nExample:\n    snow sandbox ssh my-sandbox\n    snow sandbox ssh my-sandbox --cmd 'uname -a'"
+_PORT_FORWARD_HELP = "Forward a loopback TCP port to a port inside an existing sandbox.\n\nExample:\n    snow sandbox port-forward my-sandbox 8080 --local-port 18080"
+_DESKTOP_HELP = "Open the remote desktop page for an existing sandbox.\n\nExample:\n    snow sandbox desktop my-sandbox\n    snow sandbox desktop my-sandbox --no-open"
+
+
+def _remote_config(use_snow_connection: bool, connection: str | None) -> Config:
+    from snowflake.cli_sandbox._adapter import sdk_connection
+    from snowflake.sandbox.config import resolve_config
+
+    _apply_connection(use_snow_connection, connection=connection)
+    return resolve_config(connection=sdk_connection())
+
+
+def _ssh_command(
+    sandbox_id: str = typer.Argument(..., help="Existing sandbox name or app id."),
+    user: str = typer.Option("root", "--user", help="SSH login user inside the sandbox."),
+    cmd: str | None = typer.Option(
+        None, "--cmd", help="Remote command; omit for an interactive SSH session."
+    ),
+    use_snow_connection: bool = typer.Option(
+        True, "--use-snow-connection/--no-snow-connection", help=_USE_SNOW_CONN_HELP
+    ),
+    connection: str | None = typer.Option(None, "--connection", "-c", help=_CONN_HELP),
+    proxy: bool = typer.Option(False, "--proxy", hidden=True),
+    identity: Path | None = typer.Option(None, "--identity", hidden=True),
+    known_hosts: Path | None = typer.Option(None, "--known-hosts", hidden=True),
+    **options: Any,
+) -> None:
+    from snowflake.sandbox._preview import preview_url
+    from snowflake.sandbox._ssh import run_ssh, ssh_proxy
+    from snowflake.sandbox._tunnel import resolve_remote_url
+
+    try:
+        if sandbox_id.startswith("cntr_"):
+            preview_url(sandbox_id, 8079, "org-account.example")
+        if proxy and (identity is None or known_hosts is None):
+            raise typer.BadParameter("--proxy requires --identity and --known-hosts")
+        if proxy or not sandbox_id.startswith("cntr_"):
+            # Connector/browser-login notices must not enter the SSH stream.
+            with redirect_stdout(sys.stderr):
+                config = _remote_config(use_snow_connection, connection)
+                sandbox_id = _resolve_sandbox_id(sandbox_id)
+        # Validate before key generation or spawning a process.
+        preview_url(sandbox_id, 8079, "org-account.example")
+        if proxy:
+            if identity is None or known_hosts is None:
+                raise typer.BadParameter("--proxy requires --identity and --known-hosts")
+
+            async def pump() -> None:
+                with redirect_stdout(sys.stderr):
+                    url = await resolve_remote_url(sandbox_id, config, service="ssh")
+                await ssh_proxy(
+                    url, config, identity=identity, known_hosts=known_hosts, alias=sandbox_id
+                )
+
+            asyncio.run(pump())
+            code = 0
+        else:
+            code = run_ssh(
+                sandbox_id,
+                user=user,
+                command=cmd,
+                connection=connection,
+                use_snow_connection=use_snow_connection,
+            )
+    except KeyboardInterrupt:
+        raise typer.Exit(130) from None
+    except (SandboxError, OSError) as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    raise typer.Exit(code)
+
+
+def _port_forward_command(
+    sandbox_id: str = typer.Argument(..., help="Existing sandbox name or app id."),
+    port: int = typer.Argument(..., help="TCP port inside the sandbox."),
+    local_port: int | None = typer.Option(
+        None, "--local-port", help="Loopback port to listen on (default: remote port)."
+    ),
+    use_snow_connection: bool = typer.Option(
+        True, "--use-snow-connection/--no-snow-connection", help=_USE_SNOW_CONN_HELP
+    ),
+    connection: str | None = typer.Option(None, "--connection", "-c", help=_CONN_HELP),
+    **options: Any,
+) -> None:
+    from snowflake.sandbox._preview import validate_preview_port
+    from snowflake.sandbox._tunnel import forward_port, remote_url, resolve_remote_url
+
+    try:
+        remote_url(
+            sandbox_id if sandbox_id.startswith("cntr_") else "cntr_validation",
+            "org-account.example",
+            port=port,
+        )
+        listen_port = validate_preview_port(port if local_port is None else local_port)
+        config = _remote_config(use_snow_connection, connection)
+        sandbox_id = _resolve_sandbox_id(sandbox_id)
+
+        async def forward() -> None:
+            url = await resolve_remote_url(sandbox_id, config, port=port)
+            await forward_port(
+                url,
+                config,
+                port=port,
+                local_port=listen_port,
+                ready=lambda bound: typer.echo(
+                    f"Forwarding 127.0.0.1:{bound} to {sandbox_id}:{port}", err=True
+                ),
+            )
+
+        asyncio.run(forward())
+    except KeyboardInterrupt:
+        raise typer.Exit(130) from None
+    except (SandboxError, OSError) as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+
+
+def _desktop_command(
+    sandbox_id: str = typer.Argument(..., help="Existing sandbox name or app id."),
+    no_open: bool = typer.Option(
+        False, "--no-open", help="Print the desktop URL without opening a browser."
+    ),
+    use_snow_connection: bool = typer.Option(
+        True, "--use-snow-connection/--no-snow-connection", help=_USE_SNOW_CONN_HELP
+    ),
+    connection: str | None = typer.Option(None, "--connection", "-c", help=_CONN_HELP),
+    **options: Any,
+) -> None:
+    import webbrowser
+
+    from snowflake.sandbox._tunnel import remote_url, resolve_remote_url
+
+    try:
+        if sandbox_id.startswith("cntr_"):
+            remote_url(sandbox_id, "org-account.example", service="desktop")
+        config = _remote_config(use_snow_connection, connection)
+        sandbox_id = _resolve_sandbox_id(sandbox_id)
+        url = asyncio.run(resolve_remote_url(sandbox_id, config, service="desktop"))
+        typer.echo(url)
+        if not no_open:
+            webbrowser.open(url)
+    except (SandboxError, OSError) as exc:
+        typer.echo(f"error: {exc}", err=True)
+        raise typer.Exit(1) from exc

snowflake/cli_sandbox/_run_command.py

@@ -62,9 +62,15 @@ from snowflake.cli_sandbox._common import (
 from snowflake.cli_sandbox._egress_flags import (
     EAI_HELP,
     NO_DEFAULT_EGRESS_HELP,
+    OUTBOUND_WIF_HOST_HELP,
     SECRET_HELP,
     build_egress,
 )
+from snowflake.cli_sandbox._git_repo_flags import (
+    GIT_INTEGRATION_HELP,
+    GIT_REPO_HELP,
+    build_git_repos,
+)
 from snowflake.cli_sandbox._shell_command import (
     _emit_status,
     _exec_streaming,
@@ -323,6 +329,10 @@ def _print_inferred_plan(plan: _RunPlan) -> None:
         if plan.secrets:
             bits.append(f"secrets={len(plan.secrets)}")
         typer.echo(f"egress:     {' '.join(b for b in bits if b)}")
+    for repo in plan.git_repos:
+        typer.echo(
+            f"git repo:   {repo.url} -> {repo.resolved_mount_path} (integration {repo.integration})"  # type: ignore[attr-defined]
+        )
     if plan.upload is not None:
         typer.echo(
             f"upload:     {plan.upload.file_count} file(s), "
@@ -359,6 +369,7 @@ class _RunPlan:
     env: dict[str, str]
     egress: object | None  # Egress | None -- typed loosely to keep the SDK import lazy
     secrets: tuple[object, ...]
+    git_repos: tuple[object, ...]  # GitRepo, typed loosely like egress
     quiet: bool
 
 
@@ -373,6 +384,8 @@ def _reject_app_incompatible_flags(
     eai: list[str] | None,
     secret: list[str] | None,
     nde: bool,
+    outbound_wif_host: list[str] | None = None,
+    git_repo: list[str] | None = None,
 ) -> None:
     """Everything an App module declares for itself, and so cannot be told from a flag.
 
@@ -399,12 +412,19 @@ def _reject_app_incompatible_flags(
             raise typer.BadParameter(
                 f"{flag} applies only to local code; an App declares its own bundle."
             )
-    for flag, value in (("--eai", eai), ("--secret", secret), ("--no-default-egress", nde)):
+    for flag, value in (
+        ("--eai", eai),
+        ("--secret", secret),
+        ("--no-default-egress", nde),
+        ("--outbound-wif-host", outbound_wif_host),
+    ):
         if value:
             raise typer.BadParameter(
                 f"{flag} does not apply to an App module; an App declares its own egress "
                 f"and secrets in code (see @app.function(egress=..., secrets=...))."
             )
+    if git_repo:
+        raise typer.BadParameter("--git-repo applies only to an image or local-code run.")
 
 
 def _reject_inapplicable_flags(
@@ -421,6 +441,8 @@ def _reject_inapplicable_flags(
     eai: list[str] | None = None,
     secret: list[str] | None = None,
     nde: bool = False,
+    outbound_wif_host: list[str] | None = None,
+    git_repo: list[str] | None = None,
 ) -> None:
     """Reject flag combinations that cannot take effect, loudly rather than silently.
 
@@ -438,6 +460,8 @@ def _reject_inapplicable_flags(
             eai=eai,
             secret=secret,
             nde=nde,
+            outbound_wif_host=outbound_wif_host,
+            git_repo=git_repo,
         )
     elif function is not None:
         raise typer.BadParameter("--function applies only to an App module (--app).")
@@ -540,6 +564,9 @@ def _plan_from_args(
     eai: list[str] | None = None,
     secret: list[str] | None = None,
     no_default_egress: bool = False,
+    outbound_wif_host: list[str] | None = None,
+    git_repo: list[str] | None = None,
+    git_integration: str | None = None,
     quiet: bool = False,
 ) -> _RunPlan:
     """Validate the flags and settle a `_RunPlan` (raising `typer.BadParameter`).
@@ -570,7 +597,10 @@ def _plan_from_args(
         eai=eai,
         secret=secret,
         nde=no_default_egress,
+        outbound_wif_host=outbound_wif_host,
+        git_repo=git_repo,
     )
+    git_repos = build_git_repos(git_repo, git_integration)
 
     env_overrides: dict[str, str] = {}
     for raw in envs or []:
@@ -581,7 +611,10 @@ def _plan_from_args(
     # silently overridden rather than merged -- rejected above in
     # `_reject_inapplicable_flags`, which is why this can run unconditionally.
     egress_cfg, secret_objs = build_egress(
-        eai=eai, secret=secret, no_default_egress=no_default_egress
+        eai=eai,
+        secret=secret,
+        no_default_egress=no_default_egress,
+        outbound_wif_host=outbound_wif_host,
     )
 
     upload: UploadPlan | None = None
@@ -661,6 +694,7 @@ def _plan_from_args(
         env=env_overrides,
         egress=egress_cfg,
         secrets=secret_objs,
+        git_repos=git_repos,
         quiet=quiet,
     )
 
@@ -807,6 +841,7 @@ async def _run_job(plan: _RunPlan) -> int:
         env=plan.env or None,
         egress=plan.egress,  # type: ignore[arg-type]  # Egress | None, lazily typed
         secrets=plan.secrets,  # type: ignore[arg-type]
+        git_repos=plan.git_repos,  # type: ignore[arg-type]
     )
 
 
@@ -830,6 +865,7 @@ async def _run_detached_image(plan: _RunPlan) -> None:
         env=plan.env or None,
         egress=plan.egress,  # type: ignore[arg-type]  # Egress | None, lazily typed
         secrets=plan.secrets,  # type: ignore[arg-type]
+        git_repos=plan.git_repos,  # type: ignore[arg-type]
         name=plan.name,
         command=command,
         idle_suspend=plan.idle_suspend,
@@ -867,6 +903,7 @@ async def _run_detached_local(plan: _RunPlan) -> None:
         env=plan.env or None,
         egress=plan.egress,  # type: ignore[arg-type]  # Egress | None, lazily typed
         secrets=plan.secrets,  # type: ignore[arg-type]
+        git_repos=plan.git_repos,  # type: ignore[arg-type]
         name=plan.name,
         idle_suspend=plan.idle_suspend,
     )
@@ -997,7 +1034,7 @@ def _run_command(
     secret: list[str] | None = typer.Option(
         None,
         "--secret",
-        metavar="ENV_VAR=DB.SCHEMA.NAME",
+        metavar="ENV_VAR=DB.SCHEMA.NAME[@host]",
         help=SECRET_HELP,
     ),
     no_default_egress: bool = typer.Option(
@@ -1005,6 +1042,27 @@ def _run_command(
         "--no-default-egress",
         help=NO_DEFAULT_EGRESS_HELP,
     ),
+    outbound_wif_host: list[str] | None = typer.Option(
+        None,
+        "--outbound-wif-host",
+        metavar="HOST",
+        help=OUTBOUND_WIF_HOST_HELP,
+        hidden=True,  # unreleased; see CONTRIBUTING "Hiding an unreleased parameter"
+    ),
+    git_repo: list[str] | None = typer.Option(
+        None,
+        "--git-repo",
+        metavar="URL[=MOUNT_PATH]",
+        help=GIT_REPO_HELP,
+        hidden=True,  # unreleased; see CONTRIBUTING "Hiding an unreleased parameter"
+    ),
+    git_integration: str | None = typer.Option(
+        None,
+        "--git-integration",
+        metavar="NAME",
+        help=GIT_INTEGRATION_HELP,
+        hidden=True,
+    ),
     allow_large: bool = typer.Option(
         False,
         "--allow-large",
@@ -1076,6 +1134,9 @@ def _run_command(
         eai=eai,
         secret=secret,
         no_default_egress=no_default_egress,
+        outbound_wif_host=outbound_wif_host,
+        git_repo=git_repo,
+        git_integration=git_integration,
         quiet=quiet,
     )
     _hint_app_module(plan)