lighthouse-cli 0.16.0__tar.gz → 0.17.0__tar.gz

{lighthouse_cli-0.16.0/lighthouse_cli.egg-info → lighthouse_cli-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lighthouse-cli
-Version: 0.16.0
+Version: 0.17.0
 Summary: The LightHouse command line: sign in, connect your estate, deploy agents, watch runs
 License-Expression: Apache-2.0
 Classifier: Programming Language :: Python :: 3
@@ -18,6 +18,4 @@ Requires-Dist: ruff==0.16.10; extra == "dev"
 Requires-Dist: mypy==2.4.0; extra == "dev"
 Requires-Dist: bandit[toml]==1.9.4; extra == "dev"
 Requires-Dist: jsonschema==4.25.1; extra == "dev"
-Provides-Extra: build
-Requires-Dist: pyinstaller==6.22.3; extra == "build"
 Dynamic: license-file

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/README.md

@@ -23,25 +23,20 @@ evidence:
 | **The control plane is Python.** The service, its OpenAPI generator and its MCP server are all `aal_control`. The CLI's integration tests therefore run **in process against the very application that is deployed** (`service/tests/test_cli_integration.py`) — the real routes, the real OAuth, the real row-level security, no stack to boot and no stub to drift. No other choice gets us that. | decisive |
 | **No new toolchain in any pipeline.** Every job already runs `python:3.13-slim`; a Go CLI would add a compiler, a cross-build matrix and a second dependency-audit path to all 21 repositories. | heavy |
 | **`keyring` gives the OS keychain on all three platforms** — macOS Keychain, Secret Service, Windows Credential Locker — with no native code to sign or notarise. | heavy |
-| Against: `npm` and `curl` want a runtime-free binary. | the cost |
+| Against: a runtime-free binary. | the cost |
 
-That last line is the real cost, and it is paid rather than hidden: `pip` and
-`brew` install from source, while the **npm package and the curl script serve a
-single-file build** made with PyInstaller (`installers/`), which embeds the
-interpreter. A person installing by `curl | sh` needs no Python; a person
-installing by `pip` has one already.
-
-If the npm and curl routes ever become the main way people install this, the
-decision is worth revisiting — the commands, their output and their tests are
-the valuable part and none of it is language-specific.
+That last line is the real cost, and it is paid rather than hidden: the CLI
+installs from source as a package, so it needs Python (`pipx` brings its own
+isolated environment; Homebrew brings its own virtualenv). There is no
+stand-alone binary: the stand-alone installer was retired on 11 November 2026
+and the CLI ships as packages only.
 
 ## Install
 
-| Route | Command | What it installs |
+| Route | Command | Platforms |
 |---|---|---|
-| Homebrew | `brew install atlantic-agentic-labs/tap/lighthouse` | from source, into its own virtualenv (`installers/lighthouse.rb`) |
-| pip | `pip install lighthouse-cli` | from source, as a normal console script |
-| curl | `curl -fsSL https://get.atlanticagenticlabs.com/lighthouse \| sh` | the single-file build (`installers/install.sh`) |
+| pipx or pip | `pipx install lighthouse-cli` (or `pip install lighthouse-cli`) | Linux, macOS, Windows |
+| Homebrew | `brew install atlantic-agentic-labs/tap/lighthouse` | macOS, Linux (`installers/lighthouse.rb`) |
 
 **Nothing is published yet.** From a clone:
 
@@ -49,9 +44,9 @@ the valuable part and none of it is language-specific.
 cd cli && pip install -e ".[dev]"
 ```
 
-What has to exist before any of the three routes work is in
-`installers/README.md`: a Homebrew tap, a PyPI project and one DNS name. No
-registry credential is stored for any of them.
+What has to exist before either route works is in `installers/README.md`: a
+PyPI project with a trusted publisher and a Homebrew tap. No registry
+credential is stored for PyPI.
 
 ## Signing in
 
@@ -158,6 +153,9 @@ a terminal, and when `CI`, `NO_COLOR` or `TERM=dumb` is set.
 | `evals list`, `evals list --fail-below N` | evaluation results, as a release gate on one named metric (`--metric`, default `f1`); fails closed when a row has no such number |
 | `evals run <pack:card> --cap N [--set S] [--wait] [--fail-below N]` | run the agent's scheduled evaluation once under a spend cap (the `deploy` scope, or a person); with `--wait`, gate on the new results |
 | `runs`, `runs show`, `runs tail` | what ran, and what is running now |
+| `runs export <run> [--format json\|pdf] [-o file]` | one run's content-free export, as JSON or a branded PDF (contract 1.32); audited |
+| `telemetry import <bundle>`, `telemetry status --deployment D` | upload a telemetry bundle from a deployment with no network path, and see the batches held and missing (contract 1.33; client_admin or the `offline` scope) |
+| `commands export --deployment D --out <file>` | the waiting commands as a signed command file for the deployment's `apply-file` (contract 1.33); audited |
 | `spend` | spend by day, model, pack, agent or connection; the forecast; the estimated savings |
 | `limits` | the limits in force, and whether the engines applied them |
 | `terms` | the commercial terms in force |

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/__init__.py

@@ -3,4 +3,4 @@
 """The `lighthouse` command line for LightHouse."""
 from __future__ import annotations
 
-__version__ = "0.16.0"
+__version__ = "0.17.0"

lighthouse_cli-0.17.0/lighthouse/commands/offline.py

@@ -0,0 +1,176 @@
+# Copyright 2026 Atlantic Agentic Labs. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+"""`lighthouse telemetry` and `lighthouse commands`: a deployment with no
+network path (contract 1.33).
+
+    lighthouse telemetry import <bundle.tar.gz> [--deployment D]
+    lighthouse telemetry status --deployment D
+    lighthouse commands export --deployment D --out commands.json
+
+A deployment that cannot reach LightHouse writes its telemetry into signed
+bundle files (`python -m aal_engine.telemetry export` on the deployment's
+side). `telemetry import` uploads one, as it was carried: LightHouse checks
+its signatures, its manifest and its sequence, and stores what is new
+through the same intake as live telemetry. The deployment is read from the
+bundle's own manifest unless `--deployment` says otherwise; the service
+refuses a bundle that names another. `telemetry status` shows the last batch
+number held for each epoch, which is the `--since` for the next export, and
+the numbers missing.
+
+`commands export` writes every command waiting for the deployment into a
+file of signed frames, for `python -m aal_engine.handler apply-file` on the
+other side. The commands are marked delivered when the file is written, so
+the same command is never exported twice.
+
+Each needs a client administrator: at the keyboard, or through a token with
+the `offline` scope. Each is audited by the service.
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import os
+import tarfile
+from pathlib import Path
+from typing import Any
+
+from lighthouse.exits import FAILED, USAGE, CliError
+from lighthouse.flags import inherited
+from lighthouse.main import Command, Context
+from lighthouse.out import Out
+
+# The largest upload the service takes (telemetry_bundles.UPLOAD_MAX).
+UPLOAD_MAX = 48 * 1024 * 1024
+
+
+def _telemetry_configure(ap: argparse.ArgumentParser) -> None:
+    sub = ap.add_subparsers(dest="telemetry_command", metavar="<subcommand>")
+    imp = sub.add_parser("import", parents=[inherited()],
+                         help="upload a telemetry bundle from an offline deployment")
+    imp.add_argument("file", help="the bundle (.tar.gz), as the deployment wrote it")
+    imp.add_argument("--deployment", help="the deployment (default: the one the bundle names)")
+    status = sub.add_parser("status", parents=[inherited()],
+                            help="the batches held for a deployment, and any missing")
+    status.add_argument("--deployment", required=True, help="the deployment")
+
+
+def _commands_configure(ap: argparse.ArgumentParser) -> None:
+    sub = ap.add_subparsers(dest="commands_command", metavar="<subcommand>")
+    ex = sub.add_parser("export", parents=[inherited()],
+                        help="write the waiting commands into a signed command file")
+    ex.add_argument("--deployment", required=True, help="the deployment")
+    ex.add_argument("--out", required=True, help="the file to write (- for standard output)")
+    ex.add_argument("--force", action="store_true", help="overwrite the file if it exists")
+
+
+def bundle_deployment(data: bytes) -> str | None:
+    """The deployment a bundle's manifest names (its part after the tenant),
+    read locally so the right route is called. None if it cannot be read: the
+    service, which verifies the whole bundle, has the last word either way."""
+    try:
+        with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tar:
+            member = tar.getmember("manifest.json")
+            if not member.isfile() or member.size > 4 * 1024 * 1024:
+                return None
+            fh = tar.extractfile(member)
+            manifest = json.loads(fh.read() if fh is not None else b"")
+    except (tarfile.TarError, OSError, EOFError, KeyError, ValueError):
+        return None
+    named = manifest.get("deployment") if isinstance(manifest, dict) else None
+    if not isinstance(named, str) or "/" not in named:
+        return None
+    return named.split("/", 1)[1] or None
+
+
+def telemetry(ctx: Context) -> dict[str, Any]:
+    which = getattr(ctx.args, "telemetry_command", None)
+    if which == "status":
+        body = ctx.client().get(f"/api/v1/deployments/{ctx.args.deployment}/telemetry-bundles")
+        return {"ok": True, **body}
+    if which != "import":
+        raise CliError("say what to do: `lighthouse telemetry import <file>` or "
+                       "`lighthouse telemetry status --deployment <name>`", code=USAGE,
+                       error="usage")
+    path = Path(ctx.args.file).expanduser()
+    try:
+        size = path.stat().st_size
+        if size > UPLOAD_MAX:
+            raise CliError(f"{path} is over the 48 MB a bundle may be", error="too_large",
+                           hint="export again with a smaller --max-bytes")
+        data = path.read_bytes()
+    except OSError as e:
+        raise CliError(f"{path} could not be read: {e.strerror or e}", code=USAGE,
+                       error="unreadable") from None
+    deployment = ctx.args.deployment or bundle_deployment(data)
+    if not deployment:
+        raise CliError(f"{path} names no deployment that can be read", code=USAGE,
+                       error="usage", hint="pass --deployment <name>")
+    body = ctx.client().post_bytes(f"/api/v1/deployments/{deployment}/telemetry-bundles",
+                                   data, "application/gzip")
+    return {"ok": True, "file": str(path), **body}
+
+
+def commands_export(ctx: Context) -> dict[str, Any]:
+    if getattr(ctx.args, "commands_command", None) != "export":
+        raise CliError("say what to do: `lighthouse commands export --deployment <name> "
+                       "--out <file>`", code=USAGE, error="usage")
+    out = Path(ctx.args.out).expanduser()
+    if ctx.args.out != "-" and out.exists() and not ctx.args.force:
+        raise CliError(f"{out} already exists", code=USAGE, error="exists",
+                       hint="pass --force to overwrite it, or choose another --out")
+    doc = ctx.client().post(f"/api/v1/deployments/{ctx.args.deployment}/command-file")
+    if not isinstance(doc, dict) or not isinstance(doc.get("commands"), list):
+        raise CliError("the service did not answer with a command file", code=FAILED,
+                       error="bad_response")
+    if ctx.args.out == "-":
+        ctx.out.streamed = True
+        ctx.out.stdout.write(json.dumps(doc, indent=2, sort_keys=True) + "\n")
+        return {"ok": True, "streamed": True}
+    fd = os.open(out, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+        fh.write(json.dumps(doc, indent=2, sort_keys=True) + "\n")
+    return {"ok": True, "deployment": doc.get("deployment"), "path": str(out),
+            "commands": len(doc["commands"]),
+            "ids": [c.get("id") for c in doc["commands"] if isinstance(c, dict)]}
+
+
+def _telemetry_show(out: Out, body: dict[str, Any]) -> None:
+    if "imports" in body:
+        seq = body.get("sequence") or []
+        if not seq:
+            out.say("no bundle imported yet: export with --since 0")
+            return
+        out.table(["epoch", "held through", "highest", "missing"],
+                  [[s["epoch"][:8], s["held_through"], s["highest_seq"], s["missing"]]
+                   for s in seq])
+        return
+    b, r, s = body["batches"], body["records"], body["sequence"]
+    out.done(f"imported batches {body['first_seq']} to {body['last_seq']} for "
+             f"{body['deployment']}: {b['imported']} new, {b['duplicate']} already held")
+    out.pairs([("records stored", r["stored"]), ("records already held", r["duplicate"]),
+               ("spans", body["spans"]), ("held through", s["held_through"])])
+    for item in body.get("refused") or []:
+        out.warn(f"batch {item['seq']} not imported: {item['error']}")
+    if s.get("gaps"):
+        out.warn("missing batches: " + ", ".join(
+            str(a) if a == z else f"{a}-{z}" for a, z in s["gaps"]))
+    out.note(f"next export: --since {s['held_through']}")
+
+
+def _commands_show(out: Out, body: dict[str, Any]) -> None:
+    if body.get("streamed"):
+        return
+    n = body["commands"]
+    out.done(f"{n} command{'' if n == 1 else 's'} written to {body['path']}")
+    if n:
+        out.note("apply it on the deployment: python -m aal_engine.handler apply-file "
+                 f"{Path(body['path']).name}")
+
+
+COMMANDS = (
+    Command("telemetry", "telemetry bundles from a deployment with no network path",
+            _telemetry_configure, telemetry, _telemetry_show),
+    Command("commands", "command files for a deployment with no network path",
+            _commands_configure, commands_export, _commands_show),
+)

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/commands/runs.py

@@ -6,6 +6,7 @@
     lighthouse runs tail                  # live, one line per change
     lighthouse runs tail --once --json    # one snapshot, for a pipeline
     lighthouse runs show <run_id_hash>
+    lighthouse runs export <run_id_hash> [--format json|pdf] [-o file]
 
 `tail` follows `GET /api/v1/runs/active` (contract 1.12): the live runs, each
 with its current step, its tokens so far and its estimated cost. It polls at
@@ -22,12 +23,21 @@ step wants. Both are covered by the golden test.
 `--fail-on-stall` makes it exit 1 if a run has not been seen for
 `stall_after_s`, which is the useful thing to put in a smoke job after a
 deploy.
+
+`export` (contract 1.32) writes one run's content-free export, the run map as
+JSON or as a PDF carrying the organisation's branding, to `-o` (by default
+`run-<first 12 of the hash>.<format>` here; `-o -` is standard output). The
+file is written exactly as the service sent it, and the service records the
+export in the organisation's audit log. A machine key may export, so a
+pipeline can attach a run's record to its own report.
 """
 from __future__ import annotations
 
 import argparse
 import json
+import re
 import time
+from pathlib import Path
 from typing import Any
 
 from lighthouse.exits import FAILED, CliError
@@ -46,6 +56,13 @@ def _configure(ap: argparse.ArgumentParser) -> None:
     show.add_argument("run", help="its run_id_hash")
     show.add_argument("--map", action="store_true", dest="as_map",
                       help="the run map: every step, model call and retrieval")
+    export = sub.add_parser("export", parents=[inherited()],
+                            help="one run's content-free export, as JSON or PDF")
+    export.add_argument("run", help="its run_id_hash")
+    export.add_argument("--format", choices=("json", "pdf"), default="json", dest="export_format",
+                        help="json (the default) or pdf")
+    export.add_argument("-o", "--output", dest="output", default=None,
+                        help="the file to write (default run-<hash>.<format>; - for standard output)")
     tail = sub.add_parser("tail", parents=[inherited()], help="follow the live runs")
     tail.add_argument("--interval", type=float, default=5.0, help="seconds between polls")
     tail.add_argument("--once", action="store_true", help="one snapshot, then stop")
@@ -119,10 +136,37 @@ def tail(ctx: Context) -> dict[str, Any]:
             "live": last.get("live"), "runs": last.get("runs") or [], "stalled": stalled}
 
 
+def export(ctx: Context) -> dict[str, Any]:
+    """Fetch the export and write it where asked. The bytes are the service's
+    own: nothing is re-encoded, so the file is the one the audit log names."""
+    run, fmt = str(ctx.args.run), ctx.args.export_format
+    body = ctx.client().get_bytes(f"/api/v1/runs/{run}/export", format=fmt)
+    target = ctx.args.output or f"run-{re.sub(r'[^A-Za-z0-9_-]', '', run)[:12]}.{fmt}"
+    if target == "-":
+        ctx.out.streamed = True
+        if fmt == "json":
+            ctx.out.stdout.write(body.decode("utf-8"))
+        else:
+            buffer = getattr(ctx.out.stdout, "buffer", None)
+            if buffer is None:
+                raise CliError("standard output cannot take a PDF here; use -o <file>",
+                               error="not_binary")
+            buffer.write(body)
+            buffer.flush()
+        return {"ok": True, "streamed": True}
+    path = Path(target).expanduser()
+    if path.is_dir():
+        path = path / f"run-{re.sub(r'[^A-Za-z0-9_-]', '', run)[:12]}.{fmt}"
+    path.write_bytes(body)
+    return {"ok": True, "run_id_hash": run, "format": fmt, "path": str(path), "bytes": len(body)}
+
+
 def runs(ctx: Context) -> dict[str, Any]:
     which = getattr(ctx.args, "runs_command", None) or "list"
     if which == "tail":
         return tail(ctx)
+    if which == "export":
+        return export(ctx)
     client = ctx.client()
     if which == "show":
         path = f"/api/v1/runs/{ctx.args.run}"

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/http.py

@@ -234,8 +234,12 @@ class Client:
     # -- requests ---------------------------------------------------------------------
 
     def request(self, method: str, path: str, *, params: dict[str, Any] | None = None,
-                json_body: Any = None, idempotency: str | None = None) -> Any:
-        """One logical request, retried where retrying is safe."""
+                json_body: Any = None, idempotency: str | None = None, raw: bool = False,
+                content: bytes | None = None, content_type: str | None = None) -> Any:
+        """One logical request, retried where retrying is safe. With `raw`, a
+        success is returned as the body's bytes, as sent (a file: `runs export`).
+        `content` is a body sent as it is, with its `content_type` (a file:
+        `telemetry import`), in place of a JSON body."""
         method = method.upper()
         if idempotency is None and method in WRITES:
             idempotency = str(uuid.uuid4())
@@ -245,9 +249,13 @@ class Client:
         last: CliError | None = None
         for attempt in range(self.attempts):
             try:
+                headers = self._headers(idempotency)
+                if content is not None:
+                    headers["Content-Type"] = content_type or "application/octet-stream"
                 reply = self._http.request(
                     method, path, params={k: v for k, v in (params or {}).items() if v is not None},
-                    json=json_body, headers=self._headers(idempotency))
+                    json=json_body if content is None else None, content=content,
+                    headers=headers)
             except httpx.TimeoutException as e:
                 last = CliError(t("err.timeout", method=method, path=path), code=RETRY, error="timeout")
                 log.debug("timeout: %s", e)
@@ -262,6 +270,8 @@ class Client:
                 refreshed = True
                 continue
             if 200 <= reply.status_code < 300:
+                if raw:
+                    return reply.content
                 if not reply.content:
                     return {}
                 try:
@@ -303,9 +313,19 @@ class Client:
     def get(self, path: str, **params: Any) -> Any:
         return self.request("GET", path, params=params)
 
+    def get_bytes(self, path: str, **params: Any) -> bytes:
+        """A GET whose answer is a file, returned exactly as the service sent it."""
+        body: bytes = self.request("GET", path, params=params, raw=True)
+        return body
+
     def post(self, path: str, body: Any = None, **params: Any) -> Any:
         return self.request("POST", path, params=params, json_body=body)
 
+    def post_bytes(self, path: str, content: bytes, content_type: str, **params: Any) -> Any:
+        """A POST whose body is a file, sent exactly as read."""
+        return self.request("POST", path, params=params, content=content,
+                            content_type=content_type)
+
     def delete(self, path: str, **params: Any) -> Any:
         return self.request("DELETE", path, params=params)
 

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/ar.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "توقف بعد هذا العدد من الثواني",
  "help.runs.tail.deployment": "تشغيلات عملية النشر هذه فقط",
  "help.runs.tail.fail_on_stall": "اخرج بالرمز 1 إذا تعثّر تشغيل",
+ "help.runs.export._help": "تصدير خالٍ من المحتوى لتشغيل واحد، بصيغة JSON أو PDF",
+ "help.runs.export.run": "قيمة run_id_hash الخاصة به",
+ "help.runs.export.export_format": "json (الافتراضي) أو pdf",
+ "help.runs.export.output": "الملف المراد كتابته (الافتراضي run-<hash>.<format>؛ - للإخراج القياسي)",
  "help.spend.by": "كيفية التجميع",
  "help.spend.month": "YYYY-MM؛ الشهر الحالي افتراضياً",
  "help.spend.forecast": "وإسقاط نهاية الشهر مقابل الحدّ الأقصى أيضاً",
@@ -339,5 +343,23 @@
  "label.evals": "التقييمات",
  "label.calls_month": "الاستدعاءات (الشهر)",
  "label.input_m": "الإدخال /M",
- "label.output_m": "الإخراج /M"
+ "label.output_m": "الإخراج /M",
+ "help.telemetry._help": "حزم القياس عن بُعد من نشر بلا مسار شبكي",
+ "help.commands._help": "ملفات الأوامر لنشر بلا مسار شبكي",
+ "help.telemetry.import._help": "رفع حزمة قياس عن بُعد من نشر غير متصل",
+ "help.telemetry.status._help": "الدفعات المحفوظة لنشر ما، والدفعات المفقودة",
+ "help.telemetry.import.file": "الحزمة (.tar.gz) كما كتبها النشر",
+ "help.telemetry.import.deployment": "النشر (الافتراضي: النشر المذكور في الحزمة)",
+ "help.telemetry.status.deployment": "النشر",
+ "help.commands.export._help": "كتابة الأوامر المنتظرة في ملف أوامر موقّع",
+ "help.commands.export.deployment": "النشر",
+ "help.commands.export.out": "الملف المراد كتابته (- للإخراج القياسي)",
+ "help.commands.export.force": "استبدال الملف إن وُجد",
+ "label.epoch": "الحقبة",
+ "label.held_through": "مكتمل حتى",
+ "label.highest": "الأعلى",
+ "label.missing": "المفقود",
+ "label.records_stored": "السجلات المخزنة",
+ "label.records_already_held": "السجلات المحفوظة مسبقًا",
+ "label.spans": "الامتدادات"
 }

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/de.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "nach so vielen Sekunden beenden",
  "help.runs.tail.deployment": "nur die Läufe dieser Bereitstellung",
  "help.runs.tail.fail_on_stall": "mit Exit 1 beenden, wenn ein Lauf festhängt",
+ "help.runs.export._help": "der inhaltsfreie Export eines Laufs, als JSON oder PDF",
+ "help.runs.export.run": "sein run_id_hash",
+ "help.runs.export.export_format": "json (Standard) oder pdf",
+ "help.runs.export.output": "die zu schreibende Datei (Standard run-<hash>.<format>; - für die Standardausgabe)",
  "help.spend.by": "wie gruppiert wird",
  "help.spend.month": "JJJJ-MM; standardmäßig der aktuelle Monat",
  "help.spend.forecast": "auch die Monatsend-Prognose gegenüber dem Limit",
@@ -339,5 +343,23 @@
  "label.evals": "Evaluierungen",
  "label.calls_month": "Aufrufe (Monat)",
  "label.input_m": "Eingabe /M",
- "label.output_m": "Ausgabe /M"
+ "label.output_m": "Ausgabe /M",
+ "help.telemetry._help": "Telemetriepakete einer Bereitstellung ohne Netzwerkpfad",
+ "help.commands._help": "Befehlsdateien für eine Bereitstellung ohne Netzwerkpfad",
+ "help.telemetry.import._help": "ein Telemetriepaket einer Offline-Bereitstellung hochladen",
+ "help.telemetry.status._help": "die für eine Bereitstellung gehaltenen Pakete und fehlende",
+ "help.telemetry.import.file": "das Paket (.tar.gz), wie die Bereitstellung es geschrieben hat",
+ "help.telemetry.import.deployment": "die Bereitstellung (Standard: die im Paket genannte)",
+ "help.telemetry.status.deployment": "die Bereitstellung",
+ "help.commands.export._help": "die wartenden Befehle in eine signierte Befehlsdatei schreiben",
+ "help.commands.export.deployment": "die Bereitstellung",
+ "help.commands.export.out": "die zu schreibende Datei (- für die Standardausgabe)",
+ "help.commands.export.force": "die Datei überschreiben, falls vorhanden",
+ "label.epoch": "Epoche",
+ "label.held_through": "lückenlos bis",
+ "label.highest": "höchste",
+ "label.missing": "fehlend",
+ "label.records_stored": "gespeicherte Datensätze",
+ "label.records_already_held": "bereits gehaltene Datensätze",
+ "label.spans": "Spans"
 }

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/en.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "stop after this many seconds",
  "help.runs.tail.deployment": "only this deployment's runs",
  "help.runs.tail.fail_on_stall": "exit 1 if a run has stalled",
+ "help.runs.export._help": "one run's content-free export, as JSON or PDF",
+ "help.runs.export.run": "its run_id_hash",
+ "help.runs.export.export_format": "json (the default) or pdf",
+ "help.runs.export.output": "the file to write (default run-<hash>.<format>; - for standard output)",
  "help.spend.by": "how to group",
  "help.spend.month": "YYYY-MM; the current month by default",
  "help.spend.forecast": "the month-end projection against the cap as well",
@@ -339,5 +343,23 @@
  "label.evals": "evals",
  "label.calls_month": "calls (month)",
  "label.input_m": "input /M",
- "label.output_m": "output /M"
+ "label.output_m": "output /M",
+ "help.telemetry._help": "telemetry bundles from a deployment with no network path",
+ "help.commands._help": "command files for a deployment with no network path",
+ "help.telemetry.import._help": "upload a telemetry bundle from an offline deployment",
+ "help.telemetry.status._help": "the batches held for a deployment, and any missing",
+ "help.telemetry.import.file": "the bundle (.tar.gz), as the deployment wrote it",
+ "help.telemetry.import.deployment": "the deployment (default: the one the bundle names)",
+ "help.telemetry.status.deployment": "the deployment",
+ "help.commands.export._help": "write the waiting commands into a signed command file",
+ "help.commands.export.deployment": "the deployment",
+ "help.commands.export.out": "the file to write (- for standard output)",
+ "help.commands.export.force": "overwrite the file if it exists",
+ "label.epoch": "epoch",
+ "label.held_through": "held through",
+ "label.highest": "highest",
+ "label.missing": "missing",
+ "label.records_stored": "records stored",
+ "label.records_already_held": "records already held",
+ "label.spans": "spans"
 }

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/es.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "parar tras este número de segundos",
  "help.runs.tail.deployment": "solo las ejecuciones de este despliegue",
  "help.runs.tail.fail_on_stall": "salir con 1 si una ejecución se ha atascado",
+ "help.runs.export._help": "la exportación sin contenido de una ejecución, en JSON o PDF",
+ "help.runs.export.run": "su run_id_hash",
+ "help.runs.export.export_format": "json (por defecto) o pdf",
+ "help.runs.export.output": "el archivo que se escribe (por defecto run-<hash>.<format>; - para la salida estándar)",
  "help.spend.by": "cómo agrupar",
  "help.spend.month": "AAAA-MM; por defecto, el mes actual",
  "help.spend.forecast": "también la proyección de fin de mes frente al límite",
@@ -339,5 +343,23 @@
  "label.evals": "evaluaciones",
  "label.calls_month": "llamadas (mes)",
  "label.input_m": "entrada /M",
- "label.output_m": "salida /M"
+ "label.output_m": "salida /M",
+ "help.telemetry._help": "paquetes de telemetría de un despliegue sin ruta de red",
+ "help.commands._help": "archivos de comandos para un despliegue sin ruta de red",
+ "help.telemetry.import._help": "subir un paquete de telemetría de un despliegue sin conexión",
+ "help.telemetry.status._help": "los lotes conservados para un despliegue, y los que faltan",
+ "help.telemetry.import.file": "el paquete (.tar.gz), tal como lo escribió el despliegue",
+ "help.telemetry.import.deployment": "el despliegue (por defecto: el que nombra el paquete)",
+ "help.telemetry.status.deployment": "el despliegue",
+ "help.commands.export._help": "escribir los comandos pendientes en un archivo de comandos firmado",
+ "help.commands.export.deployment": "el despliegue",
+ "help.commands.export.out": "el archivo que se escribe (- para la salida estándar)",
+ "help.commands.export.force": "sobrescribir el archivo si existe",
+ "label.epoch": "época",
+ "label.held_through": "completo hasta",
+ "label.highest": "más alto",
+ "label.missing": "faltan",
+ "label.records_stored": "registros almacenados",
+ "label.records_already_held": "registros ya conservados",
+ "label.spans": "spans"
 }

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/fr.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "s'arrêter après ce nombre de secondes",
  "help.runs.tail.deployment": "uniquement les exécutions de ce déploiement",
  "help.runs.tail.fail_on_stall": "quitter avec le code 1 si une exécution est bloquée",
+ "help.runs.export._help": "l'export sans contenu d'une exécution, en JSON ou en PDF",
+ "help.runs.export.run": "son run_id_hash",
+ "help.runs.export.export_format": "json (par défaut) ou pdf",
+ "help.runs.export.output": "le fichier à écrire (par défaut run-<hash>.<format> ; - pour la sortie standard)",
  "help.spend.by": "comment regrouper",
  "help.spend.month": "AAAA-MM ; le mois en cours par défaut",
  "help.spend.forecast": "aussi la projection de fin de mois par rapport au plafond",
@@ -339,5 +343,23 @@
  "label.evals": "évaluations",
  "label.calls_month": "appels (mois)",
  "label.input_m": "entrée /M",
- "label.output_m": "sortie /M"
+ "label.output_m": "sortie /M",
+ "help.telemetry._help": "lots de télémétrie d'un déploiement sans accès réseau",
+ "help.commands._help": "fichiers de commandes pour un déploiement sans accès réseau",
+ "help.telemetry.import._help": "téléverser un lot de télémétrie d'un déploiement hors ligne",
+ "help.telemetry.status._help": "les lots détenus pour un déploiement, et ceux qui manquent",
+ "help.telemetry.import.file": "le lot (.tar.gz), tel que le déploiement l'a écrit",
+ "help.telemetry.import.deployment": "le déploiement (par défaut : celui que le lot nomme)",
+ "help.telemetry.status.deployment": "le déploiement",
+ "help.commands.export._help": "écrire les commandes en attente dans un fichier de commandes signé",
+ "help.commands.export.deployment": "le déploiement",
+ "help.commands.export.out": "le fichier à écrire (- pour la sortie standard)",
+ "help.commands.export.force": "écraser le fichier s'il existe",
+ "label.epoch": "époque",
+ "label.held_through": "détenu jusqu'à",
+ "label.highest": "le plus élevé",
+ "label.missing": "manquants",
+ "label.records_stored": "enregistrements stockés",
+ "label.records_already_held": "enregistrements déjà détenus",
+ "label.spans": "spans"
 }

{lighthouse_cli-0.16.0 → lighthouse_cli-0.17.0}/lighthouse/locales/ga.json

@@ -209,6 +209,10 @@
  "help.runs.tail.duration": "stop tar éis an méid soicindí seo",
  "help.runs.tail.deployment": "ritheanna an imscartha seo amháin",
  "help.runs.tail.fail_on_stall": "scoir le 1 má tá rith greamaithe",
+ "help.runs.export._help": "easpórtáil gan ábhar de rith amháin, mar JSON nó PDF",
+ "help.runs.export.run": "a run_id_hash",
+ "help.runs.export.export_format": "json (an réamhshocrú) nó pdf",
+ "help.runs.export.output": "an comhad le scríobh (réamhshocrú run-<hash>.<format>; - don aschur caighdeánach)",
  "help.spend.by": "conas grúpáil",
  "help.spend.month": "BBBB-MM; an mhí reatha de réir réamhshocraithe",
  "help.spend.forecast": "réamh-mheastachán dheireadh na míosa i gcomparáid leis an uasteorainn freisin",
@@ -339,5 +343,23 @@
  "label.evals": "meastóireachtaí",
  "label.calls_month": "glaonna (mí)",
  "label.input_m": "ionchur /M",
- "label.output_m": "aschur /M"
+ "label.output_m": "aschur /M",
+ "help.telemetry._help": "beartáin teiliméadrachta ó imscaradh gan chonair líonra",
+ "help.commands._help": "comhaid ordaithe d'imscaradh gan chonair líonra",
+ "help.telemetry.import._help": "beart teiliméadrachta ó imscaradh as líne a uaslódáil",
+ "help.telemetry.status._help": "na baisceanna atá ar coimeád d'imscaradh, agus a bhfuil in easnamh",
+ "help.telemetry.import.file": "an beart (.tar.gz), mar a scríobh an t-imscaradh é",
+ "help.telemetry.import.deployment": "an t-imscaradh (réamhshocrú: an ceann a ainmníonn an beart)",
+ "help.telemetry.status.deployment": "an t-imscaradh",
+ "help.commands.export._help": "na horduithe atá ag fanacht a scríobh i gcomhad ordaithe sínithe",
+ "help.commands.export.deployment": "an t-imscaradh",
+ "help.commands.export.out": "an comhad le scríobh (- don aschur caighdeánach)",
+ "help.commands.export.force": "forscríobh an comhad má tá sé ann",
+ "label.epoch": "ré",
+ "label.held_through": "iomlán go dtí",
+ "label.highest": "is airde",
+ "label.missing": "in easnamh",
+ "label.records_stored": "taifid stóráilte",
+ "label.records_already_held": "taifid ar coimeád cheana",
+ "label.spans": "réisí"
 }