cinna-cli 0.1.4__tar.gz → 0.1.5__tar.gz

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cinna-cli
-Version: 0.1.4
+Version: 0.1.5
 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
@@ -127,10 +127,13 @@ Read-only views onto the live sync session (started by `cinna dev`).
 
 Stream a command through the platform to the remote agent environment. Output streams back live; Ctrl+C aborts. Exit code matches the remote process.
 
+Arguments pass through transparently — each token is re-quoted before being sent, so spaces and shell metacharacters inside an argument survive intact. Use ordinary single-level quoting, exactly as for a local command. To run a shell snippet (pipes, redirects, `&&`), pass it to a shell explicitly: `cinna exec bash -c '…'`.
+
 ```bash
 cinna exec python scripts/main.py
 cinna exec pip install pandas
-cinna exec 'bash -c "ls -la"'
+cinna exec bash -c 'ls -la'
+cinna exec python -c 'import sys; print(sys.argv)' "a b"
 ```
 
 ### `cinna status`

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/README.md

@@ -90,10 +90,13 @@ Read-only views onto the live sync session (started by `cinna dev`).
 
 Stream a command through the platform to the remote agent environment. Output streams back live; Ctrl+C aborts. Exit code matches the remote process.
 
+Arguments pass through transparently — each token is re-quoted before being sent, so spaces and shell metacharacters inside an argument survive intact. Use ordinary single-level quoting, exactly as for a local command. To run a shell snippet (pipes, redirects, `&&`), pass it to a shell explicitly: `cinna exec bash -c '…'`.
+
 ```bash
 cinna exec python scripts/main.py
 cinna exec pip install pandas
-cinna exec 'bash -c "ls -la"'
+cinna exec bash -c 'ls -la'
+cinna exec python -c 'import sys; print(sys.argv)' "a b"
 ```
 
 ### `cinna status`

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/docs/README.md

@@ -328,6 +328,23 @@ Two surfaces expose conflicts:
 
 Ctrl+C closes the SSE stream; the platform cleans up the remote process. Interactive stdin (REPLs, debuggers) is out of scope for the current `/exec` endpoint.
 
+### Argument quoting
+
+There are **two shell passes** between the keyboard and the remote process, and only one round of quoting belongs to each:
+
+1. **Local shell** (the caller's terminal / agent Bash tool) splits the command line into argv and strips one layer of quotes. `exec` is declared `nargs=-1`, so Click receives these already-split tokens as a tuple.
+2. **Remote shell** — the platform runs the `command` string through `/bin/sh -c`, re-parsing it a second time.
+
+`exec_cmd` (`main.py`) bridges the two with `shlex.join(command)`: it re-quotes each token so the remote `sh -c` reconstructs the *exact* argv the caller typed. This makes `cinna exec` a transparent passthrough — callers write ordinary single-level quoting, exactly as for a local command:
+
+```bash
+cinna exec python -c 'import sys; print(sys.argv)' "a b" '[{"x":"y z"}]'
+```
+
+The historical `" ".join(command)` dropped the word boundaries that the local shell's quoting had implied, so any argument containing a space or a shell metacharacter (`;`, `(`, `{`, …) was re-split or mis-parsed by the remote shell — e.g. `print(sys.argv)` failing with `/bin/sh: Syntax error: word unexpected (expecting ")")`. Regression coverage: `test_exec_command_requotes_args` in `tests/test_main.py`.
+
+To run an actual remote shell snippet (pipes, redirects, `&&`), pass it explicitly to a shell: `cinna exec bash -c 'a | b > c'`.
+
 ---
 
 ## Bootstrap Flow

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/pyproject.toml

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

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/src/cinna/main.py

@@ -3,6 +3,7 @@
 import logging
 import os
 import platform
+import shlex
 import shutil
 import sys
 import time
@@ -125,10 +126,16 @@ def exec_cmd(timeout: int, command: tuple[str, ...]):
     Output streams back in real time via the platform. Exit code matches the
     remote process's exit code. Ctrl+C aborts the stream.
 
+    Arguments are passed through transparently: each token you type is
+    re-quoted (``shlex.quote``) before being sent, so spaces and shell
+    metacharacters inside an argument survive the remote shell intact. Use
+    ordinary single-level quoting, exactly as for a local command.
+
     Examples:
       cinna exec python scripts/main.py
       cinna exec pip install pandas
       cinna exec bash -c 'ls -la'
+      cinna exec python -c 'import sys; print(sys.argv)' "a b"
       cinna exec --timeout 3600 python long_backfill.py
 
     If your remote command takes its own ``--timeout`` flag, separate it
@@ -139,7 +146,7 @@ def exec_cmd(timeout: int, command: tuple[str, ...]):
     root = find_workspace_root()
     config = load_config(root)
 
-    exit_code = _run_remote_exec(config, " ".join(command), timeout=timeout)
+    exit_code = _run_remote_exec(config, shlex.join(command), timeout=timeout)
     sys.exit(exit_code)
 
 

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/tests/test_main.py

@@ -215,7 +215,35 @@ def test_exec_command(mock_load, mock_find, mock_exec, runner, workspace_root, s
 
     result = runner.invoke(cli, ["exec", "python", "scripts/main.py"])
     assert result.exit_code == 0
-    mock_exec.assert_called_once_with(sample_config, "python scripts/main.py")
+    mock_exec.assert_called_once_with(
+        sample_config, "python scripts/main.py", timeout=1800
+    )
+
+
+@patch("cinna.main._run_remote_exec")
+@patch("cinna.main.find_workspace_root")
+@patch("cinna.main.load_config")
+def test_exec_command_requotes_args(
+    mock_load, mock_find, mock_exec, runner, workspace_root, sample_config
+):
+    """Tokens with spaces / shell metacharacters must be re-quoted so the
+    remote shell reconstructs the exact argv the caller intended, rather than
+    re-splitting them. Regression for `cinna exec` mangling quoted arguments.
+    """
+    mock_find.return_value = workspace_root
+    mock_load.return_value = sample_config
+    mock_exec.return_value = 0
+
+    result = runner.invoke(
+        cli,
+        ["exec", "python", "-c", "import sys; print(sys.argv)", "a b", '[{"x":"y z"}]'],
+    )
+    assert result.exit_code == 0
+    mock_exec.assert_called_once_with(
+        sample_config,
+        """python -c 'import sys; print(sys.argv)' 'a b' '[{"x":"y z"}]'""",
+        timeout=1800,
+    )
 
 
 @patch("cinna.main.PlatformClient")

{cinna_cli-0.1.4 → cinna_cli-0.1.5}/uv.lock

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