jettask 0.2.18__py3-none-any.whl → 0.2.20__py3-none-any.whl

jettask/cli.py

@@ -7,9 +7,8 @@ import sys
 import os
 import importlib
 import importlib.util
-import json
+import multiprocessing
 from pathlib import Path
-from dotenv import load_dotenv
 
 # 处理直接运行时的路径问题
 if __name__ == '__main__':
@@ -18,142 +17,248 @@ if __name__ == '__main__':
         sys.path.insert(0, parent_dir)
 
 from jettask.config.nacos_config import config
+from jettask.config.env_loader import EnvLoader
 from jettask.core.app_importer import import_app, AppImporter
 
 
 @click.group()
 @click.version_option(version='0.1.0', prog_name='JetTask')
-def cli():
-    """JetTask - 高性能分布式任务队列系统"""
-    pass
-
-@cli.command()
-@click.option('--host', default='0.0.0.0', help='服务器监听地址')
-@click.option('--port', default=8001, type=int, help='服务器监听端口')
-@click.option('--jettask-pg-url', envvar='JETTASK_PG_URL', 
-              help='PostgreSQL连接URL')
-@click.option('--use-nacos', is_flag=True, default=False, 
+@click.option('--env-file', '-e', envvar='JETTASK_ENV_FILE',
+              help='环境变量文件路径 (.env 格式)，可通过 JETTASK_ENV_FILE 环境变量指定')
+@click.option('--use-nacos', is_flag=True,
               help='从Nacos配置中心读取配置')
-@click.option('--nacos-server', envvar='NACOS_SERVER', 
-              help='Nacos服务器地址')
-@click.option('--nacos-namespace', envvar='NACOS_NAMESPACE',
+@click.option('--nacos-server',
+              help='Nacos服务器地址 (如: 127.0.0.1:8848)')
+@click.option('--nacos-namespace',
               help='Nacos命名空间')
-@click.option('--nacos-username', envvar='NACOS_USERNAME',
+@click.option('--nacos-username',
               help='Nacos用户名')
-@click.option('--nacos-password', envvar='NACOS_PASSWORD',
+@click.option('--nacos-password',
               help='Nacos密码')
-@click.option('--nacos-group', envvar='NACOS_GROUP',
+@click.option('--nacos-group',
               help='Nacos配置组')
-@click.option('--nacos-data-id', envvar='NACOS_DATA_ID',
-              help='Nacos配置ID')
-@click.option('--reload', is_flag=True, default=False, help='启用自动重载')
-@click.option('--log-level', default='info', 
+@click.option('--nacos-data-id',
+              help='Nacos配置ID（api/webui-consumer/scheduler 需要）')
+@click.pass_context
+def cli(ctx, env_file, use_nacos, nacos_server, nacos_namespace,
+        nacos_username, nacos_password, nacos_group, nacos_data_id):
+    """JetTask - 高性能分布式任务队列系统
+
+    配置加载优先级（从高到低）：
+    1. 命令行参数
+    2. 环境变量
+    3. .env文件
+    4. 默认值
+
+    Nacos 必需参数：
+      --nacos-server     Nacos服务器地址
+      --nacos-namespace  Nacos命名空间
+
+    Nacos 可选参数：
+      --nacos-group      配置组（默认: DEFAULT_GROUP）
+      --nacos-data-id    配置ID（api/webui-consumer/scheduler 需要）
+      --nacos-username   用户名
+      --nacos-password   密码
+
+    说明：
+      • worker 命令不使用全局 Nacos 配置，而是通过 app 读取配置
+      • api/webui-consumer/scheduler 需要 nacos-data-id 来读取应用配置
+
+    示例：
+    \b
+      # 使用.env文件
+      jettask -e .env worker --queues default
+
+      # 使用Nacos（从.env读取配置）
+      jettask --use-nacos worker --queues default
+
+      # 使用Nacos（命令行指定最小配置）
+      jettask --use-nacos \\
+        --nacos-server 127.0.0.1:8848 \\
+        --nacos-namespace prod \\
+        worker --queues default
+
+      # 混合使用：先加载.env，再从Nacos覆盖
+      jettask -e .env --use-nacos worker --queues default
+    """
+    # 在所有命令执行前加载环境变量
+    ctx.ensure_object(dict)
+
+    # 初始化 context（即使不使用 Nacos 也要设置）
+    ctx.obj['use_nacos'] = use_nacos
+    ctx.obj['nacos_data_id'] = None
+
+    loader = EnvLoader()
+
+    # 如果手动指定了env文件，只加载指定的文件；否则自动搜索加载
+    if env_file:
+        # 手动指定了文件，直接加载，不进行自动搜索
+        try:
+            loader.load_env_file(env_file, override=True)
+            click.echo(f"✓ 已加载环境变量文件: {env_file}")
+        except FileNotFoundError:
+            click.echo(f"Error: 环境变量文件不存在: {env_file}", err=True)
+            raise click.Abort()
+        except Exception as e:
+            click.echo(f"Error: 加载环境变量文件失败: {e}", err=True)
+            raise click.Abort()
+    else:
+        # 未指定文件，自动搜索并加载 .env, .env.{ENV}, .env.local
+        loader.auto_load()
+
+    # 3. 如果启用了Nacos，从Nacos读取配置并更新环境变量
+    if use_nacos:
+        try:
+            # 在加载 .env 之后，再从环境变量读取 Nacos 配置
+            # 优先级: 命令行参数 > .env 文件中的环境变量
+            nacos_server = nacos_server or os.environ.get('NACOS_SERVER')
+            nacos_namespace = nacos_namespace or os.environ.get('NACOS_NAMESPACE')
+            nacos_username = nacos_username or os.environ.get('NACOS_USERNAME')
+            nacos_password = nacos_password or os.environ.get('NACOS_PASSWORD')
+            nacos_group = nacos_group or os.environ.get('NACOS_GROUP', 'DEFAULT_GROUP')
+            nacos_data_id = nacos_data_id or os.environ.get('NACOS_DATA_ID')
+
+            # 更新 Nacos 配置到 context
+            ctx.obj['nacos_data_id'] = nacos_data_id
+
+            # 检查必需的配置是否完整（nacos_data_id 改为可选）
+            if not all([nacos_server, nacos_namespace, nacos_group]):
+                missing = []
+                if not nacos_server: missing.append("--nacos-server 或 NACOS_SERVER")
+                if not nacos_namespace: missing.append("--nacos-namespace 或 NACOS_NAMESPACE")
+                if not nacos_group: missing.append("--nacos-group 或 NACOS_GROUP")
+
+                click.echo("Error: Nacos配置不完整，缺少以下配置:", err=True)
+                for item in missing:
+                    click.echo(f"  - {item}", err=True)
+                raise click.Abort()
+
+            # 将命令行参数或环境变量的Nacos配置写入os.environ
+            # 这样nacos_config模块才能读取到
+            os.environ['NACOS_SERVER'] = nacos_server
+            os.environ['NACOS_NAMESPACE'] = nacos_namespace
+            os.environ['NACOS_GROUP'] = nacos_group
+            if nacos_data_id:
+                os.environ['NACOS_DATA_ID'] = nacos_data_id
+            if nacos_username:
+                os.environ['NACOS_USERNAME'] = nacos_username
+            if nacos_password:
+                os.environ['NACOS_PASSWORD'] = nacos_password
+
+            click.echo(f"正在从Nacos加载配置 ({nacos_server}/{nacos_namespace})...")
+
+            # 加载Nacos配置
+            nacos_pg_url = config.config.get('JETTASK_PG_URL')
+            if not nacos_pg_url:
+                # 如果没有直接的URL，尝试从独立的配置项构建
+                pg_host = config.config.get('PG_DB_HOST', 'localhost')
+                pg_port = config.config.get('PG_DB_PORT', 5432)
+                pg_user = config.config.get('PG_DB_USERNAME', 'jettask')
+                pg_password = config.config.get('PG_DB_PASSWORD', '123456')
+                pg_database = config.config.get('PG_DB_DATABASE', 'jettask')
+                nacos_pg_url = f'postgresql://{pg_user}:{pg_password}@{pg_host}:{pg_port}/{pg_database}'
+
+            # 将Nacos配置写入环境变量（会覆盖.env中的配置）
+            if nacos_pg_url:
+                os.environ['JETTASK_PG_URL'] = nacos_pg_url
+
+            # 将其他Nacos配置也设置到环境变量中
+            for key, value in config.config.items():
+                if isinstance(value, (str, int, float, bool)):
+                    os.environ[key] = str(value)
+
+            click.echo(f"✓ 从Nacos加载配置成功")
+        except click.Abort:
+            raise
+        except Exception as e:
+            click.echo(f"Error: 从Nacos加载配置失败: {e}", err=True)
+            import traceback
+            traceback.print_exc()
+            raise click.Abort()
+
+    # 保存loader到context，供子命令使用
+    ctx.obj['env_loader'] = loader
+    ctx.obj['use_nacos'] = use_nacos
+
+@cli.command()
+@click.option('--host', default='0.0.0.0', envvar='JETTASK_API_HOST', help='服务器监听地址')
+@click.option('--port', default=8001, type=int, envvar='JETTASK_API_PORT', help='服务器监听端口')
+@click.option('--redis-url', envvar='JETTASK_REDIS_URL', help='Redis连接URL')
+@click.option('--redis-prefix', envvar='JETTASK_REDIS_PREFIX', help='Redis键前缀')
+@click.option('--jettask-pg-url', envvar='JETTASK_PG_URL', help='PostgreSQL连接URL')
+@click.option('--reload', is_flag=True, envvar='JETTASK_API_RELOAD', help='启用自动重载')
+@click.option('--log-level', default='info', envvar='JETTASK_LOG_LEVEL',
               type=click.Choice(['debug', 'info', 'warning', 'error']),
               help='日志级别')
-def api(host, port, jettask_pg_url, use_nacos, nacos_server, nacos_namespace, 
-        nacos_username, nacos_password, nacos_group, nacos_data_id, 
-        reload, log_level):
+@click.pass_context
+def api(ctx, host, port, redis_url, redis_prefix, jettask_pg_url, reload, log_level):
     """启动 API 服务和监控界面
-    
+
     示例:
     \b
       # 使用默认配置启动
       jettask api
-      
-      # 指定端口和数据库
-      jettask api --host 0.0.0.0 --port 8080 --jettask-pg-url postgresql://user:pass@host/db
-      
-      # 使用Nacos配置中心
-      jettask api --use-nacos --nacos-server 127.0.0.1:8848
-      
-      # 通过环境变量配置Nacos
-      export NACOS_SERVER=127.0.0.1:8848
-      export NACOS_NAMESPACE=tamar_console_dev
-      jettask api --use-nacos
-      
-      # 通过环境变量配置数据库
-      export JETTASK_PG_URL=postgresql://jettask:123456@localhost:5432/jettask
-      jettask api
-      
+
+      # 指定配置
+      jettask api --host 0.0.0.0 --port 8080 \
+        --redis-url redis://localhost:6379/0 \
+        --redis-prefix my_app \
+        --jettask-pg-url postgresql://user:pass@host/db
+
+      # 使用Nacos配置中心（全局参数）
+      jettask --use-nacos api
+
+      # 通过环境变量配置（.env文件）
+      jettask -e .env api
+
       # 启用开发模式（自动重载）
       jettask api --reload --log-level debug
     """
     import os
     import uvicorn
-    
-    print(f'{use_nacos=} {jettask_pg_url=}')
-    if not use_nacos and not jettask_pg_url:
-        raise ValueError("必须提供 --jettask-pg-url 或启用 --use-nacos")
-    # 如果使用Nacos，从Nacos获取配置
-    if use_nacos:
-        click.echo("正在从Nacos加载配置...")
-        load_dotenv()
-        # 设置Nacos环境变量
-        if nacos_server:
-            os.environ['NACOS_SERVER'] = nacos_server
-        if nacos_namespace:
-            os.environ['NACOS_NAMESPACE'] = nacos_namespace
-        if nacos_username:
-            os.environ['NACOS_USERNAME'] = nacos_username
-        if nacos_password:
-            os.environ['NACOS_PASSWORD'] = nacos_password
-        if nacos_group:
-            os.environ['NACOS_GROUP'] = nacos_group
-        if nacos_data_id:
-            os.environ['NACOS_DATA_ID'] = nacos_data_id
-        
-        nacos_server = os.environ['NACOS_SERVER']
-        nacos_namespace = os.environ['NACOS_NAMESPACE']
-        nacos_username = os.environ['NACOS_USERNAME']
-        nacos_password = os.environ['NACOS_PASSWORD']
-        nacos_group = os.environ['NACOS_GROUP']
-        nacos_data_id = os.environ['NACOS_DATA_ID']
-        # 尝试从配置中获取JETTASK_PG_URL
-        nacos_pg_url = config.config.get('JETTASK_PG_URL')
-        print(f'{nacos_pg_url=}')
-        if not nacos_pg_url:
-            # 如果没有直接的URL，尝试从独立的配置项构建
-            pg_host = config.config.get('PG_DB_HOST', 'localhost')
-            pg_port = config.config.get('PG_DB_PORT', 5432)
-            pg_user = config.config.get('PG_DB_USERNAME', 'jettask')
-            pg_password = config.config.get('PG_DB_PASSWORD', '123456')
-            pg_database = config.config.get('PG_DB_DATABASE', 'jettask')
-            nacos_pg_url = f'postgresql://{pg_user}:{pg_password}@{pg_host}:{pg_port}/{pg_database}'
-        
-        jettask_pg_url = nacos_pg_url
-        click.echo(f"✓ 从Nacos加载配置成功")
-        click.echo(f"  配置源: {nacos_server}/{nacos_namespace}/{nacos_group}/{nacos_data_id}")
-        
-        # 将其他Nacos配置也设置到环境变量中
-        for key, value in config.config.items():
-            if isinstance(value, (str, int, float, bool)):
-                os.environ[key] = str(value)
 
-    
+    # Click的envvar已经自动处理了环境变量读取
+    # 全局的--use-nacos也已经处理了Nacos配置加载
+
+    # 获取use_nacos状态（从全局context）
+    use_nacos = ctx.obj.get('use_nacos', False)
+
+    # 检查必需参数
+    if not jettask_pg_url:
+        raise ValueError(
+            "必须提供 --jettask-pg-url 或在环境变量中设置 JETTASK_PG_URL\n"
+            "或使用 jettask --use-nacos api 从Nacos加载配置"
+        )
+
+    if not redis_url:
+        raise ValueError(
+            "必须提供 --redis-url 或在环境变量中设置 JETTASK_REDIS_URL\n"
+            "或使用 jettask --use-nacos api 从Nacos加载配置"
+        )
+
     # 设置环境变量（供应用内部使用）
+    os.environ['JETTASK_REDIS_URL'] = redis_url
+    if redis_prefix:
+        os.environ['JETTASK_REDIS_PREFIX'] = redis_prefix
     os.environ['JETTASK_PG_URL'] = jettask_pg_url
-    
-    # 设置是否使用Nacos的标志
     os.environ['USE_NACOS'] = 'true' if use_nacos else 'false'
     
     # 使用标准应用模块
-    app_module = "jettask.api:app"
+    app_module = "jettask.webui.app:app"
     click.echo(f"Starting JetTask API Server on {host}:{port}")
     
     # 显示配置信息
     click.echo("=" * 60)
     click.echo("API Server Configuration")
     click.echo("=" * 60)
-    click.echo(f"Host:        {host}")
-    click.echo(f"Port:        {port}")
-    click.echo(f"Auto-reload: {reload}")
-    click.echo(f"Log level:   {log_level}")
-    click.echo(f"Nacos:       {'Enabled' if use_nacos else 'Disabled'}")
-    if use_nacos:
-        click.echo(f"  Server:    {nacos_server}")
-        click.echo(f"  Namespace: {nacos_namespace}")
-        click.echo(f"  Data ID:   {nacos_data_id}")
-    click.echo(f"Database:    {jettask_pg_url}")
+    click.echo(f"Host:         {host}")
+    click.echo(f"Port:         {port}")
+    click.echo(f"Redis URL:    {redis_url}")
+    click.echo(f"Redis Prefix: {redis_prefix or 'jettask (default)'}")
+    click.echo(f"Database:     {jettask_pg_url}")
+    click.echo(f"Auto-reload:  {reload}")
+    click.echo(f"Log level:    {log_level}")
+    click.echo(f"Nacos:        {'Enabled' if use_nacos else 'Disabled'}")
     click.echo("=" * 60)
     click.echo(f"API Endpoint: http://{host}:{port}/api")
     click.echo(f"WebUI:        http://{host}:{port}/")
@@ -215,47 +320,61 @@ def find_jettask_app(module):
     return None
 
 @cli.command()
-@click.argument('app_str', required=False, default=None)
-@click.option('--queues', '-q', help='队列名称（逗号分隔，如: queue1,queue2）')
-@click.option('--executor', '-e', 
-              type=click.Choice(['asyncio', 'multi_asyncio']),
-              default='asyncio',
-              help='执行器类型')
-@click.option('--concurrency', '-c', type=int, default=4, help='并发数')
-@click.option('--prefetch', '-p', type=int, default=100, help='预取倍数')
-@click.option('--reload', '-r', is_flag=True, help='自动重载')
-@click.option('--config', help='配置文件 (JSON格式)')
-def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
+@click.option('--app', '-a', 'app_str', envvar='JETTASK_APP',
+              help='应用位置 (如: module:app, path/to/file.py:app, 或目录名)')
+@click.option('--queues', '-q', envvar='JETTASK_QUEUES', help='队列名称（逗号分隔，如: queue1,queue2）')
+@click.option('--concurrency', '-c', type=int, envvar='JETTASK_CONCURRENCY', help='并发数（默认为CPU核心数的一半）')
+@click.option('--prefetch', '-p', type=int, default=100, envvar='JETTASK_PREFETCH', help='预取倍数')
+@click.option('--reload', '-r', is_flag=True, envvar='JETTASK_RELOAD', help='自动重载')
+@click.pass_context
+def worker(ctx, app_str, queues, concurrency, prefetch, reload):
     """启动任务处理 Worker
-    
+
     示例:
     \b
-      # 显式指定 app
-      jettask worker main:app --queues async_queue
-      jettask worker tasks.py:app --queues queue1,queue2
-      jettask worker myapp.tasks --queues high,normal,low
-      
+      # 使用 -a 或 --app 参数指定 app
+      jettask worker -a main:app --queues async_queue
+      jettask worker --app tasks.py:app --queues queue1,queue2
+      jettask worker -a myapp --queues high,normal,low
+
       # 自动发现 app（从当前目录的 app.py 或 main.py）
       jettask worker --queues async_queue
-      
+
       # 使用环境变量
       export JETTASK_APP=myapp:app
       jettask worker --queues async_queue
+
+      # 加载环境变量文件（全局 -e 参数）
+      jettask -e .env worker --queues async_queue
+      jettask --env-file production.env worker -a main:app --queues high,low
+
+      # 或使用环境变量
+      export JETTASK_ENV_FILE=.env
+      jettask worker --queues async_queue
     """
-    
-    # 如果提供了配置文件，从中加载配置
-    if config:
-        click.echo(f"Loading configuration from {config}")
-        with open(config, 'r') as f:
-            config_data = json.load(f)
-        
-        # 从配置文件读取参数（命令行参数优先）
-        queues = queues or ','.join(config_data.get('queues', [])) if config_data.get('queues') else None
-        executor = executor or config_data.get('executor', 'asyncio')
-        concurrency = concurrency if concurrency != 4 else config_data.get('concurrency', 4)
-        prefetch = prefetch if prefetch != 100 else config_data.get('prefetch', 100)
-        reload = reload or config_data.get('reload', False)
-    
+
+    # Click的envvar已经自动处理了环境变量读取
+
+    # 检查必需的 queues 参数
+    if not queues:
+        click.echo("Error: 必须指定 --queues 参数或设置 JETTASK_QUEUES 环境变量", err=True)
+        click.echo("\n示例:", err=True)
+        click.echo("  jettask worker --queues default", err=True)
+        click.echo("  jettask worker -q high,normal,low", err=True)
+        click.echo("  export JETTASK_QUEUES=default && jettask worker", err=True)
+        raise click.Abort()
+
+    # 设置默认 concurrency 值（如果没有通过CLI或环境变量指定）
+    cpu_count = multiprocessing.cpu_count()
+    if concurrency is None:
+        concurrency = max(1, cpu_count // 4)
+        click.echo(f"Using default concurrency: {concurrency} (1/4 of {cpu_count} CPU cores)")
+    if concurrency>cpu_count:
+        click.echo(f"Error: Specified concurrency {concurrency} exceeds CPU cores {cpu_count}", err=True)
+        raise click.Abort() 
+    # 固定使用 multi_asyncio 执行器
+    executor = 'multi_asyncio'
+
     # 加载应用
     try:
         if app_str:
@@ -266,10 +385,13 @@ def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
             click.echo("Searching in: app.py, main.py, server.py, worker.py")
             app = import_app()  # 自动发现
         
+        
+        # app.redis_prefix = app.redis_prefix or 'jettask'
         # 显示应用信息
         app_info = AppImporter.get_app_info(app)
         click.echo(f"\nFound Jettask app:")
         click.echo(f"  Tasks: {app_info['tasks']} registered")
+        
         if app_info.get('task_names') and app_info['tasks'] > 0:
             task_preview = app_info['task_names'][:3]
             click.echo(f"  Names: {', '.join(task_preview)}" + 
@@ -294,6 +416,7 @@ def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
         sys.exit(1)
     except Exception as e:
         import traceback
+        traceback.print_exc()
         click.echo(f"Error loading app: {e}", err=True)
         
         # 对于所有异常都显示堆栈信息
@@ -307,24 +430,8 @@ def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
         click.echo("Please check the traceback above for details.", err=True)
         sys.exit(1)
     
-    # 处理队列参数
-    if queues:
-        # 解析队列列表（支持逗号分隔）
-        queue_list = [q.strip() for q in queues.split(',') if q.strip()]
-    else:
-        # 如果没有指定队列，尝试从 app 获取
-        if hasattr(app, 'ep') and hasattr(app.ep, 'queues'):
-            queue_list = list(app.ep.queues)
-            if queue_list:
-                click.echo(f"Using queues from app: {', '.join(queue_list)}")
-        else:
-            queue_list = []
-    
-    if not queue_list:
-        click.echo("Error: No queues specified", err=True)
-        click.echo("  Use --queues to specify queues, e.g.: --queues queue1,queue2", err=True)
-        click.echo("  Or define queues in your app configuration", err=True)
-        sys.exit(1)
+    # 解析队列列表（支持逗号分隔）
+    queue_list = [q.strip() for q in queues.split(',') if q.strip()]
     
     # 从 app 实例中获取实际配置
     redis_url = app.redis_url if hasattr(app, 'redis_url') else 'Not configured'
@@ -364,36 +471,36 @@ def worker(app_str, queues, executor, concurrency, prefetch, reload, config):
 
 @cli.command('webui-consumer')
 @click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL', required=True,
-              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/v1/namespaces/default')
+              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/namespaces/default')
 @click.option('--check-interval', type=int, default=30,
               help='命名空间检测间隔（秒），默认30秒')
 @click.option('--debug', is_flag=True, help='启用调试模式')
 def webui_consumer(task_center, check_interval, debug):
     """启动数据消费者（自动识别单/多命名空间）
-    
+
     根据URL格式自动判断运行模式:
-    - 单命名空间: http://localhost:8001/api/v1/namespaces/{name}
+    - 单命名空间: http://localhost:8001/api/namespaces/{name}
     - 多命名空间: http://localhost:8001 或 http://localhost:8001/api
-    
+
     示例:
     \b
       # 为所有命名空间启动消费者（自动检测）
       jettask webui-consumer --task-center http://localhost:8001
       jettask webui-consumer --task-center http://localhost:8001/api
-      
+
       # 为单个命名空间启动消费者
-      jettask webui-consumer --task-center http://localhost:8001/api/v1/namespaces/default
-      
+      jettask webui-consumer --task-center http://localhost:8001/api/namespaces/default
+
       # 自定义检测间隔
       jettask webui-consumer --task-center http://localhost:8001 --check-interval 60
-      
+
       # 使用环境变量
       export JETTASK_CENTER_URL=http://localhost:8001
       jettask webui-consumer
     """
     import asyncio
-    from jettask.unified_consumer_manager import UnifiedConsumerManager
-    
+    from jettask.webui.namespace_manager.unified import UnifiedConsumerManager
+
     # 运行消费者管理器
     async def run_manager():
         """运行统一的消费者管理器"""
@@ -403,70 +510,51 @@ def webui_consumer(task_center, check_interval, debug):
             debug=debug
         )
         await manager.run()
-    
+
     try:
         asyncio.run(run_manager())
     except KeyboardInterrupt:
         click.echo("\nShutdown complete")
 
-@cli.command()
-def monitor():
-    """启动系统监控器"""
-    click.echo("Starting JetTask Monitor")
-    from jettask.run_monitor import main as monitor_main
-    monitor_main()
+# @cli.command()
+# def monitor():
+#     """启动系统监控器"""
+#     click.echo("Starting JetTask Monitor")
+#     # 已删除 run_monitor 模块
+#     click.echo("Monitor command is deprecated and has been removed.")
 
 @cli.command()
-@click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL',
-              help='任务中心URL，如: http://localhost:8001/api/v1/namespaces/default')
-def init(task_center):
+@click.option('--pg-url', envvar='JETTASK_PG_URL',
+              help='PostgreSQL连接URL (如: postgresql://user:pass@localhost/db)')
+def init(pg_url):
     """初始化数据库和配置
-    
+
     示例:
     \b
-      # 使用任务中心初始化
-      jettask init --task-center http://localhost:8001/api/v1/namespaces/default
-      jettask init -tc http://localhost:8001/api/v1/namespaces/production
-      
+      # 使用命令行参数
+      jettask init --pg-url postgresql://user:pass@localhost/jettask
+
       # 使用环境变量
-      export JETTASK_CENTER_URL=http://localhost:8001/api/v1/namespaces/default
-      jettask init
-      
-      # 不使用任务中心（仅使用本地环境变量）
+      export JETTASK_PG_URL=postgresql://user:pass@localhost/jettask
       jettask init
+
+      # 使用 .env 文件
+      jettask -e .env init
     """
     click.echo("Initializing JetTask...")
-    
+
     import os
-    
-    # 如果提供了任务中心URL，尝试从任务中心获取配置
-    if task_center:
-        os.environ['JETTASK_CENTER_URL'] = task_center
-        click.echo(f"Using Task Center: {task_center}")
-        
-        # 尝试从任务中心获取数据库配置
-        try:
-            from jettask.task_center import TaskCenter
-            tc = TaskCenter(task_center)
-            if tc._connect_sync():
-                p_config = tc.pg_config
-                # 从任务中心获取的配置中提取数据库连接参数
-                os.environ['JETTASK_PG_HOST'] = p_config['host']
-                os.environ['JETTASK_PG_PORT'] = str(p_config['port'])
-                os.environ['JETTASK_PG_DATABASE'] = p_config['database']
-                os.environ['JETTASK_PG_USER'] = p_config['user']
-                os.environ['JETTASK_PG_PASSWORD'] = p_config['password']
-            else:
-                click.echo("⚠ Failed to connect to Task Center, using local configuration", err=True)
-        except Exception as e:
-            click.echo(f"⚠ Could not get configuration from Task Center: {e}", err=True)
-            click.echo("  Falling back to local environment variables")
-    
+
+    # 如果提供了 PG URL，设置到环境变量
+    if pg_url:
+        os.environ['JETTASK_PG_URL'] = pg_url
+        click.echo(f"Using PostgreSQL: {pg_url.split('@')[1] if '@' in pg_url else pg_url}")
+
     # 初始化数据库
-    from jettask.db_init import init_database
+    from jettask.utils.db_init import init_database
     click.echo("\nInitializing database...")
     init_database()
-    
+
     click.echo("\n✓ JetTask initialized successfully!")
 
 @cli.command()
@@ -477,12 +565,12 @@ def status():
     
     # 检查 Redis 连接
     try:
-        import redis
-        r = redis.Redis(host='localhost', port=6379, db=0)
+        from jettask.utils.db_connector import get_sync_redis_client
+        r = get_sync_redis_client('redis://localhost:6379/0', decode_responses=True)
         r.ping()
         click.echo("✓ Redis: Connected")
-    except:
-        click.echo("✗ Redis: Not connected")
+    except Exception as e:
+        click.echo(f"✗ Redis: Not connected ({e})")
     
     # 检查 PostgreSQL 连接
     try:
@@ -503,8 +591,8 @@ def status():
 
 @cli.command()
 @click.option('--task-center', '-tc', envvar='JETTASK_CENTER_URL', required=True,
-              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/v1/namespaces/default')
-@click.option('--interval', '-i', type=float, default=0.1, 
+              help='任务中心URL，如: http://localhost:8001 或 http://localhost:8001/api/namespaces/default')
+@click.option('--interval', '-i', type=float, default=0.1,
               help='调度器扫描间隔（秒），默认0.1秒')
 @click.option('--batch-size', '-b', type=int, default=100,
               help='每批处理的最大任务数，默认100')
@@ -513,30 +601,30 @@ def status():
 @click.option('--debug', is_flag=True, help='启用调试模式')
 def scheduler(task_center, interval, batch_size, check_interval, debug):
     """启动定时任务调度器（自动识别单/多命名空间）
-    
+
     根据URL格式自动判断运行模式:
-    - 单命名空间: http://localhost:8001/api/v1/namespaces/{name}
+    - 单命名空间: http://localhost:8001/api/namespaces/{name}
     - 多命名空间: http://localhost:8001 或 http://localhost:8001/api
-    
+
     示例:
     \b
       # 为所有命名空间启动调度器（自动检测）
       jettask scheduler --task-center http://localhost:8001
       jettask scheduler --task-center http://localhost:8001/api
-      
+
       # 为单个命名空间启动调度器
-      jettask scheduler --task-center http://localhost:8001/api/v1/namespaces/default
-      
+      jettask scheduler --task-center http://localhost:8001/api/namespaces/default
+
       # 自定义配置
       jettask scheduler --task-center http://localhost:8001 --check-interval 60 --interval 0.5
-      
+
       # 使用环境变量
       export JETTASK_CENTER_URL=http://localhost:8001
       jettask scheduler
     """
     import asyncio
-    from jettask.scheduler.unified_scheduler_manager import UnifiedSchedulerManager
-    
+    from jettask.scheduler.scheduler_coordinator import UnifiedSchedulerManager
+
     # 运行调度器管理器
     async def run_manager():
         """运行统一的调度器管理器"""
@@ -548,7 +636,7 @@ def scheduler(task_center, interval, batch_size, check_interval, debug):
             debug=debug
         )
         await manager.run()
-    
+
     try:
         asyncio.run(run_manager())
     except KeyboardInterrupt:
@@ -710,8 +798,6 @@ def frontend(port, host, api_url, auto_install, force_install, build_only):
             import http.server
             import socketserver
             import urllib.request
-            import urllib.parse
-            import json
             
             class ProxyHandler(http.server.SimpleHTTPRequestHandler):
                 def __init__(self, *args, **kwargs):