model-compose 0.4.50__tar.gz → 0.4.52__tar.gz

{model_compose-0.4.50 → model_compose-0.4.52}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.50
+Version: 0.4.52
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.50 → model_compose-0.4.52}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.50"
+version = "0.4.52"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/cli/compose.py

@@ -65,12 +65,9 @@ def up_command(
             config = _load_compose_config(config_files, env_files, env_data)
             await launch_services(config, detach, verbose)
         except Exception as e:
-            if verbose:
-                import traceback
-                click.echo(f"❌ Error: {e}\n\nTraceback:", err=True)
-                traceback.print_exc()
-            else:
-                click.echo(f"❌ {e}", err=True)
+            import traceback
+            click.echo(f"❌ Error: {e}\n\nTraceback:", err=True)
+            traceback.print_exc()
             raise SystemExit(1)
     asyncio.run(_async_command())
 

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/graph_store/drivers/arangodb.py

@@ -257,7 +257,7 @@ class ArangoDBGraphStoreService(GraphStoreService):
     def _create_client(self) -> Tuple[ArangoClient, StandardDatabase]:
         from arango import ArangoClient
 
-        url = f"{self.config.protocol}://{self.config.host}:{self.config.port}"
+        url = self.config.url if self.config.url else f"{self.config.protocol}://{self.config.host}:{self.config.port}"
         client = ArangoClient(
             hosts=url,
             request_timeout=parse_duration(self.config.timeout).total_seconds()

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/graph_store/drivers/neo4j.py

@@ -301,9 +301,10 @@ class Neo4jGraphStoreService(GraphStoreService):
         from neo4j import AsyncGraphDatabase
 
         auth = (self.config.username, self.config.password) if self.config.username else None
+        url = self.config.url if self.config.url else f"{self.config.protocol}://{self.config.host}:{self.config.port}"
 
         return AsyncGraphDatabase.driver(
-            self.config.uri,
+            url,
             auth=auth,
             connection_timeout=parse_duration(self.config.timeout).total_seconds()
         )

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/http_server.py

@@ -8,7 +8,7 @@ from mindor.core.utils.http_client import HttpClient
 from mindor.core.utils.http_status import is_status_code_matched
 from mindor.core.utils.streaming import StreamResource
 from mindor.core.utils.time import parse_duration
-from mindor.core.utils.shell import run_command_streaming
+from mindor.core.utils.shell import run_command_foreground
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 from datetime import datetime, timezone
@@ -151,16 +151,16 @@ class HttpServerComponent(ComponentService):
     async def _setup(self) -> None:
         if self.config.manage.scripts.install:
             for command in self.config.manage.scripts.install:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
         if self.config.manage.scripts.build:
             for command in self.config.manage.scripts.build:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _teardown(self):
         if self.config.manage.scripts.clean:
             for command in self.config.manage.scripts.clean:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _start(self) -> None:
         base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
@@ -174,7 +174,7 @@ class HttpServerComponent(ComponentService):
 
     async def _serve(self) -> None:
         if self.config.manage.scripts.start:
-            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
+            await run_command_foreground(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
     async def _is_ready(self) -> bool:
         try:

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/mcp_server.py

@@ -2,7 +2,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import McpServerComponentConfig
 from mindor.dsl.schema.action import ActionConfig, McpServerActionConfig
 from mindor.core.utils.mcp_client import McpClient, ContentBlock, TextContent, ImageContent, AudioContent
-from mindor.core.utils.shell import run_command_streaming
+from mindor.core.utils.shell import run_command_foreground
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
 import asyncio
@@ -45,16 +45,16 @@ class McpServerComponent(ComponentService):
     async def _setup(self) -> None:
         if self.config.manage.scripts.install:
             for command in self.config.manage.scripts.install:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
         if self.config.manage.scripts.build:
             for command in self.config.manage.scripts.build:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _teardown(self):
         if self.config.manage.scripts.clean:
             for command in self.config.manage.scripts.clean:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _start(self) -> None:
         base_url = f"http://localhost:{self.config.port}" + (self.config.base_path or "")
@@ -68,7 +68,7 @@ class McpServerComponent(ComponentService):
 
     async def _serve(self) -> None:
         if self.config.manage.scripts.start:
-            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
+            await run_command_foreground(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
     async def _is_ready(self) -> bool:
         try:

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/shell.py

@@ -1,7 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from mindor.dsl.schema.component import ShellComponentConfig
 from mindor.dsl.schema.action import ActionConfig, ShellActionConfig
-from mindor.core.utils.shell import run_command_streaming, run_command
+from mindor.core.utils.shell import run_command_foreground, run_command
 from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
@@ -74,12 +74,12 @@ class ShellComponent(ComponentService):
     async def _setup(self) -> None:
         if self.config.manage.scripts.install:
             for command in self.config.manage.scripts.install:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _teardown(self):
         if self.config.manage.scripts.clean:
             for command in self.config.manage.scripts.clean:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _run(self, action: ActionConfig, context: ComponentActionContext) -> Any:
         return await ShellAction(action, self.config.base_dir, self.config.env).run(context)

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/web_browser/drivers/chrome.py

@@ -317,7 +317,7 @@ class ChromeWebBrowserService(WebBrowserService):
             client = CdpClient(self.config.endpoint)
             await client.connect()
         else:
-            client = await CdpClient.from_host_port(
+            client = await CdpClient.discover(
                 self.config.host, self.config.port, self.config.target_index
             )
         return ChromeBrowserSession(client)

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/component/services/websocket_server.py

@@ -4,7 +4,7 @@ from mindor.dsl.schema.action import ActionConfig, WebSocketServerActionConfig
 from mindor.dsl.schema.action.impl.websocket_server import WebSocketReceiveFormat
 from mindor.core.utils.websocket_client import WebSocketClient, WebSocketConnection
 from mindor.core.utils.streaming import BytesStreamResource
-from mindor.core.utils.shell import run_command_streaming
+from mindor.core.utils.shell import run_command_foreground
 from mindor.core.utils.time import parse_duration
 from ..base import ComponentService, ComponentType, ComponentGlobalConfigs, register_component
 from ..context import ComponentActionContext
@@ -130,16 +130,16 @@ class WebSocketServerComponent(ComponentService):
     async def _setup(self) -> None:
         if self.config.manage.scripts.install:
             for command in self.config.manage.scripts.install:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
         if self.config.manage.scripts.build:
             for command in self.config.manage.scripts.build:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _teardown(self):
         if self.config.manage.scripts.clean:
             for command in self.config.manage.scripts.clean:
-                await run_command_streaming(command, self.config.manage.working_dir, self.config.manage.env)
+                await run_command_foreground(command, self.config.manage.working_dir, self.config.manage.env)
 
     async def _start(self) -> None:
         base_url = f"ws://localhost:{self.config.port}" + (self.config.base_path or "")
@@ -160,7 +160,7 @@ class WebSocketServerComponent(ComponentService):
 
     async def _serve(self) -> None:
         if self.config.manage.scripts.start:
-            await run_command_streaming(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
+            await run_command_foreground(self.config.manage.scripts.start, self.config.manage.working_dir, self.config.manage.env)
 
     async def _is_ready(self) -> bool:
         try:

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/runtime/docker/docker.py

@@ -109,6 +109,7 @@ class DockerRuntimeManager:
                     entrypoint=self.config.entrypoint,
                     working_dir=self.config.working_dir,
                     user=self.config.user,
+                    shm_size=self.config.shm_size,
                     mem_limit=self.config.mem_limit,
                     memswap_limit=self.config.memswap_limit,
                     cpu_shares=self.config.cpu_shares,

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/system/services/__init__.py

@@ -1 +1,2 @@
 from .docker_compose import *
+from .docker import *

model_compose-0.4.52/src/mindor/core/system/services/docker.py

@@ -0,0 +1,57 @@
+from mindor.dsl.schema.system.impl.docker import DockerSystemConfig
+from mindor.dsl.schema.system.impl.types import SystemType
+from mindor.dsl.schema.runtime.impl.docker import DockerRuntimeConfig
+from mindor.dsl.schema.runtime.impl.types import RuntimeType
+from mindor.core.system.base import SystemService, register_system
+from mindor.core.runtime.docker.docker import DockerRuntimeManager
+from mindor.core.logger import logging
+import shutil
+
+@register_system(SystemType.DOCKER)
+class DockerSystem(SystemService):
+    def __init__(self, id: str, config: DockerSystemConfig, daemon: bool):
+        super().__init__(id, config, daemon)
+
+        self.config: DockerSystemConfig = config
+        self._configure_system_config()
+
+        self._runtime: DockerRuntimeManager = DockerRuntimeManager(
+            config=self._build_runtime_config(self.config),
+            verbose=True,
+        )
+
+    def _configure_system_config(self) -> None:
+        if not self.config.container_name:
+            self.config.container_name = f"mindor-system-{self.id}"
+
+    def _build_runtime_config(self, config: DockerSystemConfig) -> DockerRuntimeConfig:
+        shared_fields = set(DockerRuntimeConfig.model_fields) & set(DockerSystemConfig.model_fields)
+        return DockerRuntimeConfig(**{
+            **{ k: getattr(config, k) for k in shared_fields },
+            "type": RuntimeType.DOCKER,
+        })
+
+    async def _setup(self) -> None:
+        if not shutil.which("docker"):
+            raise RuntimeError("'docker' command not found. Please install Docker to use docker systems.")
+
+        if self.config.build:
+            await self._runtime.build_image()
+        elif self.config.image:
+            if not await self._runtime.exists_image():
+                await self._runtime.pull_image()
+
+    async def _serve(self) -> None:
+        await self._runtime.start_container(detach=True)
+        logging.info(f"Docker container started: {self.config.container_name or self.config.image}")
+
+    async def _shutdown(self) -> None:
+        try:
+            await self._runtime.stop_container()
+            await self._runtime.remove_container()
+            logging.info(f"Docker container stopped: {self.config.container_name or self.config.image}")
+        except Exception as e:
+            logging.warning(f"Docker container cleanup failed: {e}")
+
+    async def _is_ready(self) -> bool:
+        return await self._runtime.is_container_running()

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/system/services/docker_compose.py

@@ -3,6 +3,7 @@ from mindor.dsl.schema.system.impl.docker_compose import DockerComposeSystemConf
 from mindor.dsl.schema.system.impl.types import SystemType
 from mindor.core.system.base import SystemService, register_system
 from mindor.core.logger import logging
+from mindor.core.utils.shell import run_command_foreground
 from mindor.core.utils.time import parse_duration
 import asyncio
 import shutil
@@ -20,33 +21,19 @@ class DockerComposeSystem(SystemService):
 
     async def _serve(self) -> None:
         command = self._build_up_command()
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-
-        stdout, stderr = await process.communicate()
+        exit_code = await run_command_foreground(command)
 
-        if process.returncode != 0:
-            error = stderr.decode("utf-8", errors="replace").strip()
-            raise RuntimeError(f"Docker compose up failed (exit {process.returncode}): {error}")
+        if exit_code != 0:
+            raise RuntimeError(f"Docker compose up failed (exit {exit_code})")
 
         logging.info(f"Docker compose started: {' '.join(self.config.files) or 'docker-compose.yml'}")
 
     async def _shutdown(self) -> None:
         command = self._build_down_command()
-        process = await asyncio.create_subprocess_exec(
-            *command,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-
-        stdout, stderr = await process.communicate()
+        exit_code = await run_command_foreground(command)
 
-        if process.returncode != 0:
-            error = stderr.decode("utf-8", errors="replace").strip()
-            logging.warning(f"Docker compose down failed (exit {process.returncode}): {error}")
+        if exit_code != 0:
+            logging.warning(f"Docker compose down failed (exit {exit_code})")
         else:
             logging.info(f"Docker compose stopped: {' '.join(self.config.files) or 'docker-compose.yml'}")
 

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/utils/cdp_client.py

@@ -26,8 +26,21 @@ class CdpClient:
         self._reader_task: Optional[asyncio.Task] = None
 
     async def connect(self) -> None:
-        self._websocket, _ = await WebSocketClient(self.ws_url).connect()
-        self._reader_task = asyncio.create_task(self._reader_loop())
+        import time
+
+        deadline = time.monotonic() + self.timeout
+        last_error: Optional[Exception] = None
+
+        while time.monotonic() < deadline:
+            try:
+                self._websocket, _ = await WebSocketClient(self.ws_url).connect()
+                self._reader_task = asyncio.create_task(self._reader_loop())
+                return
+            except (OSError, ConnectionError) as e:
+                last_error = e
+                await asyncio.sleep(1)
+
+        raise ConnectionError(f"Could not connect to {self.ws_url} within {self.timeout}s: {last_error}")
 
     async def close(self) -> None:
         if self._reader_task:
@@ -91,7 +104,7 @@ class CdpClient:
             self._pending.clear()
 
     @classmethod
-    async def from_host_port(
+    async def discover(
         cls,
         host: str,
         port: int,
@@ -99,22 +112,36 @@ class CdpClient:
         timeout: float = 30.0,
     ) -> CdpClient:
         """Discover the debugger URL by querying /json on the HTTP DevTools port."""
-        async with aiohttp.ClientSession() as session:
-            async with session.get(f"http://{host}:{port}/json") as response:
-                targets = await response.json(content_type=None)
+        import time
+
+        deadline = time.monotonic() + timeout
+        last_error: Optional[Exception] = None
+
+        while time.monotonic() < deadline:
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(f"http://{host}:{port}/json") as response:
+                        targets = await response.json(content_type=None)
+                break
+            except (aiohttp.ClientError, OSError) as e:
+                last_error = e
+                await asyncio.sleep(1)
+        else:
+            raise ConnectionError(f"Could not reach CDP at {host}:{port} within {timeout}s: {last_error}")
 
         page_targets = [ t for t in targets if t.get("type") == "page" ]
 
         if not page_targets:
             raise ConnectionError(f"No 'page' target found at {host}:{port}.")
+
         if target_index >= len(page_targets):
             raise IndexError(
                 f"target_index {target_index} is out of range; "
                 f"{len(page_targets)} page target(s) found."
             )
 
-        ws_url = page_targets[target_index]["webSocketDebuggerUrl"]
-        instance = cls(ws_url, timeout=timeout)
+        websocket_url = page_targets[target_index]["webSocketDebuggerUrl"]
+        instance = cls(websocket_url, timeout=timeout)
         await instance.connect()
 
         return instance

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/core/utils/shell.py

@@ -1,32 +1,6 @@
 from typing import Dict, List, Tuple, Optional
 from asyncio.subprocess import Process
-import asyncio, os
-
-async def run_command_streaming(
-    command: List[str],
-    working_dir: Optional[str] = None,
-    env: Dict[str, str] = None
-) -> None:
-    process = await asyncio.create_subprocess_exec(
-        *command,
-        cwd=working_dir or os.getcwd(),
-        env={ **os.environ, **(env or {}) },
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE
-    )
-
-    async def _stream_output(pipe: asyncio.StreamReader) -> None:
-        while True:
-            line = await pipe.readline()
-            if not line:
-                break
-            print(line.decode().rstrip())
-
-    await asyncio.gather(
-        _stream_output(process.stdout),
-        _stream_output(process.stderr),
-        process.wait()
-    )
+import asyncio, os, sys
 
 async def run_command(
     command: List[str],
@@ -50,6 +24,23 @@ async def run_command(
 
     return (stdout, stderr, process.returncode)
 
+async def run_command_foreground(
+    command: List[str],
+    working_dir: Optional[str] = None,
+    env: Dict[str, str] = None
+) -> int:
+    process = await asyncio.create_subprocess_exec(
+        *command,
+        cwd=working_dir or os.getcwd(),
+        env={ **os.environ, **(env or {}) },
+        stdout=sys.stdout,
+        stderr=sys.stderr
+    )
+
+    await process.wait()
+
+    return process.returncode
+
 async def kill_process(process: Process) -> bool:
     if process.returncode is None:
         process.kill()

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/component/impl/graph_store/impl/arangodb.py

@@ -1,11 +1,12 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from mindor.dsl.schema.action import ArangoDBGraphStoreActionConfig
 from .common import CommonGraphStoreComponentConfig, GraphStoreDriver
 
 class ArangoDBGraphStoreComponentConfig(CommonGraphStoreComponentConfig):
     driver: Literal[GraphStoreDriver.ARANGODB]
+    url: Optional[str] = Field(default=None, description="ArangoDB connection URL (e.g., http://localhost:8529).")
     host: str = Field(default="localhost", description="ArangoDB server hostname or IP address.")
     port: int = Field(default=8529, ge=1, le=65535, description="ArangoDB server port number.")
     protocol: Literal["http", "https"] = Field(default="http", description="Connection protocol.")
@@ -14,3 +15,9 @@ class ArangoDBGraphStoreComponentConfig(CommonGraphStoreComponentConfig):
     database: str = Field(default="_system", description="Target database name.")
     timeout: str = Field(default="30s", description="Client operation timeout.")
     actions: List[ArangoDBGraphStoreActionConfig] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def validate_url_or_host(cls, values: Dict[str, Any]):
+        if values.get("url") and values.get("host"):
+            raise ValueError("Either 'url' or 'host' should be set, but not both")
+        return values

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/component/impl/graph_store/impl/neo4j.py

@@ -1,14 +1,23 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from enum import Enum
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from mindor.dsl.schema.action import Neo4jGraphStoreActionConfig
 from .common import CommonGraphStoreComponentConfig, GraphStoreDriver
 
 class Neo4jGraphStoreComponentConfig(CommonGraphStoreComponentConfig):
     driver: Literal[GraphStoreDriver.NEO4J]
-    uri: str = Field(default="bolt://localhost:7687", description="Neo4j connection URI (bolt:// or neo4j://).")
+    url: Optional[str] = Field(default=None, description="Neo4j connection URL (bolt:// or neo4j://).")
+    host: str = Field(default="localhost", description="Neo4j server hostname or IP address.")
+    port: int = Field(default=7687, ge=1, le=65535, description="Neo4j server port number.")
+    protocol: Literal["bolt", "neo4j", "bolt+s", "neo4j+s", "bolt+ssc", "neo4j+ssc"] = Field(default="bolt", description="Neo4j connection protocol.")
     username: Optional[str] = Field(default=None, description="Username for authentication.")
     password: Optional[str] = Field(default=None, description="Password for authentication.")
     database: Optional[str] = Field(default=None, description="Target database name. Uses default database if not specified.")
     timeout: str = Field(default="30s", description="Client operation timeout.")
     actions: List[Neo4jGraphStoreActionConfig] = Field(default_factory=list)
+
+    @model_validator(mode="before")
+    def validate_url_or_host(cls, values: Dict[str, Any]):
+        if values.get("url") and values.get("host"):
+            raise ValueError("Either 'url' or 'host' should be set, but not both")
+        return values

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/component/impl/web_browser/impl/common.py

@@ -10,5 +10,4 @@ class WebBrowserDriver(str, Enum):
 class CommonWebBrowserComponentConfig(CommonComponentConfig):
     type: Literal[ComponentType.WEB_BROWSER]
     driver: WebBrowserDriver = Field(default=WebBrowserDriver.CHROME, description="Browser driver.")
-    novnc_url: Optional[str] = Field(default=None, description="URL of the noVNC viewer for this browser session. Included in interrupt metadata so humans know where to connect.")
     timeout: Optional[str] = Field(default="30s", description="Default command timeout for all actions.")

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/runtime/impl/docker.py

@@ -69,6 +69,7 @@ class DockerRuntimeConfig(CommonRuntimeConfig):
     working_dir: Optional[str] = Field(default=None, description="Working directory inside the container.")
     user: Optional[str] = Field(default=None, description="User to run the container as.")
     # Resource limits
+    shm_size: Optional[str] = Field(default=None, description="Shared memory size (e.g. '2gb').")
     mem_limit: Optional[str] = Field(default=None, description="Memory limit.")
     memswap_limit: Optional[str] = Field(default=None, description="Total memory + swap limit.")
     cpus: Optional[Union[str, float]] = Field(default=None, description="CPU quota.")

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/system/impl/__init__.py

@@ -1,2 +1,3 @@
 from .common import *
 from .docker_compose import *
+from .docker import *

model_compose-0.4.52/src/mindor/dsl/schema/system/impl/docker.py

@@ -0,0 +1,51 @@
+from typing import Union, Literal, Optional, Dict, List, Any
+from pydantic import Field
+from .common import CommonSystemConfig
+from .types import SystemType
+from mindor.dsl.schema.runtime.impl.docker import (
+    DockerBuildConfig,
+    DockerPortConfig,
+    DockerVolumeConfig,
+    DockerHealthCheck,
+)
+
+class DockerSystemConfig(CommonSystemConfig):
+    type: Literal[SystemType.DOCKER] = Field(default=SystemType.DOCKER, description="Docker system type.")
+    # Image or build
+    image: Optional[str] = Field(default=None, description="Docker image name with optional tag.")
+    build: Optional[DockerBuildConfig] = Field(default=None, description="Build configuration for building image locally.")
+    # Container identity
+    container_name: Optional[str] = Field(default=None, description="Name of the container.")
+    hostname: Optional[str] = Field(default=None, description="Hostname inside the container.")
+    # Networking
+    ports: Optional[List[Union[str, int, DockerPortConfig]]] = Field(default=None, description="Port mappings.")
+    networks: Optional[List[str]] = Field(default_factory=list, description="Networks to attach the container to.")
+    extra_hosts: Optional[Dict[str, str]] = Field(default=None, description="Extra hosts to add to /etc/hosts.")
+    # Volumes
+    volumes: Optional[List[Union[str, DockerVolumeConfig]]] = Field(default=None, description="Volume mounts.")
+    # GPU
+    gpus: Optional[Union[str, int]] = Field(default=None, description="GPU devices to expose. Use 'all' for all GPUs or a count (e.g. 1).")
+    # Environment variables
+    environment: Optional[Dict[str, Union[str, int, float, bool]]] = Field(default=None, description="Environment variables.")
+    env_file: Optional[Union[str, List[str]]] = Field(default=None, description="Environment files.")
+    # Command overrides
+    command: Optional[Union[str, List[str]]] = Field(default=None, description="Override the default command.")
+    entrypoint: Optional[Union[str, List[str]]] = Field(default=None, description="Override the entrypoint.")
+    working_dir: Optional[str] = Field(default=None, description="Working directory inside the container.")
+    user: Optional[str] = Field(default=None, description="User to run the container as.")
+    # Resource limits
+    shm_size: Optional[str] = Field(default=None, description="Shared memory size (e.g. '2gb').")
+    mem_limit: Optional[str] = Field(default=None, description="Memory limit.")
+    memswap_limit: Optional[str] = Field(default=None, description="Total memory + swap limit.")
+    cpus: Optional[Union[str, float]] = Field(default=None, description="CPU quota.")
+    cpu_shares: Optional[int] = Field(default=None, description="Relative CPU weight.")
+    # Restart policy and health checks
+    restart: str = Field(default="no", description="Restart policy.")
+    healthcheck: Optional[DockerHealthCheck] = Field(default=None, description="Health check configuration.")
+    # Miscellaneous
+    labels: Optional[Dict[str, str]] = Field(default=None, description="Container labels.")
+    privileged: Optional[bool] = Field(default=None, description="Run container in privileged mode.")
+    security_opt: Optional[List[str]] = Field(default=None, description="Security options.")
+    # System-specific
+    wait: bool = Field(default=True, description="Whether to wait for the container to be ready before proceeding.")
+    wait_timeout: Optional[str] = Field(default="60s", description="Timeout for waiting for container to be ready.")

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/system/impl/types.py

@@ -2,3 +2,4 @@ from enum import Enum
 
 class SystemType(str, Enum):
     DOCKER_COMPOSE = "docker-compose"
+    DOCKER         = "docker"

{model_compose-0.4.50 → model_compose-0.4.52}/src/mindor/dsl/schema/system/system.py

@@ -5,6 +5,7 @@ from .impl import *
 SystemConfig = Annotated[
     Union[
         DockerComposeSystemConfig,
+        DockerSystemConfig,
     ],
     Field(discriminator="type")
 ]

{model_compose-0.4.50 → model_compose-0.4.52}/src/model_compose.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.50
+Version: 0.4.52
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.50 → model_compose-0.4.52}/src/model_compose.egg-info/SOURCES.txt

@@ -215,6 +215,7 @@ src/mindor/core/system/__init__.py
 src/mindor/core/system/base.py
 src/mindor/core/system/system.py
 src/mindor/core/system/services/__init__.py
+src/mindor/core/system/services/docker.py
 src/mindor/core/system/services/docker_compose.py
 src/mindor/core/utils/__init__.py
 src/mindor/core/utils/active_counter.py
@@ -519,6 +520,7 @@ src/mindor/dsl/schema/system/__init__.py
 src/mindor/dsl/schema/system/system.py
 src/mindor/dsl/schema/system/impl/__init__.py
 src/mindor/dsl/schema/system/impl/common.py
+src/mindor/dsl/schema/system/impl/docker.py
 src/mindor/dsl/schema/system/impl/docker_compose.py
 src/mindor/dsl/schema/system/impl/types.py
 src/mindor/dsl/schema/transport/__init__.py