htmlgen-mcp 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

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/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/config.py

@@ -25,14 +25,14 @@ class ProjectConfig:
         """获取默认的项目输出目录（跨平台）
         
         优先级：
-        1. 环境变量 WEB_AGENT_OUTPUT_DIR
+        1. 环境变量 WEB_AGENT_OUTPUT_DIR / WEB_AGENT_PROJECT_ROOT
         2. 系统特定的文档目录
         3. 用户主目录下的隐藏目录
         4. 系统临时目录
         """
         
         # 1. 检查环境变量（所有平台通用）
-        env_dir = os.environ.get('WEB_AGENT_OUTPUT_DIR')
+        env_dir = os.environ.get('WEB_AGENT_OUTPUT_DIR') or os.environ.get('WEB_AGENT_PROJECT_ROOT')
         if env_dir:
             output_dir = Path(env_dir)
             try:
@@ -111,7 +111,7 @@ class ProjectConfig:
         try:
             temp_dir.mkdir(parents=True, exist_ok=True)
             print(f"⚠️ 使用临时目录: {temp_dir}")
-            print(f"💡 建议设置环境变量 WEB_AGENT_OUTPUT_DIR 到更合适的位置")
+            print(f"💡 建议设置环境变量 WEB_AGENT_OUTPUT_DIR 或 WEB_AGENT_PROJECT_ROOT 到更合适的位置")
             return temp_dir
         except Exception as e:
             # 如果连临时目录都无法创建，使用当前工作目录
@@ -280,7 +280,7 @@ def get_project_directory(project_name: str = None) -> str:
     project_dir = config.create_project_directory(project_name, use_timestamp=True)
     
     print(f"📁 项目将生成在: {project_dir}")
-    print(f"💡 提示: 可通过设置环境变量 WEB_AGENT_OUTPUT_DIR 来自定义输出目录")
+    print(f"💡 提示: 可通过设置环境变量 WEB_AGENT_OUTPUT_DIR 或 WEB_AGENT_PROJECT_ROOT 来自定义输出目录")
     
     return str(project_dir)
 
@@ -323,4 +323,4 @@ __all__ = [
     'get_project_directory',
     'list_recent_projects', 
     'clean_temp_projects'
-]
+]

htmlgen_mcp/web_agent_server.py

@@ -42,13 +42,34 @@ DEFAULT_BASE_URL = os.environ.get(
 
 mcp = FastMCP("smart-web-agent")
 
-# MCP 服务持久化目录：默认为 ~/.mcp/make_web，可通过环境变量覆盖
+# MCP 服务持久化目录：优先使用项目根目录下的 .mcp_state，可通过环境变量覆盖
 DEFAULT_MCP_STORAGE = Path.home() / ".mcp"
 MCP_SERVICE_NAME = os.environ.get("MCP_SERVICE_NAME", "make_web")
-MCP_DATA_ROOT = Path(
-    os.environ.get("MCP_DATA_DIR", DEFAULT_MCP_STORAGE / MCP_SERVICE_NAME)
-)
-MCP_DATA_ROOT.mkdir(parents=True, exist_ok=True)
+
+
+def _resolve_mcp_data_root() -> Path:
+    """解析 MCP 数据目录，优先使用共享项目目录"""
+    env_dir = os.environ.get("MCP_DATA_DIR")
+    if env_dir:
+        path = Path(env_dir)
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    shared_dir = Path(DEFAULT_PROJECT_ROOT) / ".mcp_state"
+    try:
+        shared_dir.mkdir(parents=True, exist_ok=True)
+        return shared_dir
+    except Exception:
+        fallback = DEFAULT_MCP_STORAGE / MCP_SERVICE_NAME
+        fallback.mkdir(parents=True, exist_ok=True)
+        print(
+            f"⚠️ 无法在 {shared_dir} 创建 MCP 数据目录，改用 {fallback}",
+            file=sys.stderr,
+        )
+        return fallback
+
+
+MCP_DATA_ROOT = _resolve_mcp_data_root()
 
 # 简单的缓存：记录最近一次生成的计划，避免“create_simple_site → execute_plan”时需手动传递
 PLAN_CACHE_DIR = MCP_DATA_ROOT / "plan_cache"

{htmlgen_mcp-0.3.1.dist-info → htmlgen_mcp-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: htmlgen-mcp
-Version: 0.3.1
+Version: 0.3.2
 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.dist-info → htmlgen_mcp-0.3.2.dist-info}/RECORD

@@ -1,9 +1,11 @@
 htmlgen_mcp/__init__.py,sha256=8jambwGFxu8RNWes1BUEGDHErV-LcvDaABWqNja9GW0,114
-htmlgen_mcp/config.py,sha256=Xd9naNKP1LfgOfOSXf2QbzKfrmByWvYsNP1OumDH25E,11249
+htmlgen_mcp/config.py,sha256=TXDAvNFmeCI4RIznrBhZhhvWLgXAw6MO6j83prJxFsE,11373
 htmlgen_mcp/sse_optimizations.py,sha256=_UTpgLtxgNAiiEkO5lPihOi1-eEQk6R4ejNParufrrc,6932
-htmlgen_mcp/web_agent_server.py,sha256=69Ht2qoQZ8uFIoov6md4MoJdQWm4cuWOZllBu_FFCJc,47463
+htmlgen_mcp/web_agent_server.py,sha256=UfjO3DtiHekr61nJ0z-Ne9cMXTqzjRLuIfIr85wBhIY,48091
 htmlgen_mcp/agents/__init__.py,sha256=Xydfjzw9s9O6I5Ixx6EmsTdXu26136NDPUAqt9B1hzE,121
 htmlgen_mcp/agents/ai_content_generator.py,sha256=tWGC9cY6Wp7MB1P9J7uCv8LUdiS02rgS6vxaNHD7KQk,10311
+htmlgen_mcp/agents/cluster_state.py,sha256=eDAqVm_A94_x7YfmhKKQ6T1FFt_4XQOyUiHdiTPF7Qg,14615
+htmlgen_mcp/agents/cluster_storage.py,sha256=TJTl_uk4mBHf6nZ1Es0LzPzXfneUITVW-JXTP0gZSdE,11534
 htmlgen_mcp/agents/quick_generator.py,sha256=U16MOazMdBBz0MjtfsFuc-dTLFHpPbXzGG0Yuy5ljwE,9561
 htmlgen_mcp/agents/smart_web_agent.py,sha256=gIlHqE2Zvf8IwXQCBVSzteYN0u7C6e3n5D7jCDlbR-8,99054
 htmlgen_mcp/agents/web_tools/__init__.py,sha256=2Km6T6tMkjMFKoEWkrsSuLUyr_yfHq78_V_oreqQOMc,2472
@@ -24,8 +26,8 @@ htmlgen_mcp/agents/web_tools/simple_css.py,sha256=kj9X3sHHhj1wGwBVL20j6w2qIHXRdx
 htmlgen_mcp/agents/web_tools/simple_js.py,sha256=xMiuF-u-h_IIkUONZIa4Xf8vKB5mcXxwQf5b_BIcpoE,12174
 htmlgen_mcp/agents/web_tools/simple_templates.py,sha256=-Rs-SsWpGZT2hiwa3jZNVDHOMZOo1vV2pWbmBdR30os,6471
 htmlgen_mcp/agents/web_tools/validation.py,sha256=bNA6aWXrCSi7sPqQw5bBR3XF69gRf85D5jSMi996CtI,2069
-htmlgen_mcp-0.3.1.dist-info/METADATA,sha256=EzxJ9NB8ueoSmlSy75Yq_VXtwZtEomeKbRfLy3kCGug,5161
-htmlgen_mcp-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-htmlgen_mcp-0.3.1.dist-info/entry_points.txt,sha256=w7ufTQJobIxT3FYI24yKsCEwEQvBOWhNjckUd9Amu_k,66
-htmlgen_mcp-0.3.1.dist-info/top_level.txt,sha256=KnglzX4ekV8SQkHTsJg2_nTBXz2TxaYLdvoMMovHLNk,12
-htmlgen_mcp-0.3.1.dist-info/RECORD,,
+htmlgen_mcp-0.3.2.dist-info/METADATA,sha256=ZbrJ1I9ijuFaPO0LDrRrVZS1r8d82_qLZ6xM-EP_dN0,5161
+htmlgen_mcp-0.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+htmlgen_mcp-0.3.2.dist-info/entry_points.txt,sha256=w7ufTQJobIxT3FYI24yKsCEwEQvBOWhNjckUd9Amu_k,66
+htmlgen_mcp-0.3.2.dist-info/top_level.txt,sha256=KnglzX4ekV8SQkHTsJg2_nTBXz2TxaYLdvoMMovHLNk,12
+htmlgen_mcp-0.3.2.dist-info/RECORD,,