contree-cli 0.4.4__tar.gz → 0.5.0__tar.gz

{contree_cli-0.4.4 → contree_cli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: contree-cli
-Version: 0.4.4
+Version: 0.5.0
 Summary: CLI client for the ConTree sandbox platform
 Keywords: sandbox,cli,vm,ai-agent,contree
 Author: Dmitry Orlov

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/__main__.py

@@ -8,7 +8,7 @@ import contree_cli.config as config_mod
 from contree_cli import CLIENT, FORMATTER, PROFILE, SESSION_STORE, ArgumentsProtocol
 from contree_cli.arguments import parser
 from contree_cli.client import ApiError, client_from_profile
-from contree_cli.config import Config
+from contree_cli.config import SETTINGS, Config
 from contree_cli.log import setup_logging
 from contree_cli.output import FORMATTERS
 from contree_cli.session import SessionStore, get_session_key
@@ -21,6 +21,9 @@ def main() -> None:
         parser.print_help()
         exit(0)
 
+    if SETTINGS.has_section("cli"):
+        parser.set_defaults(**SETTINGS["cli"])
+
     args = parser.parse_args()
     setup_logging(level=getattr(logging, args.log_level.upper(), logging.INFO))
 
@@ -38,14 +41,19 @@ def main() -> None:
     if args.project:
         profile = replace(profile, project=args.project)
 
-    # auth creates its own client and can work with nonexistent profiles
-    if args.command not in ("auth",):
-        if profile.name not in cfg:
-            log.error(
-                "Profile %r does not exist. Run `contree auth` first.",
-                profile.name,
-            )
-            exit(1)
+    # Local-only commands don't need a client or a configured profile:
+    # auth bootstraps its own; agent/man/skill operate purely on local files.
+    LOCAL_COMMANDS = ("auth", "agent", "man", "skill")
+    needs_client = args.command not in LOCAL_COMMANDS
+
+    if needs_client and profile.name not in cfg:
+        log.error(
+            "Profile %r does not exist. Run `contree auth` first.",
+            profile.name,
+        )
+        exit(1)
+
+    if needs_client:
         try:
             client = client_from_profile(profile)
         except ValueError as exc:
@@ -57,6 +65,7 @@ def main() -> None:
 
     session_key = get_session_key(profile.name, override=args.session_key)
     db_path = profile.session_db_path
+    log.debug("Running in session: %s", session_key)
 
     with SessionStore(db_path, session_key) as store:
         PROFILE.set(profile)

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/arguments.py

@@ -95,7 +95,7 @@ through the ConTree REST API.
 
 Authentication:
   Bearer token + project ID. Default API URL:
-    https://api.studio.nebius.com/sandboxes/
+    https://api.tokenfactory.nebius.com/sandboxes/
 
   Use `contree auth --help` to configure persistent credentials.
 

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/cli/file.py

@@ -19,7 +19,6 @@ import argparse
 import hashlib
 import json
 import logging
-import os
 import shlex
 import subprocess
 import tempfile
@@ -28,6 +27,7 @@ from pathlib import Path
 
 from contree_cli import CLIENT, SESSION_STORE, ArgumentsProtocol, SetupResult
 from contree_cli.client import ApiError, ContreeClient, resolve_image, stream_response
+from contree_cli.config import EDITOR
 from contree_cli.session import SessionStore
 from contree_cli.types import FLAGS
 
@@ -79,7 +79,8 @@ def setup_parser(p: argparse.ArgumentParser) -> SetupResult:
     )
     edit_p.add_argument(
         *FLAGS["editor"],
-        help="Editor command (default: $EDITOR or vi)",
+        default=EDITOR,
+        help=f"Editor command (default: {EDITOR})",
     )
     edit_p.add_argument("path", help="Path inside image")
     edit_p.set_defaults(handler=cmd_file_edit, load_args=FileEditArgs)
@@ -128,14 +129,14 @@ def _upload_and_record(
     except ApiError as exc:
         if exc.status != 404:
             raise
-        data = local_path.read_bytes()
-        resp = client.request(
-            "POST",
-            "/v1/files",
-            body=data,
-            headers={"Content-Type": "application/octet-stream"},
-        )
-        file_uuid = json.loads(resp.read())["uuid"]
+        with open(local_path, "rb") as fh:
+            resp = client.request(
+                "POST",
+                "/v1/files",
+                body=fh,
+                headers={"Content-Type": "application/octet-stream"},
+            )
+            file_uuid = json.loads(resp.read())["uuid"]
         logger.info("Uploaded %s (%s)", instance_path, file_uuid)
 
     history_id = store.set_image(
@@ -178,14 +179,13 @@ def cmd_file_edit(args: FileEditArgs) -> int | None:
 
     # 2. Record original hash, open editor
     original_hash = _file_sha256(tmp_file)
-    editor = args.editor or os.environ.get("EDITOR", "vi")
-    logger.info("Opening %s in %s", tmp_file, editor)
+    logger.info("Opening %s in %s", tmp_file, args.editor)
     # $EDITOR may contain shell expressions (env vars, tilde, pipes),
     # e.g. "TERM=xterm vim" or "~/bin/editor". shlex.split would not
-    # expand those — shell=True is required. The file path is quoted
+    # expand those, shell=True is required. The file path is quoted
     # via shlex.quote to prevent injection from the filename.
     # nosemgrep: subprocess-shell-true
-    rc = subprocess.call(f"{editor} {shlex.quote(str(tmp_file))}", shell=True)
+    rc = subprocess.call(f"{args.editor} {shlex.quote(str(tmp_file))}", shell=True)
     if rc != 0:
         logger.error("Editor exited with code %d", rc)
         return 1

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/cli/run.py

@@ -49,17 +49,20 @@ from __future__ import annotations
 import argparse
 import base64
 import fnmatch
+import functools
 import io
 import json
 import logging
 import os
 import re
 import select
+import shlex
 import sys
 import time
 import uuid
 from dataclasses import dataclass, field
 from datetime import timedelta
+from multiprocessing.pool import ThreadPool
 
 from contree_cli import CLIENT, FORMATTER, SESSION_STORE, ArgumentsProtocol, SetupResult
 from contree_cli.client import ApiError, ContreeClient, decode_stream, resolve_image
@@ -68,7 +71,7 @@ from contree_cli.output import (
     DefaultFormatter,
     OutputFormatter,
 )
-from contree_cli.session import SessionStore
+from contree_cli.session import CONTREE_CONCURRENCY, SessionStore
 from contree_cli.types import FLAGS
 
 logger = logging.getLogger(__name__)
@@ -351,47 +354,82 @@ def _local_file_cache_kind(host_path: str) -> str:
     return f"local_file:{digest}"
 
 
-MAX_CACHE_AGE = 90 * 24 * 3600  # 90 days — server retention is 6 months
+MAX_CACHE_AGE = 90 * 24 * 3600  # 90 days - server retention is 6 months
 
 
-def _upload_file(
-    client: ContreeClient,
-    mf: MappedFile,
-    store: SessionStore,
-) -> str:
-    """Upload a host file and return its UUID, reusing if already present."""
+def cached_local_uuid(mf: MappedFile, store: SessionStore) -> str | None:
+    """Return a cached UUID for *mf* if one was uploaded within MAX_CACHE_AGE."""
     cache_kind = _local_file_cache_kind(mf.host_path)
     cached = store.cache.get(("", cache_kind))
     if isinstance(cached, dict) and cached.get("uuid"):
         age = time.time() - cached.get("uploaded_at", 0)
         if age < MAX_CACHE_AGE:
             logger.debug(
-                "File %s reused from local cache (%s)", mf.host_path, cached["uuid"]
+                "File %s reused from local cache (%s)",
+                mf.host_path,
+                cached["uuid"],
             )
             return str(cached["uuid"])
+    return None
+
+
+def record_local_uuid(mf: MappedFile, file_uuid: str, store: SessionStore) -> None:
+    """Persist a host_path → file_uuid mapping in the local cache."""
+    cache_kind = _local_file_cache_kind(mf.host_path)
+    store.cache[("", cache_kind)] = {
+        "uuid": file_uuid,
+        "uploaded_at": time.time(),
+    }
+
 
+def upload_one_remote(client: ContreeClient, mf: MappedFile) -> tuple[MappedFile, str]:
+    """HTTP-only upload (sha256 dedup + POST /v1/files). Thread-safe."""
     try:
         resp = client.get("/v1/files", params={"sha256": mf.sha256()})
         file_uuid = str(json.loads(resp.read())["uuid"])
-        logger.info("File %s already uploaded (%s)", mf.host_path, file_uuid)
-        store.cache[("", cache_kind)] = {"uuid": file_uuid, "uploaded_at": time.time()}
-        return file_uuid
+        logger.info("Uploaded file: %s -> %s", mf.host_path, file_uuid)
+        return mf, file_uuid
     except ApiError as exc:
         if exc.status != 404:
             raise
 
     with open(mf.host_path, "rb") as fh:
-        data = fh.read()
-    resp = client.request(
-        "POST",
-        "/v1/files",
-        body=data,
-        headers={"Content-Type": "application/octet-stream"},
-    )
-    file_uuid = str(json.loads(resp.read())["uuid"])
+        resp = client.request(
+            "POST",
+            "/v1/files",
+            body=fh,
+            headers={"Content-Type": "application/octet-stream"},
+        )
+        file_uuid = str(json.loads(resp.read())["uuid"])
     logger.debug("Uploaded %s (%s)", mf.host_path, file_uuid)
-    store.cache[("", cache_kind)] = {"uuid": file_uuid, "uploaded_at": time.time()}
-    return file_uuid
+    return mf, file_uuid
+
+
+def upload_files(
+    client: ContreeClient,
+    files: list[MappedFile],
+    store: SessionStore,
+) -> dict[str, str]:
+    """Upload host files in parallel, returning host_path → file_uuid."""
+    uploaded: dict[str, str] = {}
+    pending: list[MappedFile] = []
+    for mf in files:
+        cached = cached_local_uuid(mf, store)
+        if cached:
+            uploaded[mf.host_path] = cached
+        else:
+            pending.append(mf)
+
+    if not pending:
+        return uploaded
+
+    workers = min(CONTREE_CONCURRENCY, len(pending))
+    upload = functools.partial(upload_one_remote, client)
+    with ThreadPool(workers) as pool:
+        for mf, file_uuid in pool.imap_unordered(upload, pending):
+            uploaded[mf.host_path] = file_uuid
+            record_local_uuid(mf, file_uuid, store)
+    return uploaded
 
 
 def _build_payload(
@@ -403,8 +441,12 @@ def _build_payload(
 ) -> dict[str, object]:
     """Build the JSON payload for POST /v1/instances."""
     if args.shell:
-        command = " ".join(args.command_args)
+        # In shell mode the API runs `sh -c <command>`, so we must
+        # rebuild the original argv into a shell-safe expression.
+        command = shlex.join(args.command_args)
     else:
+        # In non-shell mode the API exec's command + args directly,
+        # JSON list elements preserve boundaries, no quoting needed.
         parts = args.command_args
         command = parts[0] if parts else ""
 
@@ -534,9 +576,7 @@ def cmd_run(args: RunArgs) -> int | None:
         print(str(exc), file=sys.stderr)
         return 1
 
-    uploaded: dict[str, str] = {}
-    for mf in expanded_files:
-        uploaded[mf.host_path] = _upload_file(client, mf, store)
+    uploaded = upload_files(client, expanded_files, store)
 
     # 2b. Include pending files from session store
     pending = store.pending_files()
@@ -670,6 +710,14 @@ def cmd_run(args: RunArgs) -> int | None:
     # 6. Cache terminal operation result
     store.cache[(op_uuid, "operation")] = op
 
+    if op["status"] != "SUCCESS":
+        logger.fatal(
+            "Operation %s ended with status %s%s",
+            op_uuid,
+            op["status"],
+            f": {op['error']}" if op.get("error") else "",
+        )
+
     # 7. Display result
     _display_operation(op, formatter)
 

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/client.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import base64
 import http.client
+import io
 import json
 import logging
 import platform
@@ -10,6 +11,7 @@ import time
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from importlib.metadata import PackageNotFoundError, version
+from typing import IO, cast
 from urllib.parse import urlencode, urlsplit
 
 from contree_cli.config import AuthType, ConfigProfile
@@ -33,6 +35,93 @@ CLI_USER_AGENT = (
 )
 
 
+class BodyFormatter:
+    """Lazy %s-arg for logging HTTP bodies — formats only on emit."""
+
+    def __init__(
+        self,
+        body: bytes | str | IO[bytes] | None,
+        content_type: str = "",
+        binary_max_size: int = 4096,
+    ) -> None:
+        self.body = body
+        self.binary_max_size = binary_max_size
+        self.content_type = content_type
+
+    def __str__(self) -> str:
+        match self.body:
+            case None:
+                return self.format_none()
+            case bytes() | bytearray() as data:
+                return self.dispatch_bytes(bytes(data))
+            case str() as text:
+                return self.dispatch_bytes(text.encode("utf-8", errors="replace"))
+            case _:
+                return self.format_stream()
+
+    def format_none(self) -> str:
+        return "<none>"
+
+    def format_stream(self) -> str:
+        return "<stream>"
+
+    def dispatch_bytes(self, data: bytes) -> str:
+        if not data:
+            return "<empty>"
+        if self.content_type and (
+            "json" in self.content_type or "text" in self.content_type
+        ):
+            return self.format_json(data)
+        if self.content_type:
+            return self.format_bytes(data)
+        return self.format_json(data)
+
+    def format_json(self, data: bytes) -> str:
+        truncated = data[: self.binary_max_size]
+        try:
+            text = truncated.decode("utf-8")
+        except UnicodeDecodeError:
+            return self.format_bytes(data)
+        if len(data) > self.binary_max_size:
+            return f"{text}... <truncated, {len(data)}B total>"
+        return text
+
+    def format_bytes(self, data: bytes) -> str:
+        if self.content_type:
+            return f"<binary {len(data)}B Content-Type={self.content_type!r}>"
+        return f"<binary {len(data)}B>"
+
+
+class BufferedResponse:
+    """Replay an HTTPResponse from buffered bytes (for debug body logging)."""
+
+    def __init__(
+        self,
+        status: int,
+        reason: str,
+        headers: list[tuple[str, str]],
+        data: bytes,
+    ) -> None:
+        self.status = status
+        self.reason = reason
+        self.headers = headers
+        self.buf = io.BytesIO(data)
+
+    def read(self, amt: int | None = None) -> bytes:
+        if amt is None:
+            return self.buf.read()
+        return self.buf.read(amt)
+
+    def getheader(self, name: str, default: str | None = None) -> str | None:
+        for k, v in self.headers:
+            if k.lower() == name.lower():
+                return v
+        return default
+
+    def getheaders(self) -> list[tuple[str, str]]:
+        return list(self.headers)
+
+
 class ApiError(Exception):
     """Raised when the contree API returns a non-2xx status."""
 
@@ -80,7 +169,7 @@ class ContreeClient(ABC):
         method: str,
         path: str,
         *,
-        body: bytes | None = None,
+        body: bytes | IO[bytes] | None = None,
         headers: dict[str, str] | None = None,
     ) -> http.client.HTTPResponse:
         merged: dict[str, str] = {
@@ -96,6 +185,13 @@ class ContreeClient(ABC):
         last_error: ApiError | None = None
         attempts = len(RETRY_DELAYS) + 1
 
+        log.debug(
+            "%s %s body=%s",
+            method,
+            full_path,
+            BodyFormatter(body, content_type=merged.get("Content-Type", "")),
+        )
+
         for attempt in range(attempts):
             if last_error is not None:
                 delay = RETRY_DELAYS[attempt - 1]
@@ -106,12 +202,15 @@ class ContreeClient(ABC):
                 )
                 time.sleep(delay)
 
-            log.debug(
-                "%s %s body=%s",
-                method,
-                full_path,
-                f"{len(body)}B" if body is not None else "none",
-            )
+            if attempt > 0 and hasattr(body, "seek"):
+                stream = cast(IO[bytes], body)
+                if not stream.seekable():
+                    raise ApiError(
+                        0,
+                        "RetryNotSeekable",
+                        "Cannot retry: streaming body is not seekable",
+                    )
+                stream.seek(0)
             try:
                 conn = self._connect()
                 conn.request(method, full_path, body, merged)
@@ -127,6 +226,8 @@ class ContreeClient(ABC):
                     resp.status,
                     resp.reason,
                 )
+                if log.isEnabledFor(logging.DEBUG):
+                    return self.log_and_buffer(method, full_path, resp)
                 return resp
 
             resp_body = resp.read().decode("utf-8", errors="replace")
@@ -138,6 +239,15 @@ class ContreeClient(ABC):
                 resp.reason,
                 len(resp_body),
             )
+            log.debug(
+                "%s %s response body: %s",
+                method,
+                full_path,
+                BodyFormatter(
+                    resp_body,
+                    content_type=resp.getheader("Content-Type", "") or "",
+                ),
+            )
             error = ApiError(resp.status, resp.reason, resp_body)
 
             if 500 <= resp.status < 600:
@@ -149,6 +259,40 @@ class ContreeClient(ABC):
         assert last_error is not None
         raise last_error
 
+    def log_and_buffer(
+        self,
+        method: str,
+        full_path: str,
+        resp: http.client.HTTPResponse,
+    ) -> http.client.HTTPResponse:
+        """Read & log a textual response body; pass binary streams through."""
+        content_type = resp.getheader("Content-Type", "") or ""
+        textual = not content_type or "json" in content_type or "text" in content_type
+        if not textual:
+            log.debug(
+                "%s %s response body: <stream Content-Type=%r>",
+                method,
+                full_path,
+                content_type,
+            )
+            return resp
+        data = resp.read()
+        log.debug(
+            "%s %s response body: %s",
+            method,
+            full_path,
+            BodyFormatter(data, content_type=content_type),
+        )
+        return cast(
+            http.client.HTTPResponse,
+            BufferedResponse(
+                status=resp.status,
+                reason=resp.reason,
+                headers=list(resp.getheaders()),
+                data=data,
+            ),
+        )
+
     # -- convenience methods --------------------------------------------------
 
     def get(
@@ -217,7 +361,7 @@ class ContreeJWTClient(ContreeClient):
 class ContreeIAMClient(ContreeClient):
     """Client using IAM authentication with a project header."""
 
-    DEFAULT_URL = "https://api.studio.nebius.com/sandboxes"
+    DEFAULT_URL = "https://api.tokenfactory.nebius.com/sandboxes"
 
     def __init__(
         self,

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/config.py

@@ -1,16 +1,45 @@
+from __future__ import annotations
+
 import configparser
 import logging
 import os
+import shutil
+import stat
 from collections.abc import Iterator, MutableMapping
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 
+from .migrations import run_migrations
+
 log = logging.getLogger(__name__)
 
-CONTREE_HOME = Path(os.getenv("CONTREE_HOME", "~/.config/contree-cli")).expanduser()
+
+def get_default_path(env: str, default: str | Path) -> Path:
+    return Path(os.getenv(env) or default).expanduser()
+
+
+XDG_CONFIG_HOME = get_default_path("XDG_CONFIG_HOME", "~/.config")
+CONTREE_HOME = get_default_path("CONTREE_HOME", XDG_CONFIG_HOME / "contree")
 CONFIG_DIR = CONTREE_HOME
-CONFIG_FILE = CONTREE_HOME / "config.ini"
+CONFIG_FILE = CONTREE_HOME / "auth.ini"
+CLI_CONFIG_FILE = CONTREE_HOME / "cli.ini"
+
+# Parsed at import time. Paths are fixed by CONTREE_HOME (env), so the
+# ``[cli]`` section is available before argparse runs and can supply
+# defaults that beat hardcoded ones but still lose to flags.
+SETTINGS = configparser.ConfigParser()
+SETTINGS.read([CLI_CONFIG_FILE, CONFIG_FILE])
+
+# Default editor for ``contree file edit`` when ``--editor`` is not given.
+# Resolved once at import time. Priority: $EDITOR > cli.ini > vim > nano > vi.
+EDITOR = (
+    os.environ.get("EDITOR")
+    or SETTINGS.get("cli", "editor", fallback=None)
+    or shutil.which("vim")
+    or shutil.which("nano")
+    or "vi"
+)
 
 
 class AuthType(str, Enum):
@@ -39,7 +68,7 @@ class ConfigProfile:
 
     @property
     def session_db_path(self) -> Path:
-        return CONTREE_HOME / f"sessions-{self.name}.db"
+        return CONTREE_HOME / "cli" / "sessions" / f"{self.name}.db"
 
     def remove_session_db(self) -> None:
         db = self.session_db_path
@@ -55,10 +84,11 @@ class Config(MutableMapping[str, ConfigProfile]):
     ``del cfg[name]``, ``name in cfg``, ``len(cfg)``, iteration.
     """
 
-    DEFAULT_IAM_URL = "https://api.studio.nebius.com/sandboxes"
+    DEFAULT_IAM_URL = "https://api.tokenfactory.nebius.com/sandboxes"
     PROFILE_PREFIX = "profile:"
 
     def __init__(self, path: Path | None = None) -> None:
+        run_migrations(CONTREE_HOME)
         self.__path = path or CONFIG_FILE
         self.__profiles: dict[str, ConfigProfile] = {}
         self.__active: str = "default"
@@ -68,8 +98,12 @@ class Config(MutableMapping[str, ConfigProfile]):
 
     def _load(self) -> None:
         cp = configparser.ConfigParser()
-        log.debug("Loading config from %s", self.__path)
-        cp.read(self.__path)
+        # Read cli.ini first, then auth.ini — later files override earlier
+        # ones, so secrets in auth.ini take precedence over any non-secret
+        # profile fields a user keeps in cli.ini (url, project, type, …).
+        sources = [CLI_CONFIG_FILE, self.__path]
+        log.debug("Loading config from %s", sources)
+        cp.read(sources)
         self.__active = cp.defaults().get("profile", "default")
         self.__profiles.clear()
         for section in cp.sections():
@@ -106,8 +140,16 @@ class Config(MutableMapping[str, ConfigProfile]):
             if profile.project is not None:
                 cp.set(section, "project", profile.project)
         self.__path.parent.mkdir(parents=True, exist_ok=True)
-        with open(self.__path, "w") as f:
+        # Create with 0o600 from the start so the token is never readable
+        # by other users — even between create() and chmod().
+        fd = os.open(
+            self.__path,
+            os.O_WRONLY | os.O_CREAT | os.O_TRUNC,
+            stat.S_IRUSR | stat.S_IWUSR,
+        )
+        with os.fdopen(fd, "w") as f:
             cp.write(f)
+        os.chmod(self.__path, stat.S_IRUSR | stat.S_IWUSR)
 
     # -- MutableMapping interface --------------------------------------------
 

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/manual.md

@@ -207,14 +207,17 @@ More: contree auth --help
 Configuration
 =============
 
-Data directory: ~/.config/contree-cli/ (override: $CONTREE_HOME)
+Data directory: $XDG_CONFIG_HOME/contree/ (or ~/.config/contree/);
+override with $CONTREE_HOME.
 
-  config.ini              profile credentials
-  sessions-{profile}.db   per-profile sessions
-  skills.db               agent skill registry
+  auth.ini                    profile credentials (mode 0600)
+  cli.ini                     optional CLI defaults
+  cli/sessions/{profile}.db   per-profile sessions
+  cli/skills.db               agent skill registry
 
 Environment variables:
   CONTREE_HOME       data directory
+  XDG_CONFIG_HOME    XDG base config dir, used to derive default CONTREE_HOME
   CONTREE_TOKEN      API token (overrides config)
   CONTREE_URL        API URL (overrides config)
   CONTREE_PROJECT    project ID (overrides config)

contree_cli-0.5.0/contree_cli/migrations.py

@@ -0,0 +1,92 @@
+"""One-shot data layout migrations for ``CONTREE_HOME``.
+
+DELETE-ME: this entire module is transitional. It carries users of
+``contree-cli <= 0.4.x`` (flat layout, ``~/.config/contree-cli/``) onto
+the current layout (``~/.config/contree/`` with a ``cli/`` subdir).
+
+After ~2 minor releases (target: ``0.7.0``) drop this file, the
+``run_migrations`` import and call in ``config.py``, and
+``tests/test_migrations.py``. Anyone still on the old layout at that
+point can do the rename by hand from the changelog.
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+LEGACY_DIRNAME = "contree-cli"
+LEGACY_CONFIG_BASENAME = "config.ini"
+
+
+def run_migrations(home: Path) -> None:
+    """Idempotent layout migrations into ``home``."""
+    migrate_legacy_dir(home)
+    migrate_into_cli_subdir(home)
+
+
+def migrate_legacy_dir(home: Path) -> None:
+    """Move ``<parent>/contree-cli/*`` into ``home``.
+
+    Renames ``config.ini`` to ``auth.ini``. Skipped when ``home/auth.ini``
+    already exists, so freshly-created session DBs in ``home`` don't
+    block credential migration.
+    """
+    legacy_dir = home.parent / LEGACY_DIRNAME
+    if not legacy_dir.is_dir():
+        return
+    if (home / "auth.ini").exists():
+        return
+
+    log.info("Migrating CONTREE_HOME: %s -> %s", legacy_dir, home)
+    home.mkdir(parents=True, exist_ok=True)
+
+    for item in legacy_dir.iterdir():
+        target_name = "auth.ini" if item.name == LEGACY_CONFIG_BASENAME else item.name
+        target = home / target_name
+        if target.exists():
+            log.warning("Skipping %s: %s already exists", item, target)
+            continue
+        item.rename(target)
+
+    try:
+        legacy_dir.rmdir()
+    except OSError:
+        log.debug(
+            "Legacy dir %s not empty after migration; leaving in place", legacy_dir
+        )
+
+
+def migrate_into_cli_subdir(home: Path) -> None:
+    """Move flat session/skill DBs into the ``cli/`` subdirectory.
+
+    - ``home/sessions-{name}.db*`` → ``home/cli/sessions/{name}.db*``
+    - ``home/skills.db*``          → ``home/cli/skills.db*``
+    """
+    if not home.is_dir():
+        return
+    cli_dir = home / "cli"
+    sessions_dir = cli_dir / "sessions"
+    moved_any = False
+
+    for item in home.iterdir():
+        if not item.is_file():
+            continue
+        if item.name.startswith("sessions-"):
+            target = sessions_dir / item.name[len("sessions-") :]
+            sessions_dir.mkdir(parents=True, exist_ok=True)
+        elif item.name.startswith("skills.db"):
+            target = cli_dir / item.name
+            cli_dir.mkdir(parents=True, exist_ok=True)
+        else:
+            continue
+
+        if target.exists():
+            log.warning("Skipping %s: %s already exists", item, target)
+            continue
+        if not moved_any:
+            log.info("Reorganising CLI state into %s", cli_dir)
+            moved_any = True
+        item.rename(target)

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/session.py

@@ -13,6 +13,8 @@ from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path, PurePosixPath
 
+CONTREE_CONCURRENCY = int(os.getenv("CONTREE_CONCURRENCY", "8"))
+
 
 @dataclass(frozen=True)
 class Session:

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/shell/repl.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import contextlib
 import logging
-import os
 import re
 import shlex
 import sys
@@ -391,15 +390,7 @@ class ContreeShell:
             print(f"Usage: {editor} <path>", file=sys.stderr)
             return
         resolved = self.resolve_path(args[0])
-        old_editor = os.environ.get("EDITOR")
-        os.environ["EDITOR"] = editor
-        try:
-            self.dispatch_contree(["file", "edit", resolved])
-        finally:
-            if old_editor is None:
-                os.environ.pop("EDITOR", None)
-            else:
-                os.environ["EDITOR"] = old_editor
+        self.dispatch_contree(["file", "edit", "--editor", editor, resolved])
 
     GLOB_CHARS = frozenset("*?[")
 

{contree_cli-0.4.4 → contree_cli-0.5.0}/contree_cli/skill.py

@@ -64,7 +64,7 @@ def default_claude_home() -> Path:
 
 @contextmanager
 def connect_registry() -> Iterator[sqlite3.Connection]:
-    db_path = config_mod.CONTREE_HOME / "skills.db"
+    db_path = config_mod.CONTREE_HOME / "cli" / "skills.db"
     db_path.parent.mkdir(parents=True, exist_ok=True)
     conn = sqlite3.connect(str(db_path), timeout=5.0)
     conn.row_factory = sqlite3.Row

{contree_cli-0.4.4 → contree_cli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "contree-cli"
-version = "0.4.4"
+version = "0.5.0"
 description = "CLI client for the ConTree sandbox platform"
 readme = "README.md"
 requires-python = ">=3.10"