Execute Python KCL programs on the engine

rust/kcl-lib/Cargo.toml

@@ -72,7 +72,7 @@ kcl-error = { version = "=0.2.193", path = "../kcl-error" }
 kcl-syntax = { version = "=0.2.193", path = "../kcl-syntax" }
 ezpz = { workspace = true }
 kittycad = { workspace = true }
-kittycad-modeling-cmds = { workspace = true }
+kittycad-modeling-cmds = { workspace = true, features = ["exec-kcl"] }
 lazy_static = { workspace = true }
 libm = "0.2.16"
 miette = { workspace = true }

rust/kcl-lib/src/engine/engine_manager.rs

@@ -753,7 +753,7 @@ impl EngineManager {
         })
     }
 
-    fn parse_websocket_response(
+    pub(crate) fn parse_websocket_response(
         &self,
         response: WebSocketResponse,
         source_range: SourceRange,

rust/kcl-lib/src/engine/engine_manager/ws_transport.rs

@@ -374,13 +374,15 @@ impl WebSocketTransport {
                         Some(ToEngineReq { req, request_sent }) => {
                             // Decide whether to send as binary or text,
                             // then send to the engine.
-                            let res = if matches!(
+                            let send_via_binary = matches!(
                                 &req,
                                 WebSocketRequest::ModelingCmdReq(ModelingCmdReq {
                                     cmd: ModelingCmd::ImportFiles { .. },
                                     cmd_id: _,
                                 })
-                            ) {
+                                | WebSocketRequest::ExecKclProject { .. }
+                            );
+                            let res = if send_via_binary {
                                 Self::inner_send_to_engine_binary(req, &mut tcp_write).await
                             } else {
                                 Self::inner_send_to_engine(req, &mut tcp_write).await

rust/kcl-lib/src/execution/id_generator.rs

@@ -10,11 +10,26 @@ const NAMESPACE_KCL: uuid::Uuid = uuid::uuid!("8bda3118-75eb-58c7-a866-bef1dcb49
 pub struct IdGenerator {
     module_id: Option<ModuleId>,
     next_id: u64,
+    namespace: Option<uuid::Uuid>,
 }
 
 impl IdGenerator {
     pub fn new(module_id: Option<ModuleId>) -> Self {
-        Self { module_id, next_id: 0 }
+        Self {
+            module_id,
+            next_id: 0,
+            namespace: None,
+        }
+    }
+
+    /// A stable client namespace makes follow-up command IDs repeatable without
+    /// reusing IDs allocated by the remote interpreter.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(super) fn remote_session() -> Self {
+        Self {
+            namespace: Some(uuid::Uuid::new_v5(&NAMESPACE_KCL, b"remote-client")),
+            ..Self::default()
+        }
     }
 
     pub fn next_uuid(&mut self) -> uuid::Uuid {
@@ -25,7 +40,7 @@ impl IdGenerator {
             self.module_id.map(|id| id.to_string()).unwrap_or("none".to_string()),
             next_id
         );
-        let next_uuid = uuid::Uuid::new_v5(&NAMESPACE_KCL, next.as_bytes());
+        let next_uuid = uuid::Uuid::new_v5(self.namespace.as_ref().unwrap_or(&NAMESPACE_KCL), next.as_bytes());
 
         self.next_id += 1;
 

rust/kcl-lib/src/execution/mod.rs

@@ -180,6 +180,8 @@ pub(crate) mod kcl_value_view;
 pub(crate) mod machine;
 mod memory;
 mod modeling;
+#[cfg(not(target_arch = "wasm32"))]
+mod remote;
 mod sketch_solve;
 mod solver_arc;
 mod state;