aliyun-controller 0.1.0__py3-none-any.whl

aliyun_controller/__init__.py

@@ -0,0 +1,4 @@
+"""
+Aliyun Controller
+"""
+__version__ = "0.1.0"

aliyun_controller/config.yaml.example

@@ -0,0 +1,5 @@
+# 阿里云访问密钥配置示例
+# 复制此文件为 config.yaml 并填入你的实际密钥
+
+access_key_id: your_access_key_id
+access_key_secret: your_access_key_secret

aliyun_controller/main.py

@@ -0,0 +1,186 @@
+import datetime
+import re
+import logging
+import traceback
+import argparse
+import os
+from pathlib import Path
+from InquirerPy import prompt
+from InquirerPy.base.control import Choice
+from aliyun_controller.modules.billing import get_outbound_traffic_module, summarize_billing_module
+from aliyun_controller.modules.dns import dns_management_module
+
+# 配置日志
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("app.log", encoding='utf-8'),
+        logging.StreamHandler()
+    ]
+)
+
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(description="阿里云控制台工具")
+    parser.add_argument(
+        "-D", "--dir",
+        help="配置文件目录路径",
+        default=os.path.expanduser("~/.config/aliyun-controller")
+    )
+    return parser.parse_args()
+
+def _prompt_for_billing_cycle() -> str | None:
+    """
+    提示用户输入账单周期，并验证格式。
+    支持 YYYY-MM 和 YYYY-M 格式。
+    如果用户取消输入，则返回 None。
+    """
+    date_prompt = [
+        {
+            "type": "input",
+            "message": "请输入要查询的月份 (格式 YYYY-MM 或 YYYY-M):",
+            "name": "cycle",
+            "validate": lambda val: re.match(r"^\d{4}-(0?[1-9]|1[0-2])$", val) is not None,
+            "invalid_message": "格式错误，请输入 YYYY-MM 或 YYYY-M 格式的月份。"
+        }
+    ]
+    try:
+        answer = prompt(date_prompt)
+        if not answer:  # 用户按 Ctrl+C
+            return None
+        
+        cycle = answer.get("cycle")
+        year, month = cycle.split('-')
+        if len(month) == 1:
+            month = '0' + month
+        return f"{year}-{month}"
+    except KeyboardInterrupt:
+        return None
+    except Exception as e:
+        logging.error(f"输入月份时发生错误: {e}")
+        logging.debug(traceback.format_exc())
+        return None
+
+def query_and_repeat(query_function):
+    """
+    包装查询函数：先查当月，然后提供子菜单让用户选择继续查询或返回。
+    :param query_function: 接受 billing_cycle 参数的查询函数。
+    """
+    # 1. 默认查询当月
+    current_cycle = datetime.datetime.now().strftime("%Y-%m")
+    print(f"\n--- 正在查询默认月份 {current_cycle} 的账单 ---")
+    try:
+        query_function(current_cycle)
+    except Exception as e:
+        logging.error(f"查询账单时发生错误: {e}")
+        logging.debug(traceback.format_exc())
+        print(f"\n查询账单时发生错误，请查看日志了解详情。")
+
+    # 2. 进入子菜单循环
+    while True:
+        sub_menu_prompt = [
+            {
+                "type": "list",
+                "message": "请选择接下来的操作:",
+                "choices": [
+                    Choice("set_date", name="查询其他月份"),
+                    Choice("return", name="返回主菜单")
+                ],
+                "name": "sub_action"
+            }
+        ]
+        
+        try:
+            result = prompt(sub_menu_prompt)
+            if not result: # 用户按 Ctrl+C
+                print("\n已返回主菜单。")
+                break
+
+            action = result.get("sub_action")
+            if action == "set_date":
+                new_cycle = _prompt_for_billing_cycle()
+                if new_cycle:
+                    print(f"\n--- 正在查询 {new_cycle} 的账单 ---")
+                    try:
+                        query_function(new_cycle)
+                    except Exception as e:
+                        logging.error(f"查询账单时发生错误: {e}")
+                        logging.debug(traceback.format_exc())
+                        print(f"\n查询账单时发生错误，请查看日志了解详情。")
+                else:
+                    print("\n输入已取消。")
+                    continue # 重新显示子菜单
+            elif action == "return":
+                print("\n已返回主菜单。")
+                break
+        except Exception as e:
+            logging.error(f"执行操作时发生错误: {e}")
+            logging.debug(traceback.format_exc())
+            print(f"\n执行操作时发生错误，请查看日志了解详情。")
+            continue
+
+def main():
+    """
+    主函数，提供交互式菜单
+    """
+    args = parse_args()
+    
+    # 设置配置目录环境变量，供模块使用
+    os.environ['ALIYUN_CONTROLLER_CONFIG_DIR'] = args.dir
+    
+    print("阿里云控制台工具")
+    print("=" * 30)
+    
+    while True:
+        questions = [
+            {
+                "type": "list",
+                "message": "请选择要执行的功能:",
+                "choices": [
+                    Choice("get_traffic", name="1. 查询总流出流量"),
+                    Choice("summarize_bill", name="2. 归纳账单"),
+                    Choice("manage_dns", name="3. DNS解析管理"),
+                    Choice(value=None, name="[退出]")
+                ],
+                "name": "action",
+            }
+        ]
+
+        try:
+            result = prompt(questions)
+            if not result:
+                print("\n已退出。")
+                break
+                
+            action = result.get("action")
+
+            if action == "get_traffic":
+                query_and_repeat(get_outbound_traffic_module)
+            elif action == "summarize_bill":
+                query_and_repeat(summarize_billing_module)
+            elif action == "manage_dns":
+                try:
+                    dns_management_module()
+                except Exception as e:
+                    logging.error(f"DNS管理模块发生错误: {e}")
+                    logging.debug(traceback.format_exc())
+                    print(f"\nDNS管理模块发生错误，请查看日志了解详情。")
+            elif action is None:
+                print("已退出。")
+                break
+        except Exception as e:
+            logging.error(f"主菜单执行时发生错误: {e}")
+            logging.debug(traceback.format_exc())
+            print(f"\n执行操作时发生错误，请查看日志了解详情。")
+            continue
+
+if __name__ == "__main__":
+    try:
+        main()
+    except KeyboardInterrupt:
+        print("\n\n检测到中断，程序已退出。")
+    except Exception as e:
+        logging.error(f"程序运行时发生未处理的错误: {e}")
+        logging.debug(traceback.format_exc())
+        print(f"\n程序运行时发生未处理的错误，请查看日志了解详情。")

aliyun_controller/modules/__init__.py

@@ -0,0 +1,3 @@
+"""
+Aliyun Controller Modules
+"""

aliyun_controller/modules/billing.py

@@ -0,0 +1,189 @@
+import os
+import yaml
+from pathlib import Path
+from alibabacloud_bssopenapi20171214.client import Client as BssOpenApi20171214Client
+from alibabacloud_bssopenapi20171214.models import DescribeInstanceBillRequest
+from alibabacloud_tea_openapi import models as open_api_models
+
+def load_config():
+    """加载配置文件"""
+    config_dir = os.environ.get('ALIYUN_CONTROLLER_CONFIG_DIR', 
+                               os.path.expanduser('~/.config/aliyun-controller'))
+    config_path = Path(config_dir) / 'config.yaml'
+    example_path = Path(config_dir) / 'config.yaml.example'
+    package_example_path = Path(__file__).parent.parent / 'config.yaml.example'
+    
+    # 检查配置目录是否存在，如果不存在则创建
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # 如果示例文件不存在，则从包中复制
+    if not example_path.exists() and package_example_path.exists():
+        import shutil
+        shutil.copy(package_example_path, example_path)
+    
+    # 如果配置文件不存在，则报错退出
+    if not config_path.exists():
+        print("配置文件不存在，请参考 config.yaml.example 创建 config.yaml 文件")
+        raise FileNotFoundError(f"配置文件不存在: {config_path}")
+    
+    with open(config_path, 'r', encoding='utf-8') as f:
+        return yaml.safe_load(f)
+
+class AliCloudBssQuerier:
+    def __init__(self):
+        """
+        初始化客户端
+        """
+        config = load_config()
+        self.client = BssOpenApi20171214Client(
+            open_api_models.Config(
+                access_key_id=config['access_key_id'],
+                access_key_secret=config['access_key_secret'],
+                region_id="cn-hangzhou",
+            )
+        )
+
+    def fetch_bill_details(self, billing_cycle: str, subscription_type: str) -> list:
+        """
+        根据指定的账单类型，分页获取所有账单明细。
+        """
+        all_items = []
+        next_token = None
+        try:
+            while True:
+                request = DescribeInstanceBillRequest(
+                    billing_cycle=billing_cycle,
+                    subscription_type=subscription_type,
+                    is_billing_item=True,
+                    max_results=300
+                )
+                if next_token:
+                    request.next_token = next_token
+
+                response = self.client.describe_instance_bill(request)
+                
+                response_dict = response.body.to_map()
+                data = response_dict.get('Data', {})
+                if not data:
+                    break
+                
+                items_list = data.get('Items', [])
+                all_items.extend(items_list)
+                
+                next_token = data.get('NextToken')
+                if not next_token:
+                    break
+            
+            return all_items
+
+        except Exception as e:
+            print(f"\n查询 [{subscription_type}] 类型账单时出错: {e}")
+            return []
+
+    def fetch_all_bill_details(self, billing_cycle: str) -> list:
+        """
+        获取所有类型的账单明细（PayAsYouGo + Subscription）
+        """
+        all_items = []
+        all_items.extend(self.fetch_bill_details(billing_cycle, 'PayAsYouGo'))
+        all_items.extend(self.fetch_bill_details(billing_cycle, 'Subscription'))
+        return all_items
+
+    def convert_usage_to_bytes(self, usage: float, unit: str) -> float:
+        """
+        将用量转换为字节
+        """
+        unit = unit.upper()
+        if unit == 'GB':
+            return usage * 1024 * 1024 * 1024
+        elif unit == 'MB':
+            return usage * 1024 * 1024
+        elif unit == 'KB':
+            return usage * 1024
+        else:
+            return usage
+
+def get_outbound_traffic_module(billing_cycle: str):
+    """
+    流量查询模块
+    """
+    querier = AliCloudBssQuerier()
+    total_usage_bytes = 0.0
+
+    TRAFFIC_ITEMS_CODES = [
+        "ECS_Out_Bytes",
+        "Eip_Out_Bytes",
+        "Cdn_domestic_flow",
+        "Cdn_overseas_flow",
+        "OSS_Out_Traffic",
+    ]
+
+    print(f"\n正在查询账单周期 {billing_cycle} 的账单明细...")
+    
+    all_items = querier.fetch_all_bill_details(billing_cycle)
+    
+    if not all_items:
+        print("未发现任何账单明细。")
+        return
+
+    print("账单明细获取成功，开始计算总流量...")
+    for item in all_items:
+        if item.get('BillingItemCode') in TRAFFIC_ITEMS_CODES:
+            usage_str = item.get('Usage')
+            unit = (item.get('UsageUnit') or '').upper()
+            if usage_str:
+                try:
+                    usage = float(usage_str)
+                    if usage > 0:
+                        usage_bytes = querier.convert_usage_to_bytes(usage, unit)
+                        total_usage_bytes += usage_bytes
+                except ValueError:
+                    continue
+    
+    total_traffic_gb = total_usage_bytes / (1024 * 1024 * 1024)
+    print("\n" + "="*45)
+    print(f"账单周期 {billing_cycle} 的总公网流出流量: {total_traffic_gb:.4f} GB")
+    print("="*45)
+
+def summarize_billing_module(billing_cycle: str):
+    """
+    当月完整账单归纳模块
+    """
+    querier = AliCloudBssQuerier()
+    summary = {}
+
+    print(f"\n正在获取账单周期 {billing_cycle} 的所有账单明细...")
+    all_items = querier.fetch_all_bill_details(billing_cycle)
+
+    if not all_items:
+        print("未发现任何账单明细。")
+        return
+
+    for item in all_items:
+        product_code = item.get('ProductCode', 'Unknown')
+        product_name = item.get('ProductName', 'Unknown')
+        amount = float(item.get('PretaxAmount', 0.0))
+        if product_code not in summary:
+            summary[product_code] = {'product_name': product_name, 'total_amount': 0.0, 'count': 0}
+        summary[product_code]['product_name'] = product_name  # 更新产品名称（同一产品代码可能有多个名称，取最后一个）
+        summary[product_code]['total_amount'] += amount
+        summary[product_code]['count'] += 1
+
+    # 按金额从大到小排序
+    sorted_summary = sorted(summary.items(), key=lambda x: x[1]['total_amount'], reverse=True)
+
+    print("\n" + "="*70)
+    print(f"账单周期 {billing_cycle} 消费归纳".center(70))
+    print("="*70)
+    print(f"{'产品名称':<25} {'产品代码':<15} {'账单条数':<10} {'总金额 (元)':<15}")
+    print("-"*70)
+    
+    total_amount = 0.0
+    for product_code, data in sorted_summary:
+        total_amount += data['total_amount']
+        product_name = data['product_name'][:24]  # 截断过长的产品名称
+        print(f"{product_name:<25} {product_code:<15} {data['count']:<10} {data['total_amount']:<15.2f}")
+
+    print("-"*70)
+    print(f"总计: {total_amount:.2f} 元".rjust(70))
+    print("="*70)

aliyun_controller/modules/dns.py

@@ -0,0 +1,520 @@
+import os
+import re
+import yaml
+from pathlib import Path
+from InquirerPy.resolver import prompt
+from InquirerPy.base.control import Choice
+from alibabacloud_tea_openapi import models as open_api_models
+from alibabacloud_alidns20150109.client import Client as Alidns20150109Client
+from alibabacloud_alidns20150109 import models as alidns_20150109_models
+
+def load_config():
+    """加载配置文件"""
+    config_dir = os.environ.get('ALIYUN_CONTROLLER_CONFIG_DIR', 
+                               os.path.expanduser('~/.config/aliyun-controller'))
+    config_path = Path(config_dir) / 'config.yaml'
+    example_path = Path(config_dir) / 'config.yaml.example'
+    package_example_path = Path(__file__).parent.parent / 'config.yaml.example'
+    
+    # 检查配置目录是否存在，如果不存在则创建
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    # 如果示例文件不存在，则从包中复制
+    if not example_path.exists() and package_example_path.exists():
+        import shutil
+        shutil.copy(package_example_path, example_path)
+    
+    # 如果配置文件不存在，则报错退出
+    if not config_path.exists():
+        print("配置文件不存在，请参考 config.yaml.example 创建 config.yaml 文件")
+        raise FileNotFoundError(f"配置文件不存在: {config_path}")
+    
+    with open(config_path, 'r', encoding='utf-8') as f:
+        return yaml.safe_load(f)
+
+class AliCloudDnsQuerier:
+    def __init__(self):
+        """
+        初始化DNS客户端
+        """
+        config = load_config()
+        self.client = Alidns20150109Client(
+            open_api_models.Config(
+                access_key_id=config['access_key_id'],
+                access_key_secret=config['access_key_secret'],
+                endpoint="dns.aliyuncs.com",
+            )
+        )
+
+    def get_domains(self) -> list:
+        """
+        获取所有可管理的域名列表
+        """
+        request = alidns_20150109_models.DescribeDomainsRequest()
+        try:
+            response = self.client.describe_domains(request)
+            return response.body.to_map().get('Domains', {}).get('Domain', [])
+        except Exception as e:
+            print(f"\n获取域名列表时出错: {e}")
+            return []
+
+    def get_domain_records(self, domain_name: str) -> list:
+        """
+        获取指定域名的所有解析记录
+        """
+        all_records = []
+        page_number = 1
+        page_size = 500
+        try:
+            while True:
+                request = alidns_20150109_models.DescribeDomainRecordsRequest(
+                    domain_name=domain_name,
+                    page_number=page_number,
+                    page_size=page_size
+                )
+                response = self.client.describe_domain_records(request)
+                response_dict = response.body.to_map()
+                records = response_dict.get('DomainRecords', {}).get('Record', [])
+                if not records:
+                    break
+                all_records.extend(records)
+                total_count = response_dict.get('TotalCount')
+                if len(all_records) >= total_count:
+                    break
+                page_number += 1
+            return all_records
+        except Exception as e:
+            print(f"\n获取域名 {domain_name} 的解析记录时出错: {e}")
+            return []
+
+    def add_domain_record(self, domain_name: str, rr: str, type: str, value: str, ttl: int = 600) -> bool:
+        """
+        添加新的解析记录
+        """
+        # 验证输入参数
+        if not self._validate_dns_record(rr, type, value, ttl):
+            return False
+            
+        request = alidns_20150109_models.AddDomainRecordRequest(
+            domain_name=domain_name,
+            rr=rr,
+            type=type,
+            value=value,
+            ttl=ttl
+        )
+        try:
+            self.client.add_domain_record(request)
+            print(f"\n成功添加解析记录: {rr}.{domain_name} -> {value}")
+            return True
+        except Exception as e:
+            print(f"\n添加解析记录时出错: {e}")
+            return False
+
+    def update_domain_record(self, record_id: str, rr: str, type: str, value: str, ttl: int = 600) -> bool:
+        """
+        更新现有的解析记录
+        """
+        # 验证输入参数
+        if not self._validate_dns_record(rr, type, value, ttl):
+            return False
+            
+        request = alidns_20150109_models.UpdateDomainRecordRequest(
+            record_id=record_id,
+            rr=rr,
+            type=type,
+            value=value,
+            ttl=ttl
+        )
+        try:
+            self.client.update_domain_record(request)
+            print(f"\n成功更新解析记录 (ID: {record_id})")
+            return True
+        except Exception as e:
+            print(f"\n更新解析记录时出错: {e}")
+            return False
+
+    def delete_domain_record(self, record_id: str) -> bool:
+        """
+        删除解析记录
+        """
+        request = alidns_20150109_models.DeleteDomainRecordRequest(
+            record_id=record_id
+        )
+        try:
+            self.client.delete_domain_record(request)
+            print(f"\n成功删除解析记录 (ID: {record_id})")
+            return True
+        except Exception as e:
+            print(f"\n删除解析记录时出错: {e}")
+            return False
+
+    def _validate_dns_record(self, rr: str, type: str, value: str, ttl: int) -> bool:
+        """
+        验证DNS记录参数的合法性
+        """
+        # 验证主机记录
+        if not rr or len(rr) > 253:
+            print("\n主机记录不能为空且长度不能超过253个字符")
+            return False
+            
+        # 验证记录类型
+        valid_types = ['A', 'CNAME', 'MX', 'TXT', 'SRV', 'AAAA', 'NS', 'ANAME']
+        if type.upper() not in valid_types:
+            print(f"\n不支持的记录类型: {type}")
+            return False
+            
+        # 验证记录值
+        if not value:
+            print("\n记录值不能为空")
+            return False
+            
+        # 验证TTL (60-86400秒)
+        if not (60 <= ttl <= 86400):
+            print("\nTTL值必须在60-86400之间")
+            return False
+            
+        # 针对不同类型的记录进行额外验证
+        if type.upper() == 'A':
+            # IPv4地址验证
+            if not re.match(r'^(\d{1,3}\.){3}\d{1,3}$', value):
+                print("\nA记录的值必须是有效的IPv4地址")
+                return False
+            parts = value.split('.')
+            if any(int(part) > 255 for part in parts):
+                print("\nA记录的值必须是有效的IPv4地址")
+                return False
+        elif type.upper() == 'AAAA':
+            # IPv6地址验证（简单验证）
+            if not re.match(r'^[0-9a-fA-F:]+$', value):
+                print("\nAAAA记录的值必须是有效的IPv6地址")
+                return False
+        elif type.upper() == 'CNAME':
+            # CNAME验证（简单验证）
+            if not re.match(r'^[a-zA-Z0-9.-]+$', value):
+                print("\nCNAME记录的值格式不正确")
+                return False
+            if value.endswith('.'):
+                print("\nCNAME记录的值不能以点结尾")
+                return False
+                
+        return True
+
+    def sort_records(self, records: list, sort_type: int, sort_order: int) -> list:
+        """
+        对DNS记录进行排序
+        :param records: DNS记录列表
+        :param sort_type: 排序类型 (0-创建时间, 1-二级域名, 2-首字母)
+        :param sort_order: 排序顺序 (0-逆序, 1-正序)
+        :return: 排序后的记录列表
+        """
+        if sort_type == 0:
+            # 按创建时间排序 (默认就是按创建时间排序)
+            if sort_order == 0:  # 逆序
+                records.reverse()
+        elif sort_type == 1:
+            # 按二级域名字母排序
+            records.sort(
+                key=lambda r: r.get('RR', '').split('.')[-1] if '.' in r.get('RR', '') else r.get('RR', ''),
+                reverse=(sort_order == 0)
+            )
+        elif sort_type == 2:
+            # 按首字母排序
+            records.sort(
+                key=lambda r: r.get('RR', ''),
+                reverse=(sort_order == 0)
+            )
+        return records
+
+def dns_management_module():
+    """
+    DNS解析管理模块
+    """
+    dns_querier = AliCloudDnsQuerier()
+
+    while True: # 循环用于域名选择
+        domains = dns_querier.get_domains()
+        if not domains:
+            print("未能获取到任何域名，请检查您的账户权限或配置。")
+            return
+
+        domain_choices = [
+            Choice(value=domain['DomainName'], name=domain['DomainName']) for domain in domains
+        ]
+        domain_choices.append(Choice(value=None, name="[返回主菜单]"))
+
+        questions = [
+            {
+                "type": "list",
+                "message": "请选择要管理的域名:",
+                "choices": domain_choices,
+                "name": "domain_name",
+            }
+        ]
+
+        result = prompt(questions)
+        if not result: # 用户在域名选择时按 Ctrl+C
+            print("\n操作已取消，返回主菜单。")
+            return
+        
+        selected_domain = result.get("domain_name")
+        if not selected_domain: # 用户选择 [返回主菜单]
+            return
+
+        # 排序设置：类型(0-创建时间, 1-二级域名, 2-首字母) 和 顺序(0-逆序, 1-正序)
+        sort_type = 0  # 默认按创建时间排序
+        sort_order = 0  # 默认逆序
+
+        while True: # 循环用于对选定域名进行操作
+            records = dns_querier.get_domain_records(selected_domain)
+            # 根据排序设置对记录进行排序
+            records = dns_querier.sort_records(records, sort_type, sort_order)
+            
+            # 构建记录选项列表
+            record_choices = []
+            if records:
+                for i, record in enumerate(records):
+                    record_name = f"{record.get('RR'):<20} {record.get('Type'):<10} {record.get('Value'):<30} {record.get('TTL')}"
+                    record_choices.append(Choice(value=i, name=record_name))
+                
+                # 添加分隔线（不可选择）
+                record_choices.append(Choice(value="separator", name="-" * 80, enabled=False))
+            
+            # 添加操作选项
+            sort_type_text = ["创建时间", "二级域名", "首字母"][sort_type]
+            sort_order_text = "逆序" if sort_order == 0 else "正序"
+            record_choices.extend([
+                Choice(value="add", name="新增解析记录"),
+                Choice(value="sort", name=f"排序设置 [{sort_type_text}, {sort_order_text}]"),
+                Choice(value="refresh", name="刷新记录列表"),
+                Choice(value=None, name="[返回域名选择]")
+            ])
+
+            print("\n" + "="*80)
+            print(f"域名 {selected_domain} 的解析记录".center(80))
+            print("="*80)
+            
+            if not records:
+                print("未找到任何解析记录。")
+                print("="*80)
+                # 如果没有记录，只显示添加和返回选项
+                action_choices = [
+                    Choice(value="add", name="新增解析记录"),
+                    Choice(value=None, name="[返回域名选择]")]                
+                action_questions = [
+                    {
+                        "type": "list",
+                        "message": "请选择操作:",
+                        "choices": action_choices,
+                        "name": "dns_action",
+                    }
+                ]
+            else:
+                print(f"{'主机记录(RR)':<20} {'类型':<10} {'记录值(Value)':<30} {'TTL'}")
+                print("--------------------------------------------------------------------------------")
+                action_questions = [
+                    {
+                        "type": "list",
+                        "message": "请选择要操作的记录或操作:",
+                        "choices": record_choices,
+                        "name": "dns_action",
+                    }
+                ]
+            
+            action_result = prompt(action_questions)
+            if not action_result: # 用户在操作选择时按 Ctrl+C
+                print("\n操作已取消，返回域名选择。")
+                break # 退出操作循环，返回域名选择
+
+            dns_action = action_result.get("dns_action")
+            if not dns_action: # 用户选择 [返回域名选择]
+                break
+
+            # 处理记录选择
+            if isinstance(dns_action, int) and 0 <= dns_action < len(records):
+                selected_record = records[dns_action]
+                
+                # 为选中的记录提供编辑/删除选项
+                record_action_questions = [
+                    {
+                        "type": "list",
+                        "message": f"对记录 {selected_record.get('RR')}.{selected_domain} ({selected_record.get('Type')}: {selected_record.get('Value')}) 执行操作:",
+                        "choices": [
+                            Choice("edit", "编辑记录"),
+                            Choice("delete", "删除记录"),
+                            Choice(value=None, name="[取消]")
+                        ],
+                        "name": "record_action",
+                    }
+                ]
+                
+                record_action_result = prompt(record_action_questions)
+                if not record_action_result:
+                    print("\n操作已取消，返回记录列表。")
+                    continue
+                    
+                record_action = record_action_result.get("record_action")
+                if not record_action:
+                    print("\n操作已取消，返回记录列表。")
+                    continue
+
+                if record_action == "edit":
+                    print(f"\n您正在编辑以下记录:")
+                    print(f"  主机记录 (RR): {selected_record.get('RR')}")
+                    print(f"  记录类型 (Type): {selected_record.get('Type')}")
+                    print(f"  记录值 (Value): {selected_record.get('Value')}")
+                    print(f"  TTL: {selected_record.get('TTL')}")
+
+                    update_fields_questions = [
+                        {"type": "input", "message": f"新的主机记录 (当前: {selected_record.get('RR')}, 留空则不修改):", "name": "rr", "default": selected_record.get('RR')},
+                        {"type": "input", "message": f"新的记录类型 (当前: {selected_record.get('Type')}, 留空则不修改):", "name": "type", "default": selected_record.get('Type')},
+                        {"type": "input", "message": f"新的记录值 (当前: {selected_record.get('Value')}, 留空则不修改):", "name": "value", "default": selected_record.get('Value')},
+                        {"type": "input", "message": f"新的TTL (当前: {selected_record.get('TTL')}, 留空则不修改):", "name": "ttl", "default": str(selected_record.get('TTL'))},
+                    ]
+                    update_answers = prompt(update_fields_questions)
+                    if not update_answers:
+                        print("\n操作已取消，返回记录列表。")
+                        continue
+
+                    # 只有当用户输入了新值时才使用新值，否则保留原值
+                    rr = update_answers.get('rr') or selected_record.get('RR')
+                    type_val = (update_answers.get('type') or selected_record.get('Type')).upper()
+                    value = update_answers.get('value') or selected_record.get('Value')
+                    ttl = int(update_answers.get('ttl') or selected_record.get('TTL'))
+
+                    dns_querier.update_domain_record(
+                        record_id=selected_record.get('RecordId'),
+                        rr=rr,
+                        type=type_val,
+                        value=value,
+                        ttl=ttl
+                    )
+
+                elif record_action == "delete":
+                    full_record_name = f"{selected_record.get('RR')}.{selected_domain}"
+                    confirmation_question = [
+                        {
+                            "type": "confirm",
+                            "message": f"确定要删除解析记录 {full_record_name} (类型: {selected_record.get('Type')}, 值: {selected_record.get('Value')}) 吗?",
+                            "default": False,
+                            "name": "confirm_delete",
+                        }
+                    ]
+                    confirmation_result = prompt(confirmation_question)
+                    if not confirmation_result:
+                        print("\n操作已取消，返回记录列表。")
+                        continue
+                    
+                    if confirmation_result.get("confirm_delete"):
+                        dns_querier.delete_domain_record(selected_record.get('RecordId'))
+                    else:
+                        print("删除操作已取消。")
+                
+                # 继续显示记录列表
+                continue
+
+            # 处理其他操作
+            if dns_action == "add":
+                add_questions = [
+                    {"type": "input", "message": "主机记录 (例如 www):", "name": "rr"},
+                    {"type": "input", "message": "记录类型 (例如 A, CNAME):", "name": "type"},
+                    {"type": "input", "message": "记录值:", "name": "value"},
+                    {"type": "input", "message": "TTL (默认 600):", "name": "ttl", "default": "600"},
+                ]
+                add_answers = prompt(add_questions)
+                if not add_answers:
+                    print("\n操作已取消，返回记录列表。")
+                    continue
+                
+                if not all(add_answers.get(k) for k in ['rr', 'type', 'value']):
+                    print("\n缺少必要信息，操作取消。")
+                    continue
+                
+                # TTL 是可选的，如果用户没输入，则使用默认值
+                ttl_value = add_answers.get('ttl')
+                if not ttl_value or not ttl_value.isdigit():
+                    ttl_value = 600
+                else:
+                    ttl_value = int(ttl_value)
+
+                dns_querier.add_domain_record(
+                    domain_name=selected_domain,
+                    rr=add_answers['rr'],
+                    type=add_answers['type'].upper(),
+                    value=add_answers['value'],
+                    ttl=ttl_value
+                )
+
+            elif dns_action == "sort":
+                # 进入排序设置子页面
+                # 保存当前设置以防用户取消操作
+                prev_sort_type = sort_type
+                prev_sort_order = sort_order
+                
+                # 创建排序设置界面
+                sort_type_choices = [
+                    Choice(0, "创建时间排序"),
+                    Choice(1, "二级域名排序"),
+                    Choice(2, "首字母排序")
+                ]
+                
+                sort_order_choices = [
+                    Choice(0, "逆序"),
+                    Choice(1, "正序")
+                ]
+                
+                # 显示当前选择
+                print("\n" + "="*50)
+                print("排序设置".center(50))
+                print("="*50)
+                print(f"当前设置: {['创建时间', '二级域名', '首字母'][sort_type]}, {'逆序' if sort_order == 0 else '正序'}")
+                print("="*50)
+                
+                # 选择排序类型
+                sort_type_question = [
+                    {
+                        "type": "list",
+                        "message": "请选择排序类型:",
+                        "choices": sort_type_choices,
+                        "default": sort_type,
+                        "name": "sort_type"
+                    }
+                ]
+                
+                sort_type_result = prompt(sort_type_question)
+                if not sort_type_result or sort_type_result.get("sort_type") is None:
+                    # 恢复原设置并返回
+                    sort_type = prev_sort_type
+                    sort_order = prev_sort_order
+                    continue
+                    
+                new_sort_type = sort_type_result.get("sort_type")
+                
+                # 选择排序顺序
+                sort_order_question = [
+                    {
+                        "type": "list",
+                        "message": "请选择排序顺序:",
+                        "choices": sort_order_choices,
+                        "default": sort_order,
+                        "name": "sort_order"
+                    }
+                ]
+                
+                sort_order_result = prompt(sort_order_question)
+                if not sort_order_result or sort_order_result.get("sort_order") is None:
+                    # 恢复原设置并返回
+                    sort_type = prev_sort_type
+                    sort_order = prev_sort_order
+                    continue
+                    
+                new_sort_order = sort_order_result.get("sort_order")
+                
+                # 更新排序设置并直接返回主列表
+                sort_type = new_sort_type
+                sort_order = new_sort_order
+                print(f"\n排序设置已更新为: {['创建时间', '二级域名', '首字母'][sort_type]}, {'逆序' if sort_order == 0 else '正序'}")
+                print("正在返回DNS记录列表...")
+
+            elif dns_action == "refresh":
+                # 刷新操作，直接继续循环
+                continue

aliyun_controller-0.1.0.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: aliyun-controller
+Version: 0.1.0
+Summary: A command-line tool for managing Alibaba Cloud services including billing queries and DNS management
+Author-email: Moha-Master <hongkongreporter@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Moha-Master/Aliyun-Controller
+Project-URL: Repository, https://github.com/Moha-Master/Aliyun-Controller
+Project-URL: Issues, https://github.com/Moha-Master/Aliyun-Controller/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: alibabacloud-ecs20140526
+Requires-Dist: alibabacloud-bssopenapi20171214
+Requires-Dist: alibabacloud-alidns20150109
+Requires-Dist: InquirerPy
+Requires-Dist: PyYAML
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+
+# 阿里云控制台工具 (aliyun-controller)
+
+这是一个调用阿里云 Python SDK 在命令行中执行常用操作的简单工具，目前具有账单查询和 DNS 管理功能。
+
+## 功能特性
+
+- **账单查询**：查询指定月份的阿里云账单总额和明细
+- **流量统计**：查询指定月份的公网流出流量总量
+- **DNS 管理**：管理域名解析记录，包括增删改查操作
+
+## 后续计划
+
+- 加入**ECS控制**的相关内容
+- 加入**OOS控制**的相关内容
+
+## 安装指南
+
+### 通过 pip 安装（推荐）
+
+可以通过 pip 直接安装：
+
+```bash
+pip install aliyun-controller
+```
+
+安装后，可以直接使用 `aliyunctl` 命令运行程序：
+
+```bash
+aliyunctl
+```
+
+### 从源码运行（开发模式）
+
+如果你希望进行二次开发或修改源码，可以从源码安装：
+
+1. 克隆此项目到本地：
+   ```bash
+   git clone <项目地址>
+   cd aliyun-controller
+   ```
+
+2. 创建虚拟环境（推荐）：
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # Linux/Mac
+   # 或在 Windows 上: venv\Scripts\activate
+   ```
+
+3. 安装依赖：
+   ```bash
+   pip install -e .
+   ```
+
+4. 创建阿里云 RAM 用户并授权：
+  - 登录阿里云控制台。
+  - 进入 RAM 访问控制。
+  - 在左侧导航栏选择 用户 > 创建用户。
+  - 设置登录名称和显示名称，勾选 为该用户自动生成AccessKey。
+  - 创建成功后，请务必保存好 AccessKey ID 和 AccessKey Secret，它们只显示一次。
+  - 为新创建的 RAM 用户授权：
+    - 在用户详情页，点击 添加权限。
+    - 选择 AliyunBSSReadOnlyAccess 和 AliyunDNSFullAccess 权限。
+    - 点击 确定 完成授权。
+
+5. 配置阿里云访问密钥：
+   默认情况下，程序会在 `~/.configs/aliyun-controller` 目录下查找配置文件。
+   你可以复制示例配置文件并修改：
+   ```bash
+   mkdir -p ~/.configs/aliyun-controller
+   cp config.yaml.example ~/.configs/aliyun-controller/config.yaml
+   ```
+   然后编辑 `~/.configs/aliyun-controller/config.yaml` 文件，填入你创建的阿里云RAM用户的 AccessKey ID 和 AccessKey Secret：
+   ```yaml
+   access_key_id: your_access_key_id
+   access_key_secret: your_access_key_secret
+   ```
+   
+   你也可以使用 `--dir/-D` 参数指定配置文件所在的目录：
+   ```bash
+   aliyunctl -D /path/to/your/config/dir
+   ```
+
+## 使用方法
+
+安装后，可以直接使用 `aliyunctl` 命令运行程序：
+
+```bash
+aliyunctl
+```
+
+程序将显示交互式菜单，你可以选择以下功能：
+
+1. **查询总流出流量**：查看指定月份的公网总流出流量
+2. **归纳账单**：查看指定月份的账单明细和总额
+3. **DNS解析管理**：管理域名解析记录
+
+你也可以使用 `--dir/-D` 参数指定配置文件所在的目录：
+
+```bash
+aliyunctl -D /path/to/your/config/dir
+```
+
+### 账单查询
+
+- 程序会默认查询当前月份的账单
+- 你也可以输入其他月份（格式：YYYY-MM / YYYY-M）进行查询
+- 支持分页查询和重新查询
+
+### DNS 管理
+
+- 选择要管理的域名
+- 查看所有解析记录
+- 添加、编辑或删除解析记录
+- 支持按不同方式排序记录（创建时间、二级域名、首字母）
+
+## 权限要求
+
+为了正常使用所有功能，你的阿里云 RAM 用户记得开放以下权限：
+
+- `AliyunBSSReadOnlyAccess`：用于账单查询
+- `AliyunDNSFullAccess`：用于 DNS 管理
+
+## 日志记录
+
+程序会在运行目录下生成 `app.log` 文件，记录操作日志和错误信息。

aliyun_controller-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+aliyun_controller/__init__.py,sha256=CcvZiNQXl0DTdvwra209gPf7K0t-ejcyUdYCUPHVzY4,48
+aliyun_controller/config.yaml.example,sha256=Oq4EAx-yBKjgGoi79B4JHvpmP9t67tdcHeXLYvtxv4g,173
+aliyun_controller/main.py,sha256=d0F7WXeV4CIopMh3gaBICwosy9ywwpxftk3zDUFH-Eg,6602
+aliyun_controller/modules/__init__.py,sha256=ez9ziiPd-7wzYgWpSnce0CzZiP-VMzgIKAAHAufk_VI,34
+aliyun_controller/modules/billing.py,sha256=fjy16lZr40CyzVu4YwAEACtYX76YowXwi-yKvyewoF4,6869
+aliyun_controller/modules/dns.py,sha256=Sou-o-oc62UbXhjFXQxPzb41quHnSB50OhsbbF4EUXk,22167
+aliyun_controller-0.1.0.dist-info/METADATA,sha256=gqch9rbcWYnVhYsLyEwfo7Y00iCihkpIV_4qmfOfagE,4811
+aliyun_controller-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aliyun_controller-0.1.0.dist-info/entry_points.txt,sha256=ciHGtsRR00gd8T1Rcpk4U-uOLp3n0zPCOjnCKCHpgBM,58
+aliyun_controller-0.1.0.dist-info/top_level.txt,sha256=1J-5DktJasn2lfRPGM-FoV-kjHHBZTRFwRAWT_uLRyg,18
+aliyun_controller-0.1.0.dist-info/RECORD,,

aliyun_controller-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aliyun_controller-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aliyunctl = aliyun_controller.main:main

aliyun_controller-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+aliyun_controller