cinna-cli 0.2.0__tar.gz → 0.2.1__tar.gz

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinna-cli
-Version: 0.2.0
+Version: 0.2.1
 Summary: Local development CLI for Cinna Core agents
 Project-URL: Homepage, https://github.com/opencinna/cinna-cli
 Project-URL: Repository, https://github.com/opencinna/cinna-cli

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cinna-cli"
-version = "0.2.0"
+version = "0.2.1"
 description = "Local development CLI for Cinna Core agents"
 readme = "README.md"
 requires-python = ">=3.10"

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/src/cinna/account.py

@@ -161,6 +161,44 @@ def parse_account_setup_input(raw_input: str) -> tuple[str, str]:
     return platform_url, text
 
 
+def default_account_dir_name(platform_url: str) -> str:
+    """Derive a default workspace folder name from the platform domain.
+
+    e.g. ``https://demo-core.opencinna.io`` → ``demo-core_opencinna_io``.
+    Hostname only (creds/port stripped); every run of non
+    ``[A-Za-z0-9-]`` characters collapses to a single underscore. Falls back to
+    ``DEFAULT_ACCOUNT_DIR`` when the URL has no usable host.
+    """
+    host = urlparse(platform_url).netloc or platform_url.strip()
+    host = host.split("@")[-1].split(":")[0]  # strip user:pass@ and :port
+    slug = re.sub(r"[^A-Za-z0-9-]+", "_", host).strip("_")
+    return slug or DEFAULT_ACCOUNT_DIR
+
+
+def _prompt_account_dir(default: str) -> str:
+    """Ask for the workspace folder name, offering ``default``.
+
+    Works in the ``curl ... | python3 -`` bootstrap too: there stdin carries the
+    installer script (not keystrokes), so when stdin is not a TTY we talk to the
+    controlling terminal via ``/dev/tty`` as long as stdout is a TTY. With no
+    terminal attached (CI, captured output) we return ``default`` unchanged so
+    non-interactive runs stay non-interactive.
+    """
+    if sys.stdin.isatty():
+        return click.prompt("Workspace folder name", default=default)
+
+    if not sys.stdout.isatty():
+        return default
+    try:
+        with open("/dev/tty", "r+") as tty:
+            tty.write(f"Workspace folder name [{default}]: ")
+            tty.flush()
+            line = tty.readline()
+    except OSError:
+        return default
+    return line.strip() or default
+
+
 def _exchange_account_setup_token(
     platform_url: str, token: str, machine_name: str
 ) -> dict:
@@ -335,8 +373,13 @@ def _write_account_mcp_config(account_root: Path) -> None:
     ``POST /account/knowledge/search`` — the account analogue of the per-agent
     workspace's knowledge tool. Auto-generated infra: overwritten on every
     ``cinna account setup`` / ``cinna account refresh-context``.
+
+    The config path is written **relative** to the account root (anchored at the
+    launch cwd, which MCP clients set to the workspace folder) so the folder can
+    be moved without breaking the proxy. ``run_mcp_proxy`` additionally walks up
+    from cwd, which self-heals older configs that stored an absolute path.
     """
-    account_config = str(account_config_path(account_root))
+    account_config = f"{CONFIG_DIR}/{ACCOUNT_CONFIG_FILE}"
 
     mcp_json = {
         "mcpServers": {
@@ -434,11 +477,23 @@ def _install_context_package(
 
 
 def run_account_setup(
-    setup_input: str, machine_name: str, dir_name: str = DEFAULT_ACCOUNT_DIR
+    setup_input: str, machine_name: str, dir_name: str | None = None
 ) -> None:
-    """Full account setup flow — called by `cinna account setup <token_or_url>`."""
+    """Full account setup flow — called by `cinna account setup <token_or_url>`.
+
+    When ``dir_name`` is not given (no ``--dir``), the folder name defaults to
+    the platform domain normalized (e.g. ``demo-core_opencinna_io``); the user
+    can accept it or type their own at the prompt.
+    """
     total = 3
 
+    # Parse before touching the filesystem / network so we can derive the
+    # default folder name from the platform domain (and fail fast on bad input).
+    platform_url, token = parse_account_setup_input(setup_input)
+
+    if not dir_name:
+        dir_name = _prompt_account_dir(default_account_dir_name(platform_url))
+
     # Guard the target directory before burning the single-use setup token.
     account_root = Path.cwd() / dir_name
     if account_config_path(account_root).exists():
@@ -449,7 +504,6 @@ def run_account_setup(
 
     # Step 1: Exchange the account setup token
     console.step(1, total, "Authenticating...")
-    platform_url, token = parse_account_setup_input(setup_input)
     payload = _exchange_account_setup_token(platform_url, token, machine_name)
 
     # Step 2: Materialize the account workspace

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/src/cinna/context.py

@@ -114,6 +114,14 @@ def generate_context_files(
     (workspace_root / "CLAUDE.md").write_text(claude_md)
 
 
+# Relative (workspace-root-anchored) path to the per-agent config. Written into
+# the generated MCP configs so the workspace folder can be moved without
+# breaking the proxy: MCP clients launch `cinna mcp-proxy` with cwd set to the
+# workspace root, and the proxy resolves this path against cwd. (`run_mcp_proxy`
+# also falls back to walking up from cwd, healing older absolute-path configs.)
+_REL_CONFIG_PATH = ".cinna/config.json"
+
+
 def generate_mcp_json(config: CinnaConfig, workspace_root: Path) -> None:
     """Generate .mcp.json for Claude Code MCP tool discovery."""
     mcp_config = {
@@ -122,7 +130,7 @@ def generate_mcp_json(config: CinnaConfig, workspace_root: Path) -> None:
                 "command": "cinna",
                 "args": ["mcp-proxy"],
                 "env": {
-                    "CINNA_CONFIG": str(workspace_root / ".cinna" / "config.json"),
+                    "CINNA_CONFIG": _REL_CONFIG_PATH,
                 },
             }
         }
@@ -138,7 +146,7 @@ def generate_opencode_json(config: CinnaConfig, workspace_root: Path) -> None:
                 "type": "local",
                 "command": ["cinna", "mcp-proxy"],
                 "environment": {
-                    "CINNA_CONFIG": str(workspace_root / ".cinna" / "config.json"),
+                    "CINNA_CONFIG": _REL_CONFIG_PATH,
                 },
                 "enabled": True,
             }

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/src/cinna/main.py

@@ -131,11 +131,12 @@ def account():
 @click.option(
     "--dir",
     "dir_name",
-    default="my-cinna",
-    show_default=True,
-    help="Directory to create the account workspace in",
+    default=None,
+    help="Directory to create the account workspace in "
+    "(default: the platform domain, e.g. demo-core_opencinna_io; "
+    "you'll be prompted to accept or change it)",
 )
-def account_setup(setup_input: tuple[str, ...], name: str | None, dir_name: str):
+def account_setup(setup_input: tuple[str, ...], name: str | None, dir_name: str | None):
     """Set up an account workspace from an account setup token.
 
     Accepts any of these formats (paste directly from Settings → Local

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/src/cinna/mcp_proxy.py

@@ -187,28 +187,105 @@ def _setup_mcp_logging(workspace_root: Path) -> None:
     root.addHandler(handler)
 
 
+def _resolve_proxy_context() -> tuple[str | None, Path | None]:
+    """Resolve ``(mode, workspace_root)`` for the proxy, tolerant of a moved folder.
+
+    ``mode`` is ``"account"`` or ``"agent"``; ``workspace_root`` is the directory
+    holding ``.cinna/``. Returns ``(None, None)`` when nothing can be located.
+
+    The ``CINNA_ACCOUNT_CONFIG`` / ``CINNA_CONFIG`` env vars (set by the generated
+    ``.mcp.json`` / ``opencode.json``) primarily **select the mode**; their value
+    is only a hint for locating the config. We resolve the workspace root in order:
+
+    1. The env value taken literally — an absolute path (legacy configs) or a
+       path relative to the launch cwd (the portable form newer configs write).
+    2. A walk up from the launch cwd for the mode's config file. MCP clients
+       launch the proxy with cwd set to the workspace folder, so this heals
+       stale absolute paths after the folder is moved — no regeneration needed.
+
+    When neither env var is set, we auto-detect the nearest ``.cinna/`` from cwd
+    (an agent's ``config.json`` nested under an account wins over the account's
+    ``account.json`` because it is found first).
+    """
+    from cinna.account import ACCOUNT_CONFIG_FILE, find_account_root
+    from cinna.config import CONFIG_DIR, CONFIG_FILE, find_workspace_root
+    from cinna.errors import AccountConfigNotFoundError, ConfigNotFoundError
+
+    cwd = Path.cwd()
+    account_env = os.environ.get("CINNA_ACCOUNT_CONFIG")
+    config_env = os.environ.get("CINNA_CONFIG")
+
+    def _root_from_env(env_value: str | None, filename: str) -> Path | None:
+        """Workspace root if env_value points at an existing .cinna/<filename>."""
+        if not env_value:
+            return None
+        candidates = [Path(env_value)]
+        if not Path(env_value).is_absolute():
+            candidates.append(cwd / env_value)
+        for cand in candidates:
+            if cand.is_file():
+                return cand.resolve().parent.parent
+        return None
+
+    if account_env is not None:
+        root = _root_from_env(account_env, ACCOUNT_CONFIG_FILE)
+        if root is None:
+            try:
+                root = find_account_root(cwd)
+            except AccountConfigNotFoundError:
+                root = None
+        if root is not None:
+            return "account", root
+
+    if config_env is not None:
+        root = _root_from_env(config_env, CONFIG_FILE)
+        if root is None:
+            try:
+                root = find_workspace_root(cwd)
+            except ConfigNotFoundError:
+                root = None
+        if root is not None:
+            return "agent", root
+
+    # No usable env hint — auto-detect the nearest .cinna/ walking up from cwd.
+    if account_env is None and config_env is None:
+        current = cwd.resolve()
+        while True:
+            cinna_dir = current / CONFIG_DIR
+            if (cinna_dir / ACCOUNT_CONFIG_FILE).is_file():
+                return "account", current
+            if (cinna_dir / CONFIG_FILE).is_file():
+                return "agent", current
+            parent = current.parent
+            if parent == current:
+                break
+            current = parent
+
+    return None, None
+
+
 def run_mcp_proxy():
     """Entry point for `cinna mcp-proxy` — run as MCP stdio server.
 
-    Two modes, selected by environment variable:
+    Two modes, selected by environment variable (see ``_resolve_proxy_context``
+    for how the workspace root is located in a move-tolerant way):
 
     * ``CINNA_ACCOUNT_CONFIG`` set → **account mode**: search the account user's
       platform knowledge sources (used by the account workspace's `.mcp.json`).
     * ``CINNA_CONFIG`` set → **per-agent mode**: search a single agent's
       knowledge base (used by a per-agent workspace's `.mcp.json`).
     """
-    account_config_path = os.environ.get("CINNA_ACCOUNT_CONFIG")
-    config_path = os.environ.get("CINNA_CONFIG")
-    if not account_config_path and not config_path:
+    mode, workspace_root = _resolve_proxy_context()
+    if mode is None:
         raise SystemExit(
-            "CINNA_CONFIG or CINNA_ACCOUNT_CONFIG environment variable not set"
+            "Could not locate a cinna workspace. Set CINNA_CONFIG or "
+            "CINNA_ACCOUNT_CONFIG, or run `cinna mcp-proxy` from inside a "
+            "workspace folder (one containing .cinna/)."
         )
 
-    if account_config_path:
-        # Account mode: <root>/.cinna/account.json → workspace root is parent.parent
-        workspace_root = Path(account_config_path).parent.parent
+    if mode == "account":
         _setup_mcp_logging(workspace_root)
-        logger.info("MCP proxy starting in account mode (config=%s)", account_config_path)
+        logger.info("MCP proxy starting in account mode (workspace=%s)", workspace_root)
 
         from cinna.account import load_account_config
 
@@ -224,9 +301,8 @@ def run_mcp_proxy():
             logger.exception("Failed to create account MCP server")
             raise
     else:
-        workspace_root = Path(config_path).parent.parent
         _setup_mcp_logging(workspace_root)
-        logger.info("MCP proxy starting (config=%s)", config_path)
+        logger.info("MCP proxy starting (workspace=%s)", workspace_root)
 
         try:
             config = load_config(workspace_root)

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/tests/test_account.py

@@ -119,6 +119,25 @@ def test_parse_account_rejects_per_agent_url():
         parse_account_setup_input("https://h.example/api/cli-setup/tok_abc")
 
 
+# --- default_account_dir_name ---
+
+
+@pytest.mark.parametrize(
+    "platform_url,expected",
+    [
+        ("https://demo-core.opencinna.io", "demo-core_opencinna_io"),
+        ("https://demo-core.opencinna.io/api", "demo-core_opencinna_io"),
+        ("http://localhost:8000/api", "localhost"),
+        ("https://user:pass@app.example.com:443", "app_example_com"),
+        ("", "my-cinna"),
+    ],
+)
+def test_default_account_dir_name(platform_url, expected):
+    from cinna.account import default_account_dir_name
+
+    assert default_account_dir_name(platform_url) == expected
+
+
 # --- account config I/O ---
 
 
@@ -222,7 +241,8 @@ def test_account_setup_creates_workspace(
     )
     assert captured["body"]["machine_name"] == "laptop"
 
-    root = tmp_path / "my-cinna"
+    # No --dir given → folder name defaults to the normalized platform domain.
+    root = tmp_path / "platform_example_com"
     cfg = load_account_config(root)
     assert cfg.account_token == "account-jwt-once"
     assert cfg.platform_url == "https://platform.example.com"
@@ -247,13 +267,11 @@ def test_account_setup_creates_workspace(
     proxy = mcp["mcpServers"]["platform-knowledge"]
     assert proxy["command"] == "cinna"
     assert proxy["args"] == ["mcp-proxy"]
-    assert proxy["env"]["CINNA_ACCOUNT_CONFIG"] == str(account_config_path(root))
+    assert proxy["env"]["CINNA_ACCOUNT_CONFIG"] == ".cinna/account.json"
     opencode = json.loads((root / "opencode.json").read_text())
     oc_proxy = opencode["mcp"]["platform-knowledge"]
     assert oc_proxy["command"] == ["cinna", "mcp-proxy"]
-    assert oc_proxy["environment"]["CINNA_ACCOUNT_CONFIG"] == str(
-        account_config_path(root)
-    )
+    assert oc_proxy["environment"]["CINNA_ACCOUNT_CONFIG"] == ".cinna/account.json"
 
     # Context package extracted under context/.
     mock_client.download_context_package.assert_called_once()
@@ -325,6 +343,8 @@ def test_account_setup_refuses_existing_workspace(
             "https://platform.example.com/api/cli-setup/account/TOK",
             "--name",
             "laptop",
+            "--dir",
+            "my-cinna",
         ],
     )
     assert result.exit_code != 0
@@ -376,14 +396,55 @@ def test_account_setup_continues_on_context_failure(
     assert "Context package download failed" in result.output
     assert "refresh-context" in result.output
 
-    # The workspace itself is fully materialized.
-    root = tmp_path / "my-cinna"
+    # The workspace itself is fully materialized (domain-derived default dir).
+    root = tmp_path / "platform_example_com"
     assert load_account_config(root).account_token == "account-jwt-once"
     assert (root / "agents").is_dir()
     assert (root / "CLAUDE.md").is_file()
     assert not (root / "context").exists()
 
 
+@patch("cinna.account.AccountClient")
+@patch("cinna.account.httpx.post")
+def test_account_setup_explicit_dir_overrides_domain_default(
+    mock_post, mock_client_cls, runner, tmp_path, monkeypatch
+):
+    """An explicit ``--dir`` wins over the domain-derived default."""
+    monkeypatch.chdir(tmp_path)
+    mock_client = mock_client_cls.return_value.__enter__.return_value
+    mock_client.download_context_package.return_value = make_context_tarball()
+
+    class FakeResponse:
+        status_code = 200
+        text = ""
+
+        def json(self):
+            return {
+                "account_token": "account-jwt-once",
+                "platform_url": "https://platform.example.com",
+                "frontend_url": "https://ui.example.com",
+                "machine_name": "laptop",
+            }
+
+    mock_post.return_value = FakeResponse()
+
+    result = runner.invoke(
+        cli,
+        [
+            "account",
+            "setup",
+            "https://platform.example.com/api/cli-setup/account/TOK",
+            "--name",
+            "laptop",
+            "--dir",
+            "my-custom-folder",
+        ],
+    )
+    assert result.exit_code == 0, result.output
+    assert (tmp_path / "my-custom-folder" / ".cinna" / "account.json").is_file()
+    assert not (tmp_path / "platform_example_com").exists()
+
+
 # --- cinna account refresh-context ---
 
 
@@ -529,7 +590,8 @@ def test_write_account_mcp_config_wires_account_mode(account_root):
 
     _write_account_mcp_config(account_root)
 
-    expected_cfg = str(account_config_path(account_root))
+    # Relative path (anchored at the workspace folder) so the folder is portable.
+    expected_cfg = ".cinna/account.json"
 
     mcp = json.loads((account_root / ".mcp.json").read_text())
     proxy = mcp["mcpServers"]["platform-knowledge"]
@@ -599,6 +661,52 @@ def account_cfg_token(account_root: Path) -> str:
     return load_account_config(account_root).account_token
 
 
+# --- move-tolerant proxy context resolution ---
+
+
+def test_proxy_context_relative_path_resolved_from_cwd(account_root, monkeypatch):
+    """A relative CINNA_ACCOUNT_CONFIG resolves against the launch cwd (the
+    workspace folder MCP clients cd into) — the portable form newer configs write."""
+    from cinna.mcp_proxy import _resolve_proxy_context
+
+    monkeypatch.chdir(account_root)
+    monkeypatch.setenv("CINNA_ACCOUNT_CONFIG", ".cinna/account.json")
+    monkeypatch.delenv("CINNA_CONFIG", raising=False)
+
+    mode, root = _resolve_proxy_context()
+    assert mode == "account"
+    assert root == account_root.resolve()
+
+
+def test_proxy_context_stale_absolute_path_heals_via_cwd(account_root, monkeypatch):
+    """A stale absolute CINNA_ACCOUNT_CONFIG (folder moved) falls back to walking
+    up from cwd, so an unregenerated legacy config keeps working after a move."""
+    from cinna.mcp_proxy import _resolve_proxy_context
+
+    monkeypatch.chdir(account_root)
+    monkeypatch.setenv(
+        "CINNA_ACCOUNT_CONFIG", "/old/location/my-cinna/.cinna/account.json"
+    )
+    monkeypatch.delenv("CINNA_CONFIG", raising=False)
+
+    mode, root = _resolve_proxy_context()
+    assert mode == "account"
+    assert root == account_root.resolve()
+
+
+def test_proxy_context_autodetects_nearest_cinna_without_env(account_root, monkeypatch):
+    """With no env hint, the proxy auto-detects the nearest .cinna/ from cwd."""
+    from cinna.mcp_proxy import _resolve_proxy_context
+
+    monkeypatch.chdir(account_root)
+    monkeypatch.delenv("CINNA_ACCOUNT_CONFIG", raising=False)
+    monkeypatch.delenv("CINNA_CONFIG", raising=False)
+
+    mode, root = _resolve_proxy_context()
+    assert mode == "account"
+    assert root == account_root.resolve()
+
+
 # --- cinna account agents ---
 
 

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/tests/test_context.py

@@ -43,6 +43,8 @@ def test_generate_mcp_json(workspace_root, sample_config):
     server = data["mcpServers"]["agent-knowledge"]
     assert server["command"] == "cinna"
     assert server["args"] == ["mcp-proxy"]
+    # Relative path so the workspace folder stays portable when moved.
+    assert server["env"]["CINNA_CONFIG"] == ".cinna/config.json"
 
 
 def test_generate_opencode_json(workspace_root, sample_config):
@@ -60,6 +62,7 @@ def test_generate_opencode_json(workspace_root, sample_config):
     assert server["type"] == "local"
     assert server["command"] == ["cinna", "mcp-proxy"]
     assert server["enabled"] is True
+    assert server["environment"]["CINNA_CONFIG"] == ".cinna/config.json"
 
 
 def test_generate_gitignore(workspace_root):

{cinna_cli-0.2.0 → cinna_cli-0.2.1}/uv.lock

@@ -136,7 +136,7 @@ wheels = [
 
 [[package]]
 name = "cinna-cli"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },