devs-cli 0.1.3__tar.gz → 0.1.5__tar.gz

{devs_cli-0.1.3/devs_cli.egg-info → devs_cli-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: DevContainer Management Tool - Manage multiple named devcontainers for any project
 Author: Dan Lester
 License-Expression: MIT
@@ -81,9 +81,9 @@ devs start frontend --env DEBUG=true --env API_URL=http://localhost:3000
 devs claude frontend "Fix the tests" --env NODE_ENV=test
 
 # Set up Claude authentication (once per host)
-devs claude-auth
+devs claude --auth
 # Or with API key
-devs claude-auth --api-key <YOUR_API_KEY>
+devs claude --auth --api-key <YOUR_API_KEY>
 
 # Clean up when done
 devs stop frontend backend

{devs_cli-0.1.3 → devs_cli-0.1.5}/README.md

@@ -40,9 +40,9 @@ devs start frontend --env DEBUG=true --env API_URL=http://localhost:3000
 devs claude frontend "Fix the tests" --env NODE_ENV=test
 
 # Set up Claude authentication (once per host)
-devs claude-auth
+devs claude --auth
 # Or with API key
-devs claude-auth --api-key <YOUR_API_KEY>
+devs claude --auth --api-key <YOUR_API_KEY>
 
 # Clean up when done
 devs stop frontend backend

{devs_cli-0.1.3 → devs_cli-0.1.5}/devs/cli.py

@@ -328,67 +328,80 @@ def shell(dev_name: str, live: bool, env: tuple, debug: bool) -> None:
 
 
 @cli.command()
-@click.argument('dev_name')
-@click.argument('prompt')
+@click.argument('dev_name', required=False)
+@click.argument('prompt', required=False)
+@click.option('--auth', is_flag=True, help='Set up Claude authentication for devcontainers')
+@click.option('--api-key', help='Claude API key to authenticate with (use with --auth)')
 @click.option('--reset-workspace', is_flag=True, help='Reset workspace contents before execution')
 @click.option('--live', is_flag=True, help='Start container with current directory mounted as workspace')
 @click.option('--env', multiple=True, help='Environment variables to pass to container (format: VAR=value)')
 @debug_option
-def claude(dev_name: str, prompt: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
-    """Execute Claude CLI in devcontainer.
-    
+def claude(dev_name: str, prompt: str, auth: bool, api_key: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
+    """Execute Claude CLI in devcontainer or set up authentication.
+
     DEV_NAME: Development environment name
     PROMPT: Prompt to send to Claude
-    
+
     Example: devs claude sally "Summarize this codebase"
     Example: devs claude sally "Fix the tests" --reset-workspace
     Example: devs claude sally "Fix the tests" --live  # Run with current directory
     Example: devs claude sally "Start the server" --env QUART_PORT=5001
+    Example: devs claude --auth                        # Interactive authentication
+    Example: devs claude --auth --api-key <YOUR_KEY>   # API key authentication
     """
+    # Handle authentication mode
+    if auth:
+        _handle_claude_auth(api_key=api_key, debug=debug)
+        return
+
+    # Validate required arguments for execution mode
+    if not dev_name or not prompt:
+        raise click.UsageError("DEV_NAME and PROMPT are required unless using --auth")
+
     check_dependencies()
     project = get_project()
-    
+
     # Load environment variables from DEVS.yml and merge with CLI --env flags
     devs_env = DevsConfigLoader.load_env_vars(dev_name, project.info.name)
     cli_env = parse_env_vars(env) if env else {}
     extra_env = merge_env_vars(devs_env, cli_env) if devs_env or cli_env else None
-    
+
     if extra_env:
         console.print(f"🔧 Environment variables: {', '.join(f'{k}={v}' for k, v in extra_env.items())}")
-    
+
     container_manager = ContainerManager(project, config)
     workspace_manager = WorkspaceManager(project, config)
-    
+
     try:
         # Ensure workspace exists (handles live mode and reset internally)
         workspace_dir = workspace_manager.create_workspace(dev_name, reset_contents=reset_workspace, live=live)
         # Ensure container is running
         container_manager.ensure_container_running(
-            dev_name=dev_name, 
-            workspace_dir=workspace_dir, 
-            force_rebuild=False, 
-            debug=debug, 
-            live=live, 
+            dev_name=dev_name,
+            workspace_dir=workspace_dir,
+            force_rebuild=False,
+            debug=debug,
+            live=live,
             extra_env=extra_env
         )
-        
+
         # Execute Claude
         console.print(f"🤖 Executing Claude in {dev_name}...")
         if reset_workspace and not live:
             console.print("🗑️  Workspace contents reset")
         console.print(f"📝 Prompt: {prompt}")
         console.print("")
-        
+
         success, output, error = container_manager.exec_claude(
             dev_name=dev_name,
-            workspace_dir=workspace_dir, 
-            prompt=prompt, 
-            debug=debug, 
-            stream=True, 
-            live=live, 
+            workspace_dir=workspace_dir,
+            prompt=prompt,
+            debug=debug,
+            stream=True,
+            live=live,
             extra_env=extra_env
         )
-        
+
         console.print("")  # Add spacing after streamed output
         if success:
             console.print("✅ Claude execution completed")
@@ -399,197 +412,372 @@ def claude(dev_name: str, prompt: str, reset_workspace: bool, live: bool, env: t
                 console.print("🚫 Error:")
                 console.print(error)
             sys.exit(1)
-        
+
     except (ContainerError, WorkspaceError) as e:
         console.print(f"❌ Error executing Claude in {dev_name}: {e}")
         sys.exit(1)
 
 
+def _handle_claude_auth(api_key: str, debug: bool) -> None:
+    """Handle Claude authentication setup.
+
+    This configures Claude authentication that will be shared across
+    all devcontainers for this project. The authentication is stored
+    on the host and bind-mounted into containers.
+    """
+    try:
+        # Ensure Claude config directory exists
+        config.ensure_directories()
+
+        console.print("🔐 Setting up Claude authentication...")
+        console.print(f"   Configuration will be saved to: {config.claude_config_dir}")
+
+        if api_key:
+            # Set API key directly using Claude CLI
+            console.print("   Using provided API key...")
+
+            # Set CLAUDE_CONFIG_DIR to our config directory and run auth with API key
+            env = os.environ.copy()
+            env['CLAUDE_CONFIG_DIR'] = str(config.claude_config_dir)
+
+            cmd = ['claude', 'auth', '--key', api_key]
+
+            if debug:
+                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+                console.print(f"[dim]CLAUDE_CONFIG_DIR: {config.claude_config_dir}[/dim]")
+
+            result = subprocess.run(
+                cmd,
+                env=env,
+                capture_output=True,
+                text=True
+            )
+
+            if result.returncode != 0:
+                error_msg = result.stderr or result.stdout or "Unknown error"
+                raise Exception(f"Claude authentication failed: {error_msg}")
+
+        else:
+            # Interactive authentication
+            console.print("   Starting interactive authentication...")
+            console.print("   Follow the prompts to authenticate with Claude")
+            console.print("")
+
+            # Set CLAUDE_CONFIG_DIR to our config directory
+            env = os.environ.copy()
+            env['CLAUDE_CONFIG_DIR'] = str(config.claude_config_dir)
+
+            cmd = ['claude', 'auth']
+
+            if debug:
+                console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
+                console.print(f"[dim]CLAUDE_CONFIG_DIR: {config.claude_config_dir}[/dim]")
+
+            # Run interactively
+            result = subprocess.run(
+                cmd,
+                env=env,
+                check=False
+            )
+
+            if result.returncode != 0:
+                raise Exception("Claude authentication was cancelled or failed")
+
+        console.print("")
+        console.print("✅ Claude authentication configured successfully!")
+        console.print(f"   Configuration saved to: {config.claude_config_dir}")
+        console.print("   This authentication will be shared across all devcontainers")
+        console.print("")
+        console.print("💡 You can now use Claude in any devcontainer:")
+        console.print("   devs claude <dev-name> 'Your prompt here'")
+
+    except FileNotFoundError:
+        console.print("❌ Claude CLI not found on host machine")
+        console.print("")
+        console.print("Please install Claude CLI first:")
+        console.print("   npm install -g @anthropic-ai/claude-cli")
+        console.print("")
+        console.print("Note: Claude needs to be installed on the host machine")
+        console.print("      for authentication. It's already available in containers.")
+        sys.exit(1)
+
+    except Exception as e:
+        console.print(f"❌ Failed to configure Claude authentication: {e}")
+        if debug:
+            import traceback
+            console.print(traceback.format_exc())
+        sys.exit(1)
+
+
 @cli.command()
-@click.argument('dev_name')
+@click.argument('dev_name', required=False)
+@click.argument('prompt', required=False)
+@click.option('--auth', is_flag=True, help='Set up Codex authentication for devcontainers')
+@click.option('--api-key', help='OpenAI API key to authenticate with (use with --auth)')
 @click.option('--reset-workspace', is_flag=True, help='Reset workspace contents before execution')
 @click.option('--live', is_flag=True, help='Start container with current directory mounted as workspace')
 @click.option('--env', multiple=True, help='Environment variables to pass to container (format: VAR=value)')
 @debug_option
-def runtests(dev_name: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
-    """Run tests in devcontainer.
-    
+def codex(dev_name: str, prompt: str, auth: bool, api_key: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
+    """Execute OpenAI Codex CLI in devcontainer or set up authentication.
+
     DEV_NAME: Development environment name
-    
-    Example: devs runtests sally
-    Example: devs runtests sally --reset-workspace
-    Example: devs runtests sally --live  # Run with current directory
-    Example: devs runtests sally --env NODE_ENV=test
+    PROMPT: Prompt to send to Codex
+
+    Example: devs codex sally "Summarize this codebase"
+    Example: devs codex sally "Fix the tests" --reset-workspace
+    Example: devs codex sally "Fix the tests" --live  # Run with current directory
+    Example: devs codex sally "Start the server" --env QUART_PORT=5001
+    Example: devs codex --auth                        # Interactive authentication
+    Example: devs codex --auth --api-key <YOUR_KEY>   # API key authentication
     """
+    # Handle authentication mode
+    if auth:
+        _handle_codex_auth(api_key=api_key, debug=debug)
+        return
+
+    # Validate required arguments for execution mode
+    if not dev_name or not prompt:
+        raise click.UsageError("DEV_NAME and PROMPT are required unless using --auth")
+
     check_dependencies()
     project = get_project()
-    
-    # Load full DEVS configuration
-    try:
-        project_name = project.info.name
-    except Exception:
-        project_name = None
-    
-    devs_config = DevsConfigLoader.load(project_name)
-    
-    # Get test command from config
-    command = devs_config.ci_test_command
-    
+
     # Load environment variables from DEVS.yml and merge with CLI --env flags
-    devs_env = devs_config.get_env_vars(dev_name)
+    devs_env = DevsConfigLoader.load_env_vars(dev_name, project.info.name)
     cli_env = parse_env_vars(env) if env else {}
     extra_env = merge_env_vars(devs_env, cli_env) if devs_env or cli_env else None
-    
+
     if extra_env:
         console.print(f"🔧 Environment variables: {', '.join(f'{k}={v}' for k, v in extra_env.items())}")
-    
+
     container_manager = ContainerManager(project, config)
     workspace_manager = WorkspaceManager(project, config)
-    
+
     try:
         # Ensure workspace exists (handles live mode and reset internally)
         workspace_dir = workspace_manager.create_workspace(dev_name, reset_contents=reset_workspace, live=live)
         # Ensure container is running
         container_manager.ensure_container_running(
-            dev_name=dev_name, 
-            workspace_dir=workspace_dir, 
-            force_rebuild=False, 
-            debug=debug, 
-            live=live, 
+            dev_name=dev_name,
+            workspace_dir=workspace_dir,
+            force_rebuild=False,
+            debug=debug,
+            live=live,
             extra_env=extra_env
         )
-        
-        # Execute test command
-        console.print(f"🧪 Running tests in {dev_name}...")
+
+        # Execute Codex
+        console.print(f"🤖 Executing Codex in {dev_name}...")
         if reset_workspace and not live:
             console.print("🗑️  Workspace contents reset")
-        console.print(f"🔧 Command: {command}")
+        console.print(f"📝 Prompt: {prompt}")
         console.print("")
-        
-        success, output, error = container_manager.exec_command(
-            dev_name=dev_name, 
-            workspace_dir=workspace_dir, 
-            command=command, 
-            debug=debug, 
-            stream=True, 
-            live=live, 
+
+        success, output, error = container_manager.exec_codex(
+            dev_name=dev_name,
+            workspace_dir=workspace_dir,
+            prompt=prompt,
+            debug=debug,
+            stream=True,
+            live=live,
             extra_env=extra_env
         )
-        
+
         console.print("")  # Add spacing after streamed output
         if success:
-            console.print("✅ Tests completed successfully")
+            console.print("✅ Codex execution completed")
         else:
-            console.print("❌ Tests failed")
+            console.print("❌ Codex execution failed")
             if error:
                 console.print("")
                 console.print("🚫 Error:")
                 console.print(error)
             sys.exit(1)
-        
+
     except (ContainerError, WorkspaceError) as e:
-        console.print(f"❌ Error running tests in {dev_name}: {e}")
+        console.print(f"❌ Error executing Codex in {dev_name}: {e}")
         sys.exit(1)
 
 
-@cli.command('claude-auth')
-@click.option('--api-key', help='Claude API key to authenticate with')
-@debug_option
-def claude_auth(api_key: str, debug: bool) -> None:
-    """Set up Claude authentication for devcontainers.
-    
-    This configures Claude authentication that will be shared across
+def _handle_codex_auth(api_key: str, debug: bool) -> None:
+    """Handle Codex authentication setup.
+
+    This configures Codex authentication that will be shared across
     all devcontainers for this project. The authentication is stored
     on the host and bind-mounted into containers.
-    
-    Example: devs claude-auth
-    Example: devs claude-auth --api-key <YOUR_API_KEY>
     """
-    
     try:
-        # Ensure Claude config directory exists
+        # Ensure Codex config directory exists
         config.ensure_directories()
-        
-        console.print("🔐 Setting up Claude authentication...")
-        console.print(f"   Configuration will be saved to: {config.claude_config_dir}")
-        
+
+        console.print("🔐 Setting up Codex authentication...")
+        console.print(f"   Configuration will be saved to: {config.codex_config_dir}")
+
         if api_key:
-            # Set API key directly using Claude CLI
+            # Set API key directly using Codex CLI
             console.print("   Using provided API key...")
-            
-            # Set CLAUDE_CONFIG_DIR to our config directory and run auth with API key
+
+            # Set CODEX_CONFIG_HOME to our config directory and run auth with API key
             env = os.environ.copy()
-            env['CLAUDE_CONFIG_DIR'] = str(config.claude_config_dir)
-            
-            cmd = ['claude', 'auth', '--key', api_key]
-            
+            env['CODEX_CONFIG_HOME'] = str(config.codex_config_dir)
+
+            cmd = ['codex', 'auth', '--api-key', api_key]
+
             if debug:
                 console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
-                console.print(f"[dim]CLAUDE_CONFIG_DIR: {config.claude_config_dir}[/dim]")
-            
+                console.print(f"[dim]CODEX_CONFIG_HOME: {config.codex_config_dir}[/dim]")
+
             result = subprocess.run(
                 cmd,
                 env=env,
                 capture_output=True,
                 text=True
             )
-            
+
             if result.returncode != 0:
                 error_msg = result.stderr or result.stdout or "Unknown error"
-                raise Exception(f"Claude authentication failed: {error_msg}")
-                
+                raise Exception(f"Codex authentication failed: {error_msg}")
+
         else:
             # Interactive authentication
             console.print("   Starting interactive authentication...")
-            console.print("   Follow the prompts to authenticate with Claude")
+            console.print("   Follow the prompts to authenticate with Codex")
             console.print("")
-            
-            # Set CLAUDE_CONFIG_DIR to our config directory
+
+            # Set CODEX_CONFIG_HOME to our config directory
             env = os.environ.copy()
-            env['CLAUDE_CONFIG_DIR'] = str(config.claude_config_dir)
-            
-            cmd = ['claude', 'auth']
-            
+            env['CODEX_CONFIG_HOME'] = str(config.codex_config_dir)
+
+            cmd = ['codex', 'auth']
+
             if debug:
                 console.print(f"[dim]Running: {' '.join(cmd)}[/dim]")
-                console.print(f"[dim]CLAUDE_CONFIG_DIR: {config.claude_config_dir}[/dim]")
-            
+                console.print(f"[dim]CODEX_CONFIG_HOME: {config.codex_config_dir}[/dim]")
+
             # Run interactively
             result = subprocess.run(
                 cmd,
                 env=env,
                 check=False
             )
-            
+
             if result.returncode != 0:
-                raise Exception("Claude authentication was cancelled or failed")
-        
+                raise Exception("Codex authentication was cancelled or failed")
+
         console.print("")
-        console.print("✅ Claude authentication configured successfully!")
-        console.print(f"   Configuration saved to: {config.claude_config_dir}")
+        console.print("✅ Codex authentication configured successfully!")
+        console.print(f"   Configuration saved to: {config.codex_config_dir}")
         console.print("   This authentication will be shared across all devcontainers")
         console.print("")
-        console.print("💡 You can now use Claude in any devcontainer:")
-        console.print("   devs claude <dev-name> 'Your prompt here'")
-        
+        console.print("💡 You can now use Codex in any devcontainer:")
+        console.print("   devs codex <dev-name> 'Your prompt here'")
+
     except FileNotFoundError:
-        console.print("❌ Claude CLI not found on host machine")
+        console.print("❌ Codex CLI not found on host machine")
         console.print("")
-        console.print("Please install Claude CLI first:")
-        console.print("   npm install -g @anthropic-ai/claude-cli")
+        console.print("Please install Codex CLI first:")
+        console.print("   npm install -g @openai/codex")
         console.print("")
-        console.print("Note: Claude needs to be installed on the host machine")
+        console.print("Note: Codex needs to be installed on the host machine")
         console.print("      for authentication. It's already available in containers.")
         sys.exit(1)
-        
+
     except Exception as e:
-        console.print(f"❌ Failed to configure Claude authentication: {e}")
+        console.print(f"❌ Failed to configure Codex authentication: {e}")
         if debug:
             import traceback
             console.print(traceback.format_exc())
         sys.exit(1)
 
 
+@cli.command()
+@click.argument('dev_name')
+@click.option('--reset-workspace', is_flag=True, help='Reset workspace contents before execution')
+@click.option('--live', is_flag=True, help='Start container with current directory mounted as workspace')
+@click.option('--env', multiple=True, help='Environment variables to pass to container (format: VAR=value)')
+@debug_option
+def runtests(dev_name: str, reset_workspace: bool, live: bool, env: tuple, debug: bool) -> None:
+    """Run tests in devcontainer.
+    
+    DEV_NAME: Development environment name
+    
+    Example: devs runtests sally
+    Example: devs runtests sally --reset-workspace
+    Example: devs runtests sally --live  # Run with current directory
+    Example: devs runtests sally --env NODE_ENV=test
+    """
+    check_dependencies()
+    project = get_project()
+    
+    # Load full DEVS configuration
+    try:
+        project_name = project.info.name
+    except Exception:
+        project_name = None
+    
+    devs_config = DevsConfigLoader.load(project_name)
+    
+    # Get test command from config
+    command = devs_config.ci_test_command
+    
+    # Load environment variables from DEVS.yml and merge with CLI --env flags
+    devs_env = devs_config.get_env_vars(dev_name)
+    cli_env = parse_env_vars(env) if env else {}
+    extra_env = merge_env_vars(devs_env, cli_env) if devs_env or cli_env else None
+    
+    if extra_env:
+        console.print(f"🔧 Environment variables: {', '.join(f'{k}={v}' for k, v in extra_env.items())}")
+    
+    container_manager = ContainerManager(project, config)
+    workspace_manager = WorkspaceManager(project, config)
+    
+    try:
+        # Ensure workspace exists (handles live mode and reset internally)
+        workspace_dir = workspace_manager.create_workspace(dev_name, reset_contents=reset_workspace, live=live)
+        # Ensure container is running
+        container_manager.ensure_container_running(
+            dev_name=dev_name, 
+            workspace_dir=workspace_dir, 
+            force_rebuild=False, 
+            debug=debug, 
+            live=live, 
+            extra_env=extra_env
+        )
+        
+        # Execute test command
+        console.print(f"🧪 Running tests in {dev_name}...")
+        if reset_workspace and not live:
+            console.print("🗑️  Workspace contents reset")
+        console.print(f"🔧 Command: {command}")
+        console.print("")
+        
+        success, output, error = container_manager.exec_command(
+            dev_name=dev_name, 
+            workspace_dir=workspace_dir, 
+            command=command, 
+            debug=debug, 
+            stream=True, 
+            live=live, 
+            extra_env=extra_env
+        )
+        
+        console.print("")  # Add spacing after streamed output
+        if success:
+            console.print("✅ Tests completed successfully")
+        else:
+            console.print("❌ Tests failed")
+            if error:
+                console.print("")
+                console.print("🚫 Error:")
+                console.print(error)
+            sys.exit(1)
+        
+    except (ContainerError, WorkspaceError) as e:
+        console.print(f"❌ Error running tests in {dev_name}: {e}")
+        sys.exit(1)
+
+
 @cli.command()
 @click.option('--all-projects', is_flag=True, help='List containers for all projects')
 def list(all_projects: bool) -> None:

{devs_cli-0.1.3 → devs_cli-0.1.5}/devs/config.py

@@ -15,17 +15,24 @@ class Config(BaseConfig):
     WORKSPACES_DIR = Path.home() / ".devs" / "workspaces"
     BRIDGE_DIR = Path.home() / ".devs" / "bridge"
     CLAUDE_CONFIG_DIR = Path.home() / ".devs" / "claudeconfig"
-    
+    CODEX_CONFIG_DIR = Path.home() / ".devs" / "codexconfig"
+
     def __init__(self) -> None:
         """Initialize configuration with environment variable overrides."""
         super().__init__()
-        
+
         # CLI-specific configuration
         claude_config_env = os.getenv("DEVS_CLAUDE_CONFIG_DIR")
         if claude_config_env:
             self.claude_config_dir = Path(claude_config_env)
         else:
             self.claude_config_dir = self.CLAUDE_CONFIG_DIR
+
+        codex_config_env = os.getenv("DEVS_CODEX_CONFIG_DIR")
+        if codex_config_env:
+            self.codex_config_dir = Path(codex_config_env)
+        else:
+            self.codex_config_dir = self.CODEX_CONFIG_DIR
     
     def get_default_workspaces_dir(self) -> Path:
         """Get default workspaces directory for CLI package."""
@@ -43,6 +50,7 @@ class Config(BaseConfig):
         """Ensure required directories exist."""
         super().ensure_directories()
         self.claude_config_dir.mkdir(parents=True, exist_ok=True)
+        self.codex_config_dir.mkdir(parents=True, exist_ok=True)
 
 
 # Global config instance

{devs_cli-0.1.3 → devs_cli-0.1.5/devs_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devs-cli
-Version: 0.1.3
+Version: 0.1.5
 Summary: DevContainer Management Tool - Manage multiple named devcontainers for any project
 Author: Dan Lester
 License-Expression: MIT
@@ -81,9 +81,9 @@ devs start frontend --env DEBUG=true --env API_URL=http://localhost:3000
 devs claude frontend "Fix the tests" --env NODE_ENV=test
 
 # Set up Claude authentication (once per host)
-devs claude-auth
+devs claude --auth
 # Or with API key
-devs claude-auth --api-key <YOUR_API_KEY>
+devs claude --auth --api-key <YOUR_API_KEY>
 
 # Clean up when done
 devs stop frontend backend

{devs_cli-0.1.3 → devs_cli-0.1.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devs-cli"
-version = "0.1.3"
+version = "0.1.5"
 description = "DevContainer Management Tool - Manage multiple named devcontainers for any project"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -65,7 +65,7 @@ line-length = 88
 target-version = ['py38']
 
 [tool.mypy]
-python_version = "0.1.3"
+python_version = "3.8"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

{devs_cli-0.1.3 → devs_cli-0.1.5}/tests/test_cli.py

@@ -123,31 +123,32 @@ class TestCLI:
         assert result.exit_code != 0
         assert "Missing argument" in result.output
     
-    def test_claude_auth_command_help(self):
-        """Test claude-auth command help."""
+    def test_claude_command_help(self):
+        """Test claude command help."""
         runner = CliRunner()
-        result = runner.invoke(cli, ['claude-auth', '--help'])
-        
+        result = runner.invoke(cli, ['claude', '--help'])
+
         assert result.exit_code == 0
-        assert "Set up Claude authentication" in result.output
+        assert "Execute Claude CLI in devcontainer or set up authentication" in result.output
+        assert "--auth" in result.output
         assert "--api-key" in result.output
-    
+
     @patch('devs.cli.subprocess.run')
     @patch('devs.cli.config')
     def test_claude_auth_with_api_key(self, mock_config, mock_subprocess):
-        """Test claude-auth command with API key."""
+        """Test claude --auth command with API key."""
         # Setup mocks
         mock_config.claude_config_dir = '/tmp/test-claude-config'
         mock_config.ensure_directories = Mock()
         mock_subprocess.return_value.returncode = 0
-        
+
         runner = CliRunner()
-        result = runner.invoke(cli, ['claude-auth', '--api-key', 'test-key-123'])
-        
+        result = runner.invoke(cli, ['claude', '--auth', '--api-key', 'test-key-123'])
+
         assert result.exit_code == 0
         assert "Setting up Claude authentication" in result.output
         assert "Claude authentication configured successfully" in result.output
-        
+
         # Verify subprocess was called with correct arguments
         mock_subprocess.assert_called_once()
         call_args = mock_subprocess.call_args
@@ -155,43 +156,133 @@ class TestCLI:
         assert 'auth' in call_args[0][0]
         assert '--key' in call_args[0][0]
         assert 'test-key-123' in call_args[0][0]
-    
+
     @patch('devs.cli.subprocess.run')
     @patch('devs.cli.config')
     def test_claude_auth_interactive(self, mock_config, mock_subprocess):
-        """Test claude-auth command in interactive mode."""
+        """Test claude --auth command in interactive mode."""
         # Setup mocks
         mock_config.claude_config_dir = '/tmp/test-claude-config'
         mock_config.ensure_directories = Mock()
         mock_subprocess.return_value.returncode = 0
-        
+
         runner = CliRunner()
-        result = runner.invoke(cli, ['claude-auth'])
-        
+        result = runner.invoke(cli, ['claude', '--auth'])
+
         assert result.exit_code == 0
         assert "Setting up Claude authentication" in result.output
         assert "Starting interactive authentication" in result.output
         assert "Claude authentication configured successfully" in result.output
-        
+
         # Verify subprocess was called for interactive auth
         mock_subprocess.assert_called_once()
         call_args = mock_subprocess.call_args
         assert 'claude' in call_args[0][0]
         assert 'auth' in call_args[0][0]
         assert '--key' not in call_args[0][0]
-    
+
     @patch('devs.cli.subprocess.run')
     @patch('devs.cli.config')
     def test_claude_auth_command_not_found(self, mock_config, mock_subprocess):
-        """Test claude-auth when claude CLI is not installed."""
+        """Test claude --auth when claude CLI is not installed."""
         # Setup mocks
         mock_config.claude_config_dir = '/tmp/test-claude-config'
         mock_config.ensure_directories = Mock()
         mock_subprocess.side_effect = FileNotFoundError()
-        
+
         runner = CliRunner()
-        result = runner.invoke(cli, ['claude-auth'])
-        
+        result = runner.invoke(cli, ['claude', '--auth'])
+
         assert result.exit_code == 1
         assert "Claude CLI not found" in result.output
-        assert "npm install -g @anthropic-ai/claude-cli" in result.output
+        assert "npm install -g @anthropic-ai/claude-cli" in result.output
+
+    def test_claude_missing_args(self):
+        """Test claude command without required args (not using --auth)."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ['claude'])
+
+        assert result.exit_code != 0
+        assert "DEV_NAME and PROMPT are required unless using --auth" in result.output
+
+    def test_codex_command_help(self):
+        """Test codex command help."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--help'])
+
+        assert result.exit_code == 0
+        assert "Execute OpenAI Codex CLI in devcontainer or set up authentication" in result.output
+        assert "--auth" in result.output
+        assert "--api-key" in result.output
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_with_api_key(self, mock_config, mock_subprocess):
+        """Test codex --auth command with API key."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.return_value.returncode = 0
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth', '--api-key', 'test-key-123'])
+
+        assert result.exit_code == 0
+        assert "Setting up Codex authentication" in result.output
+        assert "Codex authentication configured successfully" in result.output
+
+        # Verify subprocess was called with correct arguments
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args
+        assert 'codex' in call_args[0][0]
+        assert 'auth' in call_args[0][0]
+        assert '--api-key' in call_args[0][0]
+        assert 'test-key-123' in call_args[0][0]
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_interactive(self, mock_config, mock_subprocess):
+        """Test codex --auth command in interactive mode."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.return_value.returncode = 0
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth'])
+
+        assert result.exit_code == 0
+        assert "Setting up Codex authentication" in result.output
+        assert "Starting interactive authentication" in result.output
+        assert "Codex authentication configured successfully" in result.output
+
+        # Verify subprocess was called for interactive auth
+        mock_subprocess.assert_called_once()
+        call_args = mock_subprocess.call_args
+        assert 'codex' in call_args[0][0]
+        assert 'auth' in call_args[0][0]
+        assert '--api-key' not in call_args[0][0]
+
+    @patch('devs.cli.subprocess.run')
+    @patch('devs.cli.config')
+    def test_codex_auth_command_not_found(self, mock_config, mock_subprocess):
+        """Test codex --auth when codex CLI is not installed."""
+        # Setup mocks
+        mock_config.codex_config_dir = '/tmp/test-codex-config'
+        mock_config.ensure_directories = Mock()
+        mock_subprocess.side_effect = FileNotFoundError()
+
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex', '--auth'])
+
+        assert result.exit_code == 1
+        assert "Codex CLI not found" in result.output
+        assert "npm install -g @openai/codex" in result.output
+
+    def test_codex_missing_args(self):
+        """Test codex command without required args (not using --auth)."""
+        runner = CliRunner()
+        result = runner.invoke(cli, ['codex'])
+
+        assert result.exit_code != 0
+        assert "DEV_NAME and PROMPT are required unless using --auth" in result.output