htmlgen-mcp 0.3.1__tar.gz → 0.3.3__tar.gz

{htmlgen_mcp-0.3.1 → htmlgen_mcp-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgen-mcp
-Version: 0.3.1
+Version: 0.3.3
 Summary: AI-powered HTML website generator with auto-upload functionality via Model Context Protocol
 Author-email: HTML Generator Team <contact@htmlgen-mcp.com>
 License: MIT

{htmlgen_mcp-0.3.1 → htmlgen_mcp-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "htmlgen-mcp"
-version = "0.3.1"
+version = "0.3.3"
 description = "AI-powered HTML website generator with auto-upload functionality via Model Context Protocol"
 readme = "README.md"
 requires-python = ">=3.10"

htmlgen_mcp-0.3.3/src/htmlgen_mcp/agents/cluster_state.py

@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+集群状态管理模块 - 支持分布式部署
+"""
+
+import json
+import time
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+
+class TaskStatus(Enum):
+    """任务状态枚举"""
+    PENDING = "pending"
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class StateManager:
+    """
+    抽象状态管理器基类
+    可以有多种实现：RedisStateManager, PostgreSQLStateManager, MongoDBStateManager
+    """
+    
+    def create_task(self, task_id: str, user_input: str, project_directory: str, metadata: dict = None) -> bool:
+        """创建新任务"""
+        raise NotImplementedError
+    
+    def update_task_status(self, task_id: str, status: TaskStatus, message: str = None) -> bool:
+        """更新任务状态"""
+        raise NotImplementedError
+    
+    def get_task_status(self, task_id: str) -> Optional[dict]:
+        """获取任务状态"""
+        raise NotImplementedError
+    
+    def add_created_file(self, task_id: str, file_path: str, size: int = 0) -> bool:
+        """记录创建的文件"""
+        raise NotImplementedError
+    
+    def get_created_files(self, task_id: str) -> List[str]:
+        """获取任务创建的所有文件"""
+        raise NotImplementedError
+    
+    def add_execution_step(self, task_id: str, step: dict) -> bool:
+        """添加执行步骤记录"""
+        raise NotImplementedError
+    
+    def get_execution_history(self, task_id: str) -> List[dict]:
+        """获取执行历史"""
+        raise NotImplementedError
+    
+    def acquire_lock(self, resource_id: str, timeout: int = 10) -> bool:
+        """获取分布式锁"""
+        raise NotImplementedError
+    
+    def release_lock(self, resource_id: str) -> bool:
+        """释放分布式锁"""
+        raise NotImplementedError
+
+
+class RedisStateManager(StateManager):
+    """基于 Redis 的状态管理器"""
+    
+    def __init__(self, redis_url: str = "redis://localhost:6379/0"):
+        try:
+            import redis
+            from redis.lock import Lock
+        except ImportError:
+            raise ImportError("请安装 redis: pip install redis")
+        
+        self.redis = redis.from_url(redis_url, decode_responses=True)
+        self.Lock = Lock
+        
+    def create_task(self, task_id: str, user_input: str, project_directory: str, metadata: dict = None) -> bool:
+        """创建新任务"""
+        task_data = {
+            "task_id": task_id,
+            "user_input": user_input,
+            "project_directory": project_directory,
+            "status": TaskStatus.PENDING.value,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        
+        # 使用 Hash 存储任务基本信息
+        self.redis.hset(f"task:{task_id}", mapping={
+            k: json.dumps(v) if isinstance(v, (dict, list)) else str(v)
+            for k, v in task_data.items()
+        })
+        
+        # 设置过期时间（7天）
+        self.redis.expire(f"task:{task_id}", 7 * 24 * 3600)
+        
+        return True
+    
+    def update_task_status(self, task_id: str, status: TaskStatus, message: str = None) -> bool:
+        """更新任务状态"""
+        updates = {
+            "status": status.value,
+            "updated_at": datetime.now().isoformat()
+        }
+        if message:
+            updates["message"] = message
+        
+        self.redis.hset(f"task:{task_id}", mapping=updates)
+        return True
+    
+    def get_task_status(self, task_id: str) -> Optional[dict]:
+        """获取任务状态"""
+        data = self.redis.hgetall(f"task:{task_id}")
+        if not data:
+            return None
+        
+        # 反序列化 JSON 字段
+        for key in ["metadata"]:
+            if key in data:
+                try:
+                    data[key] = json.loads(data[key])
+                except (json.JSONDecodeError, TypeError):
+                    pass
+        
+        return data
+    
+    def add_created_file(self, task_id: str, file_path: str, size: int = 0) -> bool:
+        """记录创建的文件"""
+        file_info = {
+            "path": file_path,
+            "size": size,
+            "created_at": datetime.now().isoformat()
+        }
+        
+        # 使用 List 存储文件列表
+        self.redis.rpush(f"task:{task_id}:files", json.dumps(file_info))
+        self.redis.expire(f"task:{task_id}:files", 7 * 24 * 3600)
+        
+        return True
+    
+    def get_created_files(self, task_id: str) -> List[str]:
+        """获取任务创建的所有文件"""
+        files_json = self.redis.lrange(f"task:{task_id}:files", 0, -1)
+        files = []
+        for file_json in files_json:
+            try:
+                file_info = json.loads(file_json)
+                files.append(file_info["path"])
+            except (json.JSONDecodeError, KeyError):
+                continue
+        return files
+    
+    def add_execution_step(self, task_id: str, step: dict) -> bool:
+        """添加执行步骤记录"""
+        step_data = {
+            **step,
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        # 使用 List 存储执行历史
+        self.redis.rpush(f"task:{task_id}:history", json.dumps(step_data))
+        self.redis.expire(f"task:{task_id}:history", 7 * 24 * 3600)
+        
+        return True
+    
+    def get_execution_history(self, task_id: str) -> List[dict]:
+        """获取执行历史"""
+        history_json = self.redis.lrange(f"task:{task_id}:history", 0, -1)
+        history = []
+        for step_json in history_json:
+            try:
+                history.append(json.loads(step_json))
+            except json.JSONDecodeError:
+                continue
+        return history
+    
+    def acquire_lock(self, resource_id: str, timeout: int = 10) -> bool:
+        """获取分布式锁"""
+        lock = self.redis.lock(f"lock:{resource_id}", timeout=timeout)
+        return lock.acquire(blocking=True, blocking_timeout=timeout)
+    
+    def release_lock(self, resource_id: str) -> bool:
+        """释放分布式锁"""
+        try:
+            lock = self.redis.lock(f"lock:{resource_id}")
+            lock.release()
+            return True
+        except Exception:
+            return False
+
+
+class DatabaseStateManager(StateManager):
+    """基于 PostgreSQL/MySQL 的状态管理器"""
+    
+    def __init__(self, db_url: str):
+        try:
+            from sqlalchemy import create_engine, Column, String, Integer, Text, DateTime, JSON
+            from sqlalchemy.ext.declarative import declarative_base
+            from sqlalchemy.orm import sessionmaker
+        except ImportError:
+            raise ImportError("请安装 sqlalchemy: pip install sqlalchemy psycopg2-binary")
+        
+        self.engine = create_engine(db_url)
+        Base = declarative_base()
+        
+        # 定义数据模型
+        class Task(Base):
+            __tablename__ = 'agent_tasks'
+            
+            task_id = Column(String(64), primary_key=True)
+            user_input = Column(Text)
+            project_directory = Column(String(512))
+            status = Column(String(20))
+            message = Column(Text, nullable=True)
+            metadata = Column(JSON, nullable=True)
+            created_at = Column(DateTime, default=datetime.now)
+            updated_at = Column(DateTime, default=datetime.now, onupdate=datetime.now)
+        
+        class CreatedFile(Base):
+            __tablename__ = 'agent_files'
+            
+            id = Column(Integer, primary_key=True, autoincrement=True)
+            task_id = Column(String(64), index=True)
+            file_path = Column(String(1024))
+            size = Column(Integer, default=0)
+            created_at = Column(DateTime, default=datetime.now)
+        
+        class ExecutionStep(Base):
+            __tablename__ = 'agent_execution_history'
+            
+            id = Column(Integer, primary_key=True, autoincrement=True)
+            task_id = Column(String(64), index=True)
+            step = Column(Integer)
+            tool = Column(String(100))
+            status = Column(String(20))
+            result = Column(Text)
+            duration = Column(Integer, default=0)
+            created_at = Column(DateTime, default=datetime.now)
+        
+        Base.metadata.create_all(self.engine)
+        
+        self.Session = sessionmaker(bind=self.engine)
+        self.Task = Task
+        self.CreatedFile = CreatedFile
+        self.ExecutionStep = ExecutionStep
+    
+    def create_task(self, task_id: str, user_input: str, project_directory: str, metadata: dict = None) -> bool:
+        """创建新任务"""
+        session = self.Session()
+        try:
+            task = self.Task(
+                task_id=task_id,
+                user_input=user_input,
+                project_directory=project_directory,
+                status=TaskStatus.PENDING.value,
+                metadata=metadata
+            )
+            session.add(task)
+            session.commit()
+            return True
+        except Exception as e:
+            session.rollback()
+            print(f"创建任务失败: {e}")
+            return False
+        finally:
+            session.close()
+    
+    def update_task_status(self, task_id: str, status: TaskStatus, message: str = None) -> bool:
+        """更新任务状态"""
+        session = self.Session()
+        try:
+            task = session.query(self.Task).filter_by(task_id=task_id).first()
+            if task:
+                task.status = status.value
+                task.updated_at = datetime.now()
+                if message:
+                    task.message = message
+                session.commit()
+                return True
+            return False
+        except Exception as e:
+            session.rollback()
+            print(f"更新任务状态失败: {e}")
+            return False
+        finally:
+            session.close()
+    
+    def get_task_status(self, task_id: str) -> Optional[dict]:
+        """获取任务状态"""
+        session = self.Session()
+        try:
+            task = session.query(self.Task).filter_by(task_id=task_id).first()
+            if not task:
+                return None
+            
+            return {
+                "task_id": task.task_id,
+                "user_input": task.user_input,
+                "project_directory": task.project_directory,
+                "status": task.status,
+                "message": task.message,
+                "metadata": task.metadata,
+                "created_at": task.created_at.isoformat() if task.created_at else None,
+                "updated_at": task.updated_at.isoformat() if task.updated_at else None
+            }
+        finally:
+            session.close()
+    
+    def add_created_file(self, task_id: str, file_path: str, size: int = 0) -> bool:
+        """记录创建的文件"""
+        session = self.Session()
+        try:
+            file_record = self.CreatedFile(
+                task_id=task_id,
+                file_path=file_path,
+                size=size
+            )
+            session.add(file_record)
+            session.commit()
+            return True
+        except Exception as e:
+            session.rollback()
+            print(f"记录文件失败: {e}")
+            return False
+        finally:
+            session.close()
+    
+    def get_created_files(self, task_id: str) -> List[str]:
+        """获取任务创建的所有文件"""
+        session = self.Session()
+        try:
+            files = session.query(self.CreatedFile).filter_by(task_id=task_id).all()
+            return [f.file_path for f in files]
+        finally:
+            session.close()
+    
+    def add_execution_step(self, task_id: str, step: dict) -> bool:
+        """添加执行步骤记录"""
+        session = self.Session()
+        try:
+            step_record = self.ExecutionStep(
+                task_id=task_id,
+                step=step.get("step", 0),
+                tool=step.get("tool", ""),
+                status=step.get("status", ""),
+                result=json.dumps(step.get("result", "")),
+                duration=step.get("duration", 0)
+            )
+            session.add(step_record)
+            session.commit()
+            return True
+        except Exception as e:
+            session.rollback()
+            print(f"记录执行步骤失败: {e}")
+            return False
+        finally:
+            session.close()
+    
+    def get_execution_history(self, task_id: str) -> List[dict]:
+        """获取执行历史"""
+        session = self.Session()
+        try:
+            steps = session.query(self.ExecutionStep).filter_by(task_id=task_id).order_by(self.ExecutionStep.step).all()
+            return [
+                {
+                    "step": s.step,
+                    "tool": s.tool,
+                    "status": s.status,
+                    "result": s.result,
+                    "duration": s.duration,
+                    "created_at": s.created_at.isoformat() if s.created_at else None
+                }
+                for s in steps
+            ]
+        finally:
+            session.close()
+    
+    def acquire_lock(self, resource_id: str, timeout: int = 10) -> bool:
+        """获取分布式锁（需要配合数据库锁实现）"""
+        # PostgreSQL 可以使用 advisory lock
+        # MySQL 可以使用 GET_LOCK
+        # 这里简化实现，实际应使用数据库特定的锁机制
+        return True
+    
+    def release_lock(self, resource_id: str) -> bool:
+        """释放分布式锁"""
+        return True
+
+
+def create_state_manager(backend: str = "redis", connection_string: str = None) -> StateManager:
+    """
+    工厂函数：根据配置创建状态管理器
+    
+    Args:
+        backend: 后端类型，支持 'redis', 'postgresql', 'mysql'
+        connection_string: 连接字符串
+            - Redis: redis://localhost:6379/0
+            - PostgreSQL: postgresql://user:pass@localhost/dbname
+            - MySQL: mysql://user:pass@localhost/dbname
+    
+    Returns:
+        StateManager 实例
+    """
+    if backend == "redis":
+        return RedisStateManager(connection_string or "redis://localhost:6379/0")
+    elif backend in ["postgresql", "mysql"]:
+        if not connection_string:
+            raise ValueError(f"{backend} 需要提供 connection_string")
+        return DatabaseStateManager(connection_string)
+    else:
+        raise ValueError(f"不支持的后端类型: {backend}")

htmlgen_mcp-0.3.3/src/htmlgen_mcp/agents/cluster_storage.py

@@ -0,0 +1,341 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+集群文件存储模块 - 支持对象存储
+"""
+
+import os
+import mimetypes
+from pathlib import Path
+from typing import Optional, List
+
+
+class StorageBackend:
+    """存储后端抽象基类"""
+    
+    def upload_file(self, local_path: str, remote_path: str) -> str:
+        """
+        上传文件到存储
+        
+        Args:
+            local_path: 本地文件路径
+            remote_path: 远程存储路径
+            
+        Returns:
+            可访问的 URL
+        """
+        raise NotImplementedError
+    
+    def download_file(self, remote_path: str, local_path: str) -> bool:
+        """下载文件到本地"""
+        raise NotImplementedError
+    
+    def delete_file(self, remote_path: str) -> bool:
+        """删除文件"""
+        raise NotImplementedError
+    
+    def list_files(self, prefix: str) -> List[str]:
+        """列出指定前缀的所有文件"""
+        raise NotImplementedError
+    
+    def get_url(self, remote_path: str, expires: int = 3600) -> str:
+        """获取文件访问URL"""
+        raise NotImplementedError
+
+
+class LocalStorageBackend(StorageBackend):
+    """
+    本地文件系统存储（开发/单机环境）
+    适用于开发测试，生产环境请使用对象存储
+    """
+    
+    def __init__(self, base_dir: str = "/tmp/agent_storage"):
+        self.base_dir = Path(base_dir)
+        self.base_dir.mkdir(parents=True, exist_ok=True)
+    
+    def upload_file(self, local_path: str, remote_path: str) -> str:
+        """复制文件到存储目录"""
+        target_path = self.base_dir / remote_path
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        import shutil
+        shutil.copy2(local_path, target_path)
+        
+        return f"file://{target_path}"
+    
+    def download_file(self, remote_path: str, local_path: str) -> bool:
+        """从存储目录复制文件"""
+        source_path = self.base_dir / remote_path
+        if not source_path.exists():
+            return False
+        
+        import shutil
+        Path(local_path).parent.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(source_path, local_path)
+        return True
+    
+    def delete_file(self, remote_path: str) -> bool:
+        """删除文件"""
+        target_path = self.base_dir / remote_path
+        if target_path.exists():
+            target_path.unlink()
+            return True
+        return False
+    
+    def list_files(self, prefix: str) -> List[str]:
+        """列出文件"""
+        prefix_path = self.base_dir / prefix
+        if not prefix_path.exists():
+            return []
+        
+        files = []
+        for file_path in prefix_path.rglob("*"):
+            if file_path.is_file():
+                rel_path = file_path.relative_to(self.base_dir)
+                files.append(str(rel_path))
+        return files
+    
+    def get_url(self, remote_path: str, expires: int = 3600) -> str:
+        """获取文件URL"""
+        target_path = self.base_dir / remote_path
+        return f"file://{target_path}"
+
+
+class OSSStorageBackend(StorageBackend):
+    """阿里云 OSS 存储"""
+    
+    def __init__(self, access_key: str, secret_key: str, endpoint: str, bucket: str):
+        try:
+            import oss2
+        except ImportError:
+            raise ImportError("请安装 oss2: pip install oss2")
+        
+        auth = oss2.Auth(access_key, secret_key)
+        self.bucket = oss2.Bucket(auth, endpoint, bucket)
+        self.bucket_name = bucket
+        self.endpoint = endpoint
+    
+    def upload_file(self, local_path: str, remote_path: str) -> str:
+        """上传文件到 OSS"""
+        # 自动检测 Content-Type
+        content_type, _ = mimetypes.guess_type(local_path)
+        
+        headers = {}
+        if content_type:
+            headers['Content-Type'] = content_type
+        
+        self.bucket.put_object_from_file(remote_path, local_path, headers=headers)
+        
+        return f"https://{self.bucket_name}.{self.endpoint}/{remote_path}"
+    
+    def download_file(self, remote_path: str, local_path: str) -> bool:
+        """从 OSS 下载文件"""
+        try:
+            Path(local_path).parent.mkdir(parents=True, exist_ok=True)
+            self.bucket.get_object_to_file(remote_path, local_path)
+            return True
+        except Exception:
+            return False
+    
+    def delete_file(self, remote_path: str) -> bool:
+        """删除 OSS 文件"""
+        try:
+            self.bucket.delete_object(remote_path)
+            return True
+        except Exception:
+            return False
+    
+    def list_files(self, prefix: str) -> List[str]:
+        """列出 OSS 文件"""
+        files = []
+        for obj in oss2.ObjectIterator(self.bucket, prefix=prefix):
+            files.append(obj.key)
+        return files
+    
+    def get_url(self, remote_path: str, expires: int = 3600) -> str:
+        """获取 OSS 签名 URL"""
+        return self.bucket.sign_url('GET', remote_path, expires)
+
+
+class S3StorageBackend(StorageBackend):
+    """AWS S3 / MinIO 存储"""
+    
+    def __init__(self, access_key: str, secret_key: str, endpoint: str, bucket: str, region: str = "us-east-1"):
+        try:
+            import boto3
+        except ImportError:
+            raise ImportError("请安装 boto3: pip install boto3")
+        
+        self.s3_client = boto3.client(
+            's3',
+            aws_access_key_id=access_key,
+            aws_secret_access_key=secret_key,
+            endpoint_url=endpoint if endpoint else None,
+            region_name=region
+        )
+        self.bucket = bucket
+        self.endpoint = endpoint
+    
+    def upload_file(self, local_path: str, remote_path: str) -> str:
+        """上传文件到 S3"""
+        content_type, _ = mimetypes.guess_type(local_path)
+        
+        extra_args = {}
+        if content_type:
+            extra_args['ContentType'] = content_type
+        
+        self.s3_client.upload_file(local_path, self.bucket, remote_path, ExtraArgs=extra_args)
+        
+        if self.endpoint:
+            return f"{self.endpoint}/{self.bucket}/{remote_path}"
+        return f"https://{self.bucket}.s3.amazonaws.com/{remote_path}"
+    
+    def download_file(self, remote_path: str, local_path: str) -> bool:
+        """从 S3 下载文件"""
+        try:
+            Path(local_path).parent.mkdir(parents=True, exist_ok=True)
+            self.s3_client.download_file(self.bucket, remote_path, local_path)
+            return True
+        except Exception:
+            return False
+    
+    def delete_file(self, remote_path: str) -> bool:
+        """删除 S3 文件"""
+        try:
+            self.s3_client.delete_object(Bucket=self.bucket, Key=remote_path)
+            return True
+        except Exception:
+            return False
+    
+    def list_files(self, prefix: str) -> List[str]:
+        """列出 S3 文件"""
+        files = []
+        paginator = self.s3_client.get_paginator('list_objects_v2')
+        for page in paginator.paginate(Bucket=self.bucket, Prefix=prefix):
+            if 'Contents' in page:
+                for obj in page['Contents']:
+                    files.append(obj['Key'])
+        return files
+    
+    def get_url(self, remote_path: str, expires: int = 3600) -> str:
+        """获取 S3 签名 URL"""
+        return self.s3_client.generate_presigned_url(
+            'get_object',
+            Params={'Bucket': self.bucket, 'Key': remote_path},
+            ExpiresIn=expires
+        )
+
+
+class COSStorageBackend(StorageBackend):
+    """腾讯云 COS 存储"""
+    
+    def __init__(self, secret_id: str, secret_key: str, region: str, bucket: str):
+        try:
+            from qcloud_cos import CosConfig, CosS3Client
+        except ImportError:
+            raise ImportError("请安装 cos-python-sdk-v5: pip install cos-python-sdk-v5")
+        
+        config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key)
+        self.client = CosS3Client(config)
+        self.bucket = bucket
+        self.region = region
+    
+    def upload_file(self, local_path: str, remote_path: str) -> str:
+        """上传文件到 COS"""
+        content_type, _ = mimetypes.guess_type(local_path)
+        
+        with open(local_path, 'rb') as f:
+            self.client.put_object(
+                Bucket=self.bucket,
+                Body=f,
+                Key=remote_path,
+                ContentType=content_type or 'application/octet-stream'
+            )
+        
+        return f"https://{self.bucket}.cos.{self.region}.myqcloud.com/{remote_path}"
+    
+    def download_file(self, remote_path: str, local_path: str) -> bool:
+        """从 COS 下载文件"""
+        try:
+            Path(local_path).parent.mkdir(parents=True, exist_ok=True)
+            response = self.client.get_object(Bucket=self.bucket, Key=remote_path)
+            response['Body'].get_stream_to_file(local_path)
+            return True
+        except Exception:
+            return False
+    
+    def delete_file(self, remote_path: str) -> bool:
+        """删除 COS 文件"""
+        try:
+            self.client.delete_object(Bucket=self.bucket, Key=remote_path)
+            return True
+        except Exception:
+            return False
+    
+    def list_files(self, prefix: str) -> List[str]:
+        """列出 COS 文件"""
+        files = []
+        marker = ""
+        while True:
+            response = self.client.list_objects(Bucket=self.bucket, Prefix=prefix, Marker=marker)
+            if 'Contents' in response:
+                for obj in response['Contents']:
+                    files.append(obj['Key'])
+            if response['IsTruncated'] == 'false':
+                break
+            marker = response['NextMarker']
+        return files
+    
+    def get_url(self, remote_path: str, expires: int = 3600) -> str:
+        """获取 COS 签名 URL"""
+        return self.client.get_presigned_download_url(
+            Bucket=self.bucket,
+            Key=remote_path,
+            Expired=expires
+        )
+
+
+def create_storage_backend(
+    backend_type: str = "local",
+    **kwargs
+) -> StorageBackend:
+    """
+    工厂函数：创建存储后端
+    
+    Args:
+        backend_type: 后端类型 'local', 'oss', 's3', 'cos'
+        **kwargs: 各后端的配置参数
+            - local: base_dir
+            - oss: access_key, secret_key, endpoint, bucket
+            - s3: access_key, secret_key, endpoint, bucket, region
+            - cos: secret_id, secret_key, region, bucket
+    
+    Returns:
+        StorageBackend 实例
+    """
+    if backend_type == "local":
+        return LocalStorageBackend(kwargs.get("base_dir", "/tmp/agent_storage"))
+    elif backend_type == "oss":
+        return OSSStorageBackend(
+            access_key=kwargs["access_key"],
+            secret_key=kwargs["secret_key"],
+            endpoint=kwargs["endpoint"],
+            bucket=kwargs["bucket"]
+        )
+    elif backend_type == "s3":
+        return S3StorageBackend(
+            access_key=kwargs["access_key"],
+            secret_key=kwargs["secret_key"],
+            endpoint=kwargs.get("endpoint"),
+            bucket=kwargs["bucket"],
+            region=kwargs.get("region", "us-east-1")
+        )
+    elif backend_type == "cos":
+        return COSStorageBackend(
+            secret_id=kwargs["secret_id"],
+            secret_key=kwargs["secret_key"],
+            region=kwargs["region"],
+            bucket=kwargs["bucket"]
+        )
+    else:
+        raise ValueError(f"不支持的存储后端: {backend_type}")

{htmlgen_mcp-0.3.1 → htmlgen_mcp-0.3.3}/src/htmlgen_mcp/config.py

@@ -1,4 +1,4 @@
-"""项目配置管理 - 跨平台支持"""
+"""项目配置管理 - 跨平台支持与集群部署优化"""
 import os
 import sys
 import platform
@@ -8,7 +8,7 @@ from datetime import datetime
 
 
 class ProjectConfig:
-    """项目配置管理器 - 支持 Windows/macOS/Linux"""
+    """项目配置管理器 - 支持 Windows/macOS/Linux/集群部署"""
     
     @staticmethod
     def get_system_info() -> dict:
@@ -22,16 +22,37 @@ class ProjectConfig:
     
     @staticmethod
     def get_default_output_dir() -> Path:
-        """获取默认的项目输出目录（跨平台）
+        """获取默认的项目输出目录（跨平台 + 集群部署）
         
-        优先级：
-        1. 环境变量 WEB_AGENT_OUTPUT_DIR
-        2. 系统特定的文档目录
-        3. 用户主目录下的隐藏目录
-        4. 系统临时目录
+        优先级（集群部署优化）：
+        1. 环境变量 WEB_AGENT_PROJECT_ROOT（集群共享存储，最高优先级）
+        2. 环境变量 WEB_AGENT_OUTPUT_DIR（兼容旧配置）
+        3. 系统特定的文档目录
+        4. 用户主目录下的隐藏目录
+        5. 系统临时目录
+        
+        集群部署说明：
+        - 在 SSE 集群中，建议配置 WEB_AGENT_PROJECT_ROOT 为 NAS 共享路径
+        - 示例：WEB_AGENT_PROJECT_ROOT=/app/mcp-servers/mcp-servers/html_agent/projects
         """
         
-        # 1. 检查环境变量（所有平台通用）
+        # 1a. 检查集群共享存储环境变量（最高优先级）
+        project_root = os.environ.get('WEB_AGENT_PROJECT_ROOT')
+        if project_root:
+            output_dir = Path(project_root)
+            try:
+                output_dir.mkdir(parents=True, exist_ok=True)
+                # 验证目录可写
+                test_file = output_dir / '.write_test'
+                test_file.touch()
+                test_file.unlink()
+                print(f"✅ 使用集群共享存储: {output_dir}")
+                return output_dir
+            except Exception as e:
+                print(f"⚠️ 集群共享存储不可用 ({output_dir}): {e}")
+                print(f"💡 请检查 NAS 挂载状态和权限")
+        
+        # 1b. 检查兼容性环境变量
         env_dir = os.environ.get('WEB_AGENT_OUTPUT_DIR')
         if env_dir:
             output_dir = Path(env_dir)

{htmlgen_mcp-0.3.1 → htmlgen_mcp-0.3.3}/src/htmlgen_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgen-mcp
-Version: 0.3.1
+Version: 0.3.3
 Summary: AI-powered HTML website generator with auto-upload functionality via Model Context Protocol
 Author-email: HTML Generator Team <contact@htmlgen-mcp.com>
 License: MIT

{htmlgen_mcp-0.3.1 → htmlgen_mcp-0.3.3}/src/htmlgen_mcp.egg-info/SOURCES.txt

@@ -12,6 +12,8 @@ src/htmlgen_mcp.egg-info/requires.txt
 src/htmlgen_mcp.egg-info/top_level.txt
 src/htmlgen_mcp/agents/__init__.py
 src/htmlgen_mcp/agents/ai_content_generator.py
+src/htmlgen_mcp/agents/cluster_state.py
+src/htmlgen_mcp/agents/cluster_storage.py
 src/htmlgen_mcp/agents/quick_generator.py
 src/htmlgen_mcp/agents/smart_web_agent.py
 src/htmlgen_mcp/agents/web_tools/__init__.py