operx-cli 0.1.0__tar.gz → 0.2.0__tar.gz

{operx_cli-0.1.0 → operx_cli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: operx-cli
-Version: 0.1.0
+Version: 0.2.0
 Summary: La línea de comandos de OperX: tu empresa desde la terminal, con tu token de API.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -8,6 +8,7 @@ Requires-Dist: typer>=0.27
 Requires-Dist: httpx>=0.28
 Requires-Dist: keyring>=25
 Requires-Dist: openpyxl>=3.1
+Requires-Dist: prompt_toolkit>=3.0
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 
@@ -19,38 +20,74 @@ tú, con tu rol, y solo en tu empresa.
 
 ## Instalar
 
-Necesitas Python 3.10 o más nuevo.
+Windows (PowerShell):
+
+```powershell
+powershell -c "irm https://astral.sh/uv/install.ps1 | iex"; uv tool install operx-cli
+```
+
+Mac y Linux:
 
 ```sh
-pipx install ./cli          # desde esta carpeta del repositorio
-operx --version
+curl -LsSf https://astral.sh/uv/install.sh | sh && uv tool install operx-cli
 ```
 
+`uv` instala su propio Python, así que no necesitas tener uno. Si ya tienes
+Python 3.10 o más nuevo, también sirve `pipx install operx-cli`. Abre una
+terminal nueva y comprueba con `operx --version`.
+
+Para actualizar: `uv tool upgrade operx-cli`.
+
 ## Entrar
 
-1. En la app, abre el menú de tu cuenta › **Acceso por API** y crea un token.
-   Elige *Lectura y escritura* si vas a crear o cambiar datos.
-2. Guárdalo en tu equipo:
+```sh
+operx login
+```
+
+1. La terminal muestra un código y abre el navegador en la página de OperX.
+2. Entras como siempre. La página dice qué terminal pide acceso: apruébalo solo
+   si acabas de escribir `operx login` en tu propio computador y el código es
+   el mismo. Escribe tu contraseña y elige *Solo lectura* o *Lectura y
+   escritura*.
+3. Vuelve a la terminal: ya entraste. Nunca ves ni copias un token.
 
-   ```sh
-   operx entrar        # pega el token; no se muestra
-   operx cuenta        # quién eres, tu empresa y tu rol
-   ```
+Tu rol necesita el permiso «Acceso por API» (Ajustes › Usuarios y acceso ›
+Roles); un administrador lo da. El acceso dura 90 días y lo ves, y puedes
+revocarlo, en el menú de tu cuenta › Acceso por API.
 
 El token queda en el llavero del sistema (en Windows, el Administrador de
-credenciales), nunca en un archivo. En un servidor sin llavero, usa variables
-de entorno: `OPERX_TOKEN` (el token) y, si no es producción, `OPERX_DIRECCION`.
+credenciales), nunca en un archivo. En un servidor sin navegador ni llavero:
+`operx login --token` te deja pegar un token creado en Acceso por API, o puedes
+usar variables de entorno: `OPERX_TOKEN` (el token) y, si no es producción,
+`OPERX_DIRECCION`.
 
 Para otra dirección u otra empresa, usa un perfil:
 
 ```sh
-operx --perfil pruebas entrar --direccion https://…
+operx --perfil pruebas login --direccion https://…
 operx --perfil pruebas ordenes listar
 ```
 
-`operx salir` borra el token de este equipo; para que deje de funcionar,
+`operx logout` borra el token de este equipo; para que deje de funcionar,
 revócalo en Acceso por API.
 
+## Modo interactivo
+
+Escribe `operx` solo, en una terminal, y se abre la pantalla de bienvenida
+(quién eres y los números de hoy: órdenes abiertas, vencidas, artículos bajo
+el mínimo) con un prompt. Ahí escribes los comandos sin el `operx`, con
+Tab para completar y ↑ para repetir lo anterior:
+
+```
+operx › ordenes listar --vencidas
+operx › buscar "bomba"
+operx › ayuda
+operx › salir
+```
+
+`salir` (o Ctrl+D) termina la sesión sin borrar tu token. En un script o una
+tubería, `operx` solo muestra la ayuda y no espera a nadie.
+
 ## Comandos
 
 ```sh
@@ -134,3 +171,21 @@ python -m venv .venv && .venv/Scripts/python -m pip install -e ".[test]"
 
 `operx_cli/client.py` es lo único que habla con la red; el servidor MCP lo
 usará igual.
+
+### Publicar una versión
+
+El paquete es `operx-cli` en PyPI. Una versión publicada no se puede reemplazar:
+si algo falla, se sube la siguiente.
+
+1. Sube el número en `pyproject.toml` y en `operx_cli/__init__.py`.
+2. Las funciones nuevas del servidor (como `operx login`) tienen que estar ya
+   desplegadas en producción antes de publicar: el paquete nuevo las llama.
+3. Desde `cli/`, con un entorno que tenga `build` y `twine`:
+
+   ```sh
+   python -m build
+   python -m twine upload dist/*     # usuario __token__, y el token del proyecto
+   ```
+
+El token de PyPI es secreto: se escribe en tu terminal, nunca en un archivo del
+repositorio ni en un chat.

{operx_cli-0.1.0 → operx_cli-0.2.0}/README.md

@@ -6,38 +6,74 @@ tú, con tu rol, y solo en tu empresa.
 
 ## Instalar
 
-Necesitas Python 3.10 o más nuevo.
+Windows (PowerShell):
+
+```powershell
+powershell -c "irm https://astral.sh/uv/install.ps1 | iex"; uv tool install operx-cli
+```
+
+Mac y Linux:
 
 ```sh
-pipx install ./cli          # desde esta carpeta del repositorio
-operx --version
+curl -LsSf https://astral.sh/uv/install.sh | sh && uv tool install operx-cli
 ```
 
+`uv` instala su propio Python, así que no necesitas tener uno. Si ya tienes
+Python 3.10 o más nuevo, también sirve `pipx install operx-cli`. Abre una
+terminal nueva y comprueba con `operx --version`.
+
+Para actualizar: `uv tool upgrade operx-cli`.
+
 ## Entrar
 
-1. En la app, abre el menú de tu cuenta › **Acceso por API** y crea un token.
-   Elige *Lectura y escritura* si vas a crear o cambiar datos.
-2. Guárdalo en tu equipo:
+```sh
+operx login
+```
+
+1. La terminal muestra un código y abre el navegador en la página de OperX.
+2. Entras como siempre. La página dice qué terminal pide acceso: apruébalo solo
+   si acabas de escribir `operx login` en tu propio computador y el código es
+   el mismo. Escribe tu contraseña y elige *Solo lectura* o *Lectura y
+   escritura*.
+3. Vuelve a la terminal: ya entraste. Nunca ves ni copias un token.
 
-   ```sh
-   operx entrar        # pega el token; no se muestra
-   operx cuenta        # quién eres, tu empresa y tu rol
-   ```
+Tu rol necesita el permiso «Acceso por API» (Ajustes › Usuarios y acceso ›
+Roles); un administrador lo da. El acceso dura 90 días y lo ves, y puedes
+revocarlo, en el menú de tu cuenta › Acceso por API.
 
 El token queda en el llavero del sistema (en Windows, el Administrador de
-credenciales), nunca en un archivo. En un servidor sin llavero, usa variables
-de entorno: `OPERX_TOKEN` (el token) y, si no es producción, `OPERX_DIRECCION`.
+credenciales), nunca en un archivo. En un servidor sin navegador ni llavero:
+`operx login --token` te deja pegar un token creado en Acceso por API, o puedes
+usar variables de entorno: `OPERX_TOKEN` (el token) y, si no es producción,
+`OPERX_DIRECCION`.
 
 Para otra dirección u otra empresa, usa un perfil:
 
 ```sh
-operx --perfil pruebas entrar --direccion https://…
+operx --perfil pruebas login --direccion https://…
 operx --perfil pruebas ordenes listar
 ```
 
-`operx salir` borra el token de este equipo; para que deje de funcionar,
+`operx logout` borra el token de este equipo; para que deje de funcionar,
 revócalo en Acceso por API.
 
+## Modo interactivo
+
+Escribe `operx` solo, en una terminal, y se abre la pantalla de bienvenida
+(quién eres y los números de hoy: órdenes abiertas, vencidas, artículos bajo
+el mínimo) con un prompt. Ahí escribes los comandos sin el `operx`, con
+Tab para completar y ↑ para repetir lo anterior:
+
+```
+operx › ordenes listar --vencidas
+operx › buscar "bomba"
+operx › ayuda
+operx › salir
+```
+
+`salir` (o Ctrl+D) termina la sesión sin borrar tu token. En un script o una
+tubería, `operx` solo muestra la ayuda y no espera a nadie.
+
 ## Comandos
 
 ```sh
@@ -121,3 +157,21 @@ python -m venv .venv && .venv/Scripts/python -m pip install -e ".[test]"
 
 `operx_cli/client.py` es lo único que habla con la red; el servidor MCP lo
 usará igual.
+
+### Publicar una versión
+
+El paquete es `operx-cli` en PyPI. Una versión publicada no se puede reemplazar:
+si algo falla, se sube la siguiente.
+
+1. Sube el número en `pyproject.toml` y en `operx_cli/__init__.py`.
+2. Las funciones nuevas del servidor (como `operx login`) tienen que estar ya
+   desplegadas en producción antes de publicar: el paquete nuevo las llama.
+3. Desde `cli/`, con un entorno que tenga `build` y `twine`:
+
+   ```sh
+   python -m build
+   python -m twine upload dist/*     # usuario __token__, y el token del proyecto
+   ```
+
+El token de PyPI es secreto: se escribe en tu terminal, nunca en un archivo del
+repositorio ni en un chat.

{operx_cli-0.1.0 → operx_cli-0.2.0}/operx_cli/__init__.py

@@ -2,4 +2,4 @@
 API (backend/users/api_allowlist.py) from a terminal, with a personal API
 token."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{operx_cli-0.1.0 → operx_cli-0.2.0}/operx_cli/app.py

@@ -1,13 +1,15 @@
 """`operx`: the root of the commands, and what turns a refused call into
 one line instead of a traceback."""
 
+import errno
+import os
 import sys
 from typing import Annotated, Optional
 
 import typer
 from typer.core import TyperGroup
 
-from . import __version__, settings
+from . import __version__, settings, shell
 from .client import ApiError
 from .commands import account, inventario, lecturas, ordenes, personas, raw, registros, search
 from .commands.common import CliError, Session
@@ -18,6 +20,24 @@ from .spreadsheet import SpreadsheetError
 EXPECTED_ERRORS = (ApiError, CliError, NoSingleMatch, SpreadsheetError, settings.SettingsError)
 
 
+def _is_closed_pipe(error):
+    """What writing to a pipe whose reader left raises: BrokenPipeError (EPIPE),
+    and on Windows a bare EINVAL. That EINVAL names no file: a bad file name
+    raises the same errno with the name in it, and must not be hidden."""
+    if isinstance(error, BrokenPipeError) or error.errno == errno.EPIPE:
+        return True
+    return error.errno == errno.EINVAL and error.filename is None
+
+
+def _silence_stdout():
+    """Python flushes stdout once more on the way out, which would print
+    "Exception ignored…" over the quiet exit: point it at nothing."""
+    try:
+        os.dup2(os.open(os.devnull, os.O_WRONLY), sys.stdout.fileno())
+    except (OSError, ValueError, AttributeError):
+        pass
+
+
 class ReportedErrors(TyperGroup):
     def invoke(self, ctx):
         try:
@@ -25,16 +45,23 @@ class ReportedErrors(TyperGroup):
         except EXPECTED_ERRORS as error:
             typer.echo(f"Error: {error}", err=True)
             raise typer.Exit(1) from None
-        except typer.Abort:
+        except (typer.Abort, KeyboardInterrupt):
             # Ctrl+C, or a question whose answer never came.
             typer.echo("Se canceló.", err=True)
             raise typer.Exit(1) from None
+        except OSError as error:
+            if not _is_closed_pipe(error):
+                raise
+            # `operx … | head`: whoever reads left before the end. Not an error.
+            _silence_stdout()
+            raise typer.Exit(0) from None
 
 
 app = typer.Typer(
     cls=ReportedErrors,
     help="OperX desde la terminal: tu empresa con tu token de API.",
-    no_args_is_help=True,
+    # `operx` alone is the welcome and the prompt (root below), not the help.
+    no_args_is_help=False,
     add_completion=False,
     context_settings={"help_option_names": ["-h", "--help"]},
     # A crash must never print the token, which lives in the client's locals.
@@ -48,7 +75,13 @@ def _show_version(value):
         raise typer.Exit()
 
 
-@app.callback()
+def is_interactive():
+    """A person at a terminal, not a script or a pipe: only then does a prompt
+    make sense."""
+    return sys.stdin.isatty() and sys.stdout.isatty()
+
+
+@app.callback(invoke_without_command=True)
 def root(
     ctx: typer.Context,
     perfil: Annotated[
@@ -61,11 +94,33 @@ def root(
 ):
     if ctx.obj is None:
         ctx.obj = Session()
-    ctx.obj.profile = settings.profile_name(perfil)
+        ctx.obj.profile = settings.profile_name(perfil)
+    elif perfil:
+        ctx.obj.profile = perfil
+    # Else the interactive mode's session, which already has its profile:
+    # every line typed runs this callback again and must not reset it.
+    if ctx.invoked_subcommand is None:
+        open_the_prompt(ctx)
+
+
+def open_the_prompt(ctx):
+    """`operx` alone: at a terminal, the welcome and the prompt; in a script
+    or a pipe, the help (a prompt would hang it)."""
+    if ctx.obj.in_shell:
+        # Typed at the prompt (`--perfil staging`): it already did what it
+        # says; a second prompt must not open inside the first.
+        return
+    if not is_interactive() and ctx.obj.reader is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+    shell.enter(ctx.obj, ctx.command)
 
 
-app.command()(account.entrar)
-app.command()(account.salir)
+app.command()(account.login)
+app.command()(account.logout)
+# The first version's names, for whoever typed them: out of the help.
+app.command(name="entrar", hidden=True)(account.entrar)
+app.command(name="salir", hidden=True)(account.logout)
 app.command()(account.cuenta)
 app.command()(search.buscar)
 app.command()(raw.api)

operx_cli-0.2.0/operx_cli/browser_login.py

@@ -0,0 +1,91 @@
+"""`operx login`: signing in through the browser, the way `gh auth login`
+does it (backend users/cli_login.py).
+
+The terminal asks the server for a login and shows the person a short code;
+the person opens the page, signs in as always and approves it; the terminal,
+asking every few seconds, gets a personal API token that the person never
+sees or copies. Nothing here is saved until the server hands the token over.
+"""
+
+import socket
+from datetime import datetime
+
+import typer
+
+from .client import ApiError, error_message
+from .commands.common import CliError
+
+NOT_A_WEB_ADDRESS = "El servidor devolvió una dirección que no es una página web, y no se abrió. No se guardó nada."
+
+# Why a login ended without a token, by what the server's poll said.
+ENDINGS = {
+    "denied": "Se rechazó el acceso en el navegador. No se guardó nada.",
+    "expired": "El código venció. Escribe `operx login` otra vez para pedir uno nuevo.",
+    "no_access": "Tu rol no tiene acceso por API. Pídele a un administrador de tu empresa el permiso «Acceso por API».",
+}
+
+
+def ask_for_login(client):
+    """The server's answer to a new login: the secret to poll with, the code
+    and page to show, how often to ask and how long it lasts."""
+    started = client.send("POST", "auth/cli-login/start", json={"client_name": socket.gethostname()}).json()
+    # The terminal opens this in the person's browser: only a web page.
+    if not str(started.get("verification_url", "")).lower().startswith(("https://", "http://")):
+        raise CliError(NOT_A_WEB_ADDRESS)
+    return started
+
+
+def show_how_to_approve(started, opened):
+    typer.echo("")
+    typer.echo("  Para entrar, abre esta página y escribe el código:")
+    typer.echo("")
+    typer.echo(f"      {started['verification_url']}        código  {started['user_code']}")
+    typer.echo("")
+    typer.echo("  Abriendo el navegador…" if opened else "  Abre la página en tu navegador.")
+    typer.echo("  Esperando que lo apruebes… (Ctrl+C para cancelar)")
+
+
+def try_to_open(open_browser, address):
+    """The browser, if this computer has one: a server has none, and the
+    person can open the page anywhere."""
+    try:
+        return bool(open_browser(address))
+    except Exception:
+        return False
+
+
+def wait_for_approval(client, session, started):
+    """Polls until the person answers or the code runs out; the token's answer."""
+    interval = started["interval"]
+    waited = 0
+    while waited < started["expires_in"]:
+        answer = client.send("POST", "auth/cli-login/poll", json={"device_code": started["device_code"]}, check=False)
+        body = _json_of(answer)
+        if answer.status_code == 200:
+            return body
+        if answer.status_code == 202:
+            # The server may ask for more time between asks ("slow_down").
+            interval = body.get("interval", interval)
+            session.sleep(interval)
+            waited += interval
+            continue
+        ending = ENDINGS.get(body.get("status"))
+        if ending is None:
+            raise ApiError(answer.status_code, error_message(answer))
+        raise CliError(ending)
+    raise CliError(ENDINGS["expired"])
+
+
+def _json_of(answer):
+    try:
+        body = answer.json()
+    except ValueError:
+        return {}
+    return body if isinstance(body, dict) else {}
+
+
+def access_line(scope, expires_at):
+    """'Acceso de lectura y escritura · vence el 20/01/2027'."""
+    what = "lectura y escritura" if scope == "write" else "solo lectura"
+    expires = datetime.fromisoformat(expires_at.replace("Z", "+00:00")).astimezone()
+    return f"Acceso de {what} · vence el {expires:%d/%m/%Y}"

{operx_cli-0.1.0 → operx_cli-0.2.0}/operx_cli/client.py

@@ -23,7 +23,7 @@ PAGE_SIZE = 200
 RETRIES_ON_429 = 3
 LONGEST_WAIT = 60
 
-SIGN_IN_AGAIN = "Entra de nuevo con `operx entrar`."
+SIGN_IN_AGAIN = "Entra de nuevo con `operx login`."
 TIMED_OUT_WRITE = (
     "La API no respondió a tiempo. Revisa en la app si el cambio quedó hecho antes de repetirlo."
 )
@@ -77,15 +77,17 @@ class ApiClient:
     def __init__(self, address, token, transport=None, sleep=time.sleep):
         self.address = address.rstrip("/")
         self.sleep = sleep
-        self.http = httpx.Client(
-            base_url=self.address + "/api/v1/",
-            headers={"Authorization": f"Bearer {token}", "User-Agent": USER_AGENT, "Accept": "application/json"},
-            timeout=60,
-            transport=transport,
-        )
-
-    def send(self, method, path, params=None, json=None, files=None, data=None):
-        """One call; its answer, or ApiError when the API refused it."""
+        headers = {"User-Agent": USER_AGENT, "Accept": "application/json"}
+        # No token (the login's first calls): no header at all. An empty
+        # "Bearer " makes the server's JWT check raise instead of answering.
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+        self.http = httpx.Client(base_url=self.address + "/api/v1/", headers=headers, timeout=60, transport=transport)
+
+    def send(self, method, path, params=None, json=None, files=None, data=None, check=True):
+        """One call; its answer, or ApiError when the API refused it. With
+        check=False the answer comes back whatever its status, for a call
+        whose status is its protocol (the login's poll)."""
         method = method.upper()
         headers = {"Idempotency-Key": str(uuid.uuid4())} if method in WRITES else {}
         waits = 0
@@ -95,7 +97,7 @@ class ApiClient:
                 break
             self.sleep(seconds_to_wait(response))
             waits += 1
-        if response.status_code >= 400:
+        if check and response.status_code >= 400:
             message = error_message(response)
             if response.status_code == 401:
                 message = f"{message}\n{SIGN_IN_AGAIN}"

{operx_cli-0.1.0 → operx_cli-0.2.0}/operx_cli/commands/account.py

@@ -1,13 +1,13 @@
-"""`operx entrar`, `operx salir` and `operx cuenta`: the token of a profile,
+"""`operx login`, `operx logout` and `operx cuenta`: the token of a profile,
 and who it acts as."""
 
+import os
 from typing import Annotated, Optional
 
 import typer
 
-from .. import settings
-from ..client import ApiClient
-from ..output import print_record
+from .. import browser_login, settings
+from ..output import note, print_record
 from .common import CliError, JsonOption, Session, client_of
 
 TOKEN_PREFIX = "opx_"
@@ -21,29 +21,65 @@ def full_name(me):
     return " ".join(f"{me.get('first_name', '')} {me.get('last_name', '')}".split()) or me.get("email", "")
 
 
-def entrar(
+def login(
     ctx: typer.Context,
     direccion: Annotated[
         Optional[str], typer.Option("--direccion", help="La dirección de la API. Sin ella, la de producción.")
     ] = None,
+    con_token: Annotated[
+        bool, typer.Option("--token", help="Pega un token en vez de abrir el navegador (para un servidor sin navegador).")
+    ] = False,
 ):
-    """Guarda tu token de API en el llavero del sistema. Créalo en la app: menú de tu cuenta › Acceso por API."""
+    """Entra con tu cuenta: abre el navegador, apruebas el código y listo. Nunca ves ni copias un token."""
     session = ctx.find_object(Session)
-    token = typer.prompt("Pega tu token (no se mostrará)", hide_input=True).strip()
-    if not token.startswith(TOKEN_PREFIX):
-        raise CliError("Eso no es un token de OperX: empieza por «opx_». Créalo en la app, en Acceso por API.")
     address = direccion.rstrip("/") if direccion else session.address()
-    # Checked before it's kept: a token the API refuses is never saved.
-    me = ApiClient(address, token, transport=session.transport).get("auth/me")
+    if os.environ.get("OPERX_TOKEN"):
+        note("Ojo: OPERX_TOKEN está definido y gana sobre el token que se guarde aquí.")
+    if con_token:
+        token = _pasted_token()
+        me = session.client_with(address, token).get("auth/me")
+        extra = None
+    else:
+        token, me, extra = _token_from_browser(session, address)
+    # Kept only after the API accepted it.
     settings.save_token(session.profile, token)
     if direccion:
         settings.save_address(session.profile, address)
-    typer.echo(f"Listo: entraste como {full_name(me)} en {me.get('client_name')}.")
+    company = str(me.get("client_name") or "tu empresa")
+    typer.echo(f"Entraste como {full_name(me)} en {company}" + ("" if company.endswith(".") else "."))
+    if extra:
+        typer.echo(extra)
     typer.echo(f"Perfil «{session.profile}», {address}.")
 
 
-def salir(ctx: typer.Context):
-    """Borra el token de este perfil del llavero. El token sigue vivo: revócalo en Acceso por API si ya no lo usas."""
+def _pasted_token():
+    token = typer.prompt("Pega tu token (no se mostrará)", hide_input=True).strip()
+    if not token.startswith(TOKEN_PREFIX):
+        raise CliError("Eso no es un token de OperX: empieza por «opx_». Créalo en la app, en Acceso por API.")
+    return token
+
+
+def _token_from_browser(session, address):
+    anonymous = session.client_with(address, None)
+    started = browser_login.ask_for_login(anonymous)
+    opened = browser_login.try_to_open(session.open_browser, started["verification_url"])
+    browser_login.show_how_to_approve(started, opened)
+    approved = browser_login.wait_for_approval(anonymous, session, started)
+    me = session.client_with(address, approved["key"]).get("auth/me")
+    return approved["key"], me, browser_login.access_line(approved["scope"], approved["expires_at"])
+
+
+def entrar(
+    ctx: typer.Context,
+    direccion: Annotated[Optional[str], typer.Option("--direccion")] = None,
+):
+    """The first version's name for `login --token`: it reads a pasted token,
+    as it did, so a script that piped one in doesn't wait for a browser."""
+    login(ctx, direccion=direccion, con_token=True)
+
+
+def logout(ctx: typer.Context):
+    """Borra el token de este equipo. El token sigue vivo: revócalo en Acceso por API si ya no lo usas."""
     session = ctx.find_object(Session)
     settings.forget_token(session.profile)
     typer.echo(f"Se borró el token del perfil «{session.profile}».")

{operx_cli-0.1.0 → operx_cli-0.2.0}/operx_cli/commands/common.py

@@ -3,6 +3,8 @@ options that choose how results are shown, and the question before a
 write."""
 
 import sys
+import time
+import webbrowser
 from dataclasses import dataclass
 from typing import Annotated, Optional
 
@@ -13,7 +15,7 @@ from ..client import ApiClient
 from ..output import note
 from ..values import decimal_text, iso_date, iso_datetime
 
-NOT_SIGNED_IN = "No has entrado en este perfil. Usa `operx entrar` con un token de Acceso por API."
+NOT_SIGNED_IN = "No has entrado en este perfil. Escribe `operx login`."
 NEEDS_SI = "Esto cambia datos de tu empresa. Fuera de una terminal agrega --si para confirmarlo."
 
 
@@ -26,6 +28,14 @@ class Session:
     profile: str = settings.DEFAULT_PROFILE
     # httpx's transport: None goes to the network; the tests pass a fake API.
     transport: object = None
+    # What waits and what opens the browser, in the tests' hands too.
+    open_browser: object = webbrowser.open
+    sleep: object = time.sleep
+    # Reads a line at the interactive prompt; None: the terminal's own.
+    reader: object = None
+    # While the interactive prompt runs: what is typed there must not open
+    # another one.
+    in_shell: bool = False
 
     def address(self):
         return settings.address_of(self.profile)
@@ -34,7 +44,11 @@ class Session:
         token = settings.token_of(self.profile)
         if not token:
             raise CliError(NOT_SIGNED_IN)
-        return ApiClient(self.address(), token, transport=self.transport)
+        return ApiClient(self.address(), token, transport=self.transport, sleep=self.sleep)
+
+    def client_with(self, address, token):
+        """A client for an address and a token not saved (yet): the login's."""
+        return ApiClient(address, token, transport=self.transport, sleep=self.sleep)
 
 
 def client_of(ctx):