keystone-cli 0.1.10__tar.gz → 0.1.26__tar.gz

{keystone_cli-0.1.10 → keystone_cli-0.1.26}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: keystone-cli
-Version: 0.1.10
+Version: 0.1.26
 Summary: Keystone pro-code agent CLI — author, validate, and run agents locally, then deploy and invoke them on the Keystone platform.
 Requires-Python: >=3.12
-Requires-Dist: keystone-agent-sdk<0.4,>=0.3
+Requires-Dist: keystone-agent-sdk<0.11,>=0.10
 Requires-Dist: keystone-request-context<0.4,>=0.3
 Requires-Dist: typer<1,>=0.12
 Requires-Dist: httpx<1,>=0.27

{keystone_cli-0.1.10 → keystone_cli-0.1.26}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "keystone-cli"
-version = "0.1.10"
+version = "0.1.26"
 description = "Keystone pro-code agent CLI — author, validate, and run agents locally, then deploy and invoke them on the Keystone platform."
 requires-python = ">=3.12"
 dependencies = [
     # Pinned to a compatible range: on an index (Artifact Registry) an unpinned name resolves to
     # ANY published version — the wheel's metadata is the only pin that travels with it.
-    "keystone-agent-sdk>=0.3,<0.4",
+    "keystone-agent-sdk>=0.10,<0.11",
     # Transitive (the SDK's building-block clients) + used directly by `run` to set a local
     # caller-identity ContextVar and to patch the clients for --offline. uv sources are NOT
     # transitive, so declare it directly (cf. services/llm-gateway).
@@ -45,7 +45,7 @@ where = ["src"]
 keystone_cli = ["templates/*/*.tmpl", "templates/*/pkg/*.tmpl"]
 
 [tool.ruff]
-target-version = "0.1.10"
+target-version = "0.1.26"
 line-length = 120
 
 [tool.ruff.lint]

{keystone_cli-0.1.10 → keystone_cli-0.1.26}/src/keystone_cli/__main__.py

@@ -4,12 +4,20 @@ from __future__ import annotations
 
 import typer
 
+from keystone_cli._stdio import make_stdio_unicode_safe
 from keystone_cli._version import version_line
 from keystone_cli.commands.agent import agent_app
 from keystone_cli.commands.dev import dev
+from keystone_cli.commands.kb import kb_app
 from keystone_cli.commands.login import login
+from keystone_cli.commands.tool_credentials import tool_credentials_app
 from keystone_cli.commands.workspace import workspace_app
 
+# FDP-4360 — before Typer builds anything. `--help` is rendered inside `app()`, and the help
+# text comes from docstrings carrying `→` and `─`, so a hook that ran per-command would be too
+# late for the very invocation QC reported first. No-op on a console that already copes.
+make_stdio_unicode_safe()
+
 app = typer.Typer(
     help="Keystone pro-code agent CLI — author, validate, and run agents locally.",
     no_args_is_help=True,
@@ -45,6 +53,8 @@ def version() -> None:
 
 app.add_typer(agent_app, name="agent")
 app.add_typer(workspace_app, name="workspace")
+app.add_typer(kb_app, name="kb")
+app.add_typer(tool_credentials_app, name="tool-credentials")
 app.command(name="login")(login)
 app.command(name="dev")(dev)
 

keystone_cli-0.1.26/src/keystone_cli/_stdio.py

@@ -0,0 +1,68 @@
+"""Make stdout/stderr able to carry the CLI's own glyphs (FDP-4360).
+
+Every command prints at least one of ``✓ ✗ → ─ ⚠ ↻``, and Typer renders ``--help`` from
+docstrings that contain them too. On a console whose encoding cannot represent those — a
+Windows cp1252 shell is the reported case, but any ``LANG=C`` box behaves the same — writing
+them raises ``UnicodeEncodeError`` and the command dies at the moment it reports success.
+QC hit exactly that: ``keystone agent init`` created the project and then crashed printing
+``✓``, so the user saw only a traceback and had no way to tell the work had been done.
+
+The fix is deliberately conditional rather than unconditional. A stream that can already
+carry the glyphs is left alone — that keeps a deliberate ``PYTHONIOENCODING`` honoured, and
+keeps this from being one more global that reaches into a process it does not own.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import IO, Any
+
+#: The characters the CLI actually emits that cp1252 (and most 8-bit encodings) cannot carry.
+#: Taken from the source, not guessed: ``— … • · §`` ARE representable in cp1252 and so would
+#: hide the problem if the probe included only them.
+_PROBE = "→✓✗─⚠↻"
+
+
+def _can_carry_glyphs(stream: IO[Any]) -> bool:
+    encoding = getattr(stream, "encoding", None)
+    if not encoding:
+        # No declared encoding (a pipe wrapper, a test double). Nothing to prove it cannot
+        # cope, and nothing to reconfigure either — treat it as fine and leave it be.
+        return True
+    try:
+        _PROBE.encode(encoding)
+    except (UnicodeEncodeError, LookupError):
+        return False
+    return True
+
+
+def make_stdio_unicode_safe(streams: tuple[IO[Any], ...] | None = None) -> None:
+    """Re-open stdout/stderr as UTF-8 when their current encoding cannot carry our glyphs.
+
+    Called once from the CLI entry point, before Typer builds anything — ``--help`` is
+    rendered during ``app()``, so a later hook would already be too late.
+
+    Three things are deliberately tolerated rather than raised on, because a CLI that cannot
+    fix its console must still run the command the user asked for:
+
+    * a stream with no ``reconfigure`` (``io.TextIOWrapper`` has it; pytest's capture object
+      and anything hand-rolled may not),
+    * ``reconfigure`` refusing — a detached or closed stream,
+    * UTF-8 itself being rejected, in which case the encoding is left as it is and only the
+      error handler is relaxed, so an unencodable glyph degrades to ``?`` instead of a crash.
+    """
+    for stream in streams if streams is not None else (sys.stdout, sys.stderr):
+        if _can_carry_glyphs(stream):
+            continue
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        try:
+            reconfigure(encoding="utf-8", errors="replace")
+        except (ValueError, OSError, LookupError):
+            # Last resort: keep the console's own encoding and stop it from raising. The
+            # glyphs become '?', which is a cosmetic loss; the crash was a functional one.
+            try:
+                reconfigure(errors="replace")
+            except (ValueError, OSError):
+                pass

{keystone_cli-0.1.10 → keystone_cli-0.1.26}/src/keystone_cli/auth/token_store.py

@@ -95,14 +95,62 @@ def load() -> AuthConfig:
     path = config_path()
     if not path.exists():
         return AuthConfig()
-    data = json.loads(path.read_text())
+    # FDP-4716: `save()` below writes this file with encoding="utf-8"; reading it back with the
+    # locale encoding made the two disagree on Windows, where a workspace name with diacritics
+    # turned a valid session into "not logged in".
+    data = json.loads(path.read_text(encoding="utf-8"))
     known = {f.name for f in fields(AuthConfig)}
     return AuthConfig(**{k: v for k, v in data.items() if k in known})
 
 
+def _ensure_private_dir(directory: Path) -> None:
+    """Config dir, owner-only. ``mode=`` is IGNORED when the directory already exists, so the chmod
+    is not redundant — it is the only thing that narrows a ``~/.keystone`` an older CLI left at 0755.
+
+    Best-effort on purpose: on a shared runner the directory can belong to someone else, and failing
+    the whole ``login`` over a directory bit would be worse than the bit. The FILE is the credential
+    and its mode is enforced unconditionally below; this is the layer around it.
+    """
+    directory.mkdir(parents=True, exist_ok=True, mode=0o700)
+    try:
+        os.chmod(directory, 0o700)
+    except OSError:
+        pass
+
+
 def save(cfg: AuthConfig) -> None:
+    """Persist the config, with the credential never once readable by anyone else (FDP-4574).
+
+    This used to be ``write_text()`` then ``chmod(0o600)``. The end state was right, but between the
+    two calls the refresh token sat on disk at whatever the umask allowed — 0644 on a default box —
+    so on a shared host or CI runner any local user could read it and mint access tokens as the
+    developer until it was revoked. Applying permissions AFTER the content is the bug; the window is
+    the vulnerability, not the final mode, which is why the existing 0600 assertion never saw it.
+
+    So the bytes only ever land in a file that was created 0600. ``O_EXCL`` (after clearing a stale
+    temp) guarantees WE created it, so ``O_CREAT``'s mode really applies rather than being inherited
+    from a leftover file — the one way this shape can silently degrade. umask can only remove bits,
+    never add them, so a permissive umask cannot widen it.
+
+    ``os.replace`` then swaps the inode in atomically. Two things fall out for free: a crash can no
+    longer leave a half-written config that every later command fails to parse, and an existing
+    world-readable ``config.json`` from an older CLI is REPLACED rather than rewritten in place, so
+    it is fixed on the next save instead of keeping its old mode forever.
+
+    The temp carries the pid so two CLI processes saving at once (a `dev` watcher plus a command in
+    another terminal) cannot collide on ``O_EXCL``, and it is removed in a ``finally`` so a failed
+    save does not leave a token sitting in an orphan file.
+    """
     path = config_path()
-    path.parent.mkdir(parents=True, exist_ok=True)
-    # Write then lock to 0600 (owner-only) — the refresh token is a credential.
-    path.write_text(json.dumps(asdict(cfg), indent=2))
-    path.chmod(0o600)
+    _ensure_private_dir(path.parent)
+    tmp = path.with_name(f"{path.name}.{os.getpid()}.tmp")
+    tmp.unlink(missing_ok=True)
+    # O_BINARY (Windows only, 0 elsewhere) keeps newline handling in the text wrapper alone, the way
+    # open() does it — without it the CRT would translate as well, on top of the wrapper.
+    flags = os.O_CREAT | os.O_EXCL | os.O_WRONLY | getattr(os, "O_BINARY", 0)
+    try:
+        with os.fdopen(os.open(tmp, flags, 0o600), "w", encoding="utf-8") as fh:
+            fh.write(json.dumps(asdict(cfg), indent=2))
+        os.replace(tmp, path)
+    finally:
+        tmp.unlink(missing_ok=True)