Merge pull request #28 from imbue-ai/danver/fix-modal-create-command

Fix modal-create justfile command

Author: danverbraganza

.dockerignore

@@ -0,0 +1,50 @@
+# Rust build artifacts (can be gigabytes)
+/target/
+target/
+
+# Version control
+.git/
+.jj/
+
+# IDE/editor files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+\#*\#
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+venv/
+.pytest_cache/
+.ruff_cache/
+
+# Node
+node_modules/
+
+# Test output
+/test-results/
+test-results/
+
+# Local caches
+.offload/
+.beads/
+
+# Claude Code agent files
+.claude/
+
+# Secrets (should never be uploaded)
+*.pem
+*_key
+id_rsa*
+id_ed25519*
+
+# Local config overrides
+offload.local.toml

offload-modal.toml

@@ -9,7 +9,7 @@ stream_output = true
 [provider]
 type = "modal"
 app_name = "offload-sandbox"
-image_type = { dockerfile = ".devcontainer/Dockerfile" }
+dockerfile = ".devcontainer/Dockerfile"
 timeout_secs = 600
 
 [groups.unit]

src/cache.rs

@@ -27,7 +27,7 @@ pub struct ImageCacheEntry {
     /// ISO 8601 timestamp when the entry was created
     pub created_at: String,
 
-    /// Type of image: "dockerfile" or "preset" (e.g., "default", "rust")
+    /// Type of image (e.g., "dockerfile")
     pub image_type: String,
 }
 
@@ -228,12 +228,12 @@ mod tests {
         // Create and save a cache
         let mut cache = ImageCache::default();
         cache.insert(
-            "default".to_string(),
+            "dockerfile:test".to_string(),
             ImageCacheEntry {
                 image_id: "im-abc123".to_string(),
-                dockerfile_hash: None,
+                dockerfile_hash: Some("abc123".to_string()),
                 created_at: "2024-01-01T00:00:00Z".to_string(),
-                image_type: "preset".to_string(),
+                image_type: "dockerfile".to_string(),
             },
         );
 
@@ -243,27 +243,29 @@ mod tests {
         let loaded_cache = ImageCache::load(temp_dir.path());
         assert_eq!(loaded_cache.entries.len(), 1);
 
-        let entry = loaded_cache.get("default").ok_or("Entry not found")?;
+        let entry = loaded_cache
+            .get("dockerfile:test")
+            .ok_or("Entry not found")?;
         assert_eq!(entry.image_id, "im-abc123");
-        assert_eq!(entry.image_type, "preset");
-        assert!(entry.dockerfile_hash.is_none());
+        assert_eq!(entry.image_type, "dockerfile");
+        assert_eq!(entry.dockerfile_hash, Some("abc123".to_string()));
         Ok(())
     }
 
     #[test]
     fn test_cache_get() {
         let mut cache = ImageCache::default();
         cache.insert(
-            "default".to_string(),
+            "dockerfile:test".to_string(),
             ImageCacheEntry {
                 image_id: "im-abc123".to_string(),
-                dockerfile_hash: None,
+                dockerfile_hash: Some("abc123".to_string()),
                 created_at: "2024-01-01T00:00:00Z".to_string(),
-                image_type: "preset".to_string(),
+                image_type: "dockerfile".to_string(),
             },
         );
 
-        assert!(cache.get("default").is_some());
+        assert!(cache.get("dockerfile:test").is_some());
         assert!(cache.get("nonexistent").is_none());
     }
 
@@ -363,28 +365,28 @@ mod tests {
         let mut cache = ImageCache::default();
 
         cache.insert(
-            "default".to_string(),
+            "dockerfile:test".to_string(),
             ImageCacheEntry {
                 image_id: "im-abc123".to_string(),
-                dockerfile_hash: None,
+                dockerfile_hash: Some("hash1".to_string()),
                 created_at: "2024-01-01T00:00:00Z".to_string(),
-                image_type: "preset".to_string(),
+                image_type: "dockerfile".to_string(),
             },
         );
 
         // Insert again with different ID
         cache.insert(
-            "default".to_string(),
+            "dockerfile:test".to_string(),
             ImageCacheEntry {
                 image_id: "im-xyz789".to_string(),
-                dockerfile_hash: None,
+                dockerfile_hash: Some("hash2".to_string()),
                 created_at: "2024-01-02T00:00:00Z".to_string(),
-                image_type: "preset".to_string(),
+                image_type: "dockerfile".to_string(),
             },
         );
 
         // Should have the new ID
-        let entry = cache.get("default").ok_or("Entry not found")?;
+        let entry = cache.get("dockerfile:test").ok_or("Entry not found")?;
         assert_eq!(entry.image_id, "im-xyz789");
         assert_eq!(cache.entries.len(), 1);
         Ok(())

src/config/schema.rs

@@ -127,7 +127,6 @@ pub enum ProviderConfig {
     /// Run tests using Modal cloud sandboxes.
     ///
     /// Provides first-class integration with Modal for ephemeral compute.
-    /// Supports both custom Dockerfiles and Modal's preset images.
     Modal(ModalProviderConfig),
 
     /// Run tests using custom shell commands.
@@ -180,42 +179,6 @@ pub struct LocalProviderConfig {
 fn default_shell() -> String {
     "/bin/sh".to_string()
 }
-
-/// Image type specification for Modal provider.
-///
-/// Determines whether to use a custom Dockerfile or a Modal preset image.
-/// The enum uses untagged deserialization - it checks for a "dockerfile" or
-/// "preset" field to determine the variant.
-///
-/// # Example: Dockerfile
-///
-/// ```toml
-/// [provider]
-/// type = "modal"
-/// image_type = { dockerfile = ".devcontainer/Dockerfile" }
-/// ```
-///
-/// # Example: Preset
-///
-/// ```toml
-/// [provider]
-/// type = "modal"
-/// image_type = { preset = "rust" }
-/// ```
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(untagged)]
-pub enum ModalImageType {
-    /// Build image from a Dockerfile.
-    ///
-    /// Path is relative to the project root.
-    Dockerfile { dockerfile: String },
-
-    /// Use a Modal preset image.
-    ///
-    /// Common presets: "default", "rust", "python", "node".
-    Preset { preset: String },
-}
-
 /// Configuration for the Modal cloud provider.
 ///
 /// Modal provides ephemeral cloud sandboxes with first-class Docker support.
@@ -228,20 +191,10 @@ pub enum ModalImageType {
 /// [provider]
 /// type = "modal"
 /// app_name = "offload-sandbox"
-/// image_type = { dockerfile = ".devcontainer/Dockerfile" }
+/// dockerfile = ".devcontainer/Dockerfile"
 /// working_dir = "/workspace"
 /// timeout_secs = 600
 /// ```
-///
-/// # Example: Preset Image
-///
-/// ```toml
-/// [provider]
-/// type = "modal"
-/// app_name = "test-runner"
-/// image_type = { preset = "rust" }
-/// timeout_secs = 3600
-/// ```
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct ModalProviderConfig {
     /// Modal app name for the sandbox.
@@ -257,8 +210,8 @@ pub struct ModalProviderConfig {
 
     /// Image configuration for the sandbox.
     ///
-    /// Either a path to a Dockerfile or a Modal preset name.
-    pub image_type: ModalImageType,
+    /// A path to the Dockerfile on which this image is based
+    pub dockerfile: String,
 
     /// Working directory inside the sandbox.
     ///
@@ -646,7 +599,7 @@ mod tests {
             [provider]
             type = "modal"
             app_name = "offload-sandbox"
-            image_type = { dockerfile = ".devcontainer/Dockerfile" }
+            dockerfile = ".devcontainer/Dockerfile"
             timeout_secs = 600
 
             [groups.test]
@@ -664,56 +617,7 @@ mod tests {
             assert_eq!(modal_config.app_name, "offload-sandbox");
             assert_eq!(modal_config.timeout_secs, 600);
             assert!(modal_config.working_dir.is_none());
-
-            assert!(
-                matches!(&modal_config.image_type, ModalImageType::Dockerfile { .. }),
-                "Expected Dockerfile image type"
-            );
-
-            if let ModalImageType::Dockerfile { dockerfile } = &modal_config.image_type {
-                assert_eq!(dockerfile, ".devcontainer/Dockerfile");
-            }
-        }
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_modal_provider_with_preset() -> Result<(), Box<dyn std::error::Error>> {
-        let toml = r#"
-            [offload]
-            max_parallel = 4
-
-            [provider]
-            type = "modal"
-            app_name = "test-runner"
-            image_type = { preset = "rust" }
-            working_dir = "/workspace"
-
-            [groups.test]
-            type = "cargo"
-        "#;
-
-        let config: Config = toml::from_str(toml)?;
-
-        assert!(
-            matches!(&config.provider, ProviderConfig::Modal(_)),
-            "Expected Modal provider"
-        );
-
-        if let ProviderConfig::Modal(modal_config) = &config.provider {
-            assert_eq!(modal_config.app_name, "test-runner");
-            assert_eq!(modal_config.timeout_secs, 3600); // default value
-            assert_eq!(modal_config.working_dir, Some(PathBuf::from("/workspace")));
-
-            assert!(
-                matches!(&modal_config.image_type, ModalImageType::Preset { .. }),
-                "Expected Preset image type"
-            );
-
-            if let ModalImageType::Preset { preset } = &modal_config.image_type {
-                assert_eq!(preset, "rust");
-            }
+            assert_eq!(&modal_config.dockerfile, ".devcontainer/Dockerfile");
         }
 
         Ok(())