yearning-cli 0.1.5__py3-none-any.whl

mysql_proxy/server.py

@@ -0,0 +1,661 @@
+"""MySQL protocol proxy server — bridges MySQL clients to Yearning."""
+
+import hashlib
+import logging
+import os
+import random
+import socket
+import sys
+import threading
+import time
+
+# Add parent dir to path so we can import yearning_cli
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from yearning_cli.client import (
+    STATE_FILE,
+    TokenExpiredError,
+    YearningClient,
+    read_state,
+    write_state,
+)
+
+from mysql_proxy.protocol import (
+    DEFAULT_CAPABILITIES,
+    make_err,
+    make_handshake,
+    make_ok,
+    make_result_set,
+    make_result_header,
+    stream_rows,
+    parse_handshake_response,
+    parse_packet,
+)
+
+logger = logging.getLogger("mysql_proxy")
+
+
+class ConnectionHandler:
+    """Handle a single MySQL client connection."""
+
+    _conn_id_counter = 0
+    _lock = threading.Lock()
+    _cache_lock = threading.Lock()
+    _source_cache = {}
+    _query_order_cache = {}
+    SOURCE_CACHE_TTL = 60
+    QUERY_ORDER_TTL = 600
+
+    def __init__(self, conn: socket.socket, addr, config: dict):
+        self.conn = conn
+        self.addr = addr
+        self.config = config
+        self.connection_id = self._next_id()
+        self.salt = bytes(random.getrandbits(8) for _ in range(20))
+        self.authenticated = False
+        self.current_db = config.get("database", "")
+        self.source_id = config.get("source_id", "")
+        self.source_name = config.get("source_name", "")
+        self.yearning = None
+        self.buffer = b""
+        # Socket tuning: disable Nagle's algorithm for lower latency
+        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        # Increase send buffer for large result sets
+        try:
+            conn.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 256 * 1024)
+        except OSError:
+            pass
+        # Set a generous socket timeout to avoid premature disconnects
+        conn.settimeout(300)
+
+    @classmethod
+    def _next_id(cls):
+        with cls._lock:
+            cls._conn_id_counter += 1
+            return cls._conn_id_counter
+
+    def run(self):
+        """Main connection loop."""
+        try:
+            self._handshake()
+            if not self.authenticated:
+                return
+            self._command_loop()
+        except (ConnectionResetError, BrokenPipeError):
+            logger.info("Client disconnected: %s", self.addr)
+        except OSError as e:
+            logger.info("Connection error %s: %s", self.addr, e)
+        except Exception as e:
+            logger.error("Connection error %s: %s", self.addr, e)
+        finally:
+            try:
+                self.conn.close()
+            except Exception:
+                pass
+
+    def _send(self, data: bytes):
+        try:
+            self.conn.sendall(data)
+        except (ConnectionResetError, BrokenPipeError, OSError) as e:
+            logger.warning("Send failed, client may have disconnected: %s", e)
+            raise
+
+    def _recv(self, n=4096) -> bytes:
+        return self.conn.recv(n)
+
+    def _read_packet(self) -> bytes:
+        """Read a complete MySQL packet, handling buffering."""
+        while True:
+            if len(self.buffer) >= 4:
+                length = int.from_bytes(self.buffer[:3], "little")
+                if len(self.buffer) >= 4 + length:
+                    payload = self.buffer[4 : 4 + length]
+                    self.buffer = self.buffer[4 + length :]
+                    return payload
+            chunk = self._recv(8192)
+            if not chunk:
+                raise ConnectionResetError("Client closed connection")
+            self.buffer += chunk
+
+    def _handshake(self):
+        """Perform MySQL handshake."""
+        # Send initial handshake
+        handshake = make_handshake(self.connection_id, self.salt)
+        self._send(handshake)
+
+        # Read client response
+        payload = self._read_packet()
+        username, auth_response, database = parse_handshake_response(payload)
+
+        if database:
+            self.current_db = database
+
+        # Use username as source name for data source switching
+        # No password verification — any user/password accepted
+        self.source_name = username if username else ""
+
+        # Auth OK
+        self.authenticated = True
+        logger.info("Authenticated: user=%s (source=%s) db=%s from=%s",
+                     username, self.source_name, self.current_db, self.addr)
+        self._send(make_ok(message="Connected to Yearning proxy", seq=2))
+
+    def _init_yearning(self):
+        """Initialize Yearning client and resolve the selected source."""
+        if self.yearning:
+            return
+
+        base_url = self.config.get("base_url", "http://192.168.1.135")
+        self.yearning = YearningClient(base_url)
+        try:
+            self.yearning.ensure_authenticated()
+        except TokenExpiredError as e:
+            logger.error("Yearning authentication failed: %s", e)
+            return
+
+        # Fast path: when the source is already an ID, avoid fetching the full
+        # source list for the common fallback user.
+        config_source = self.config.get("source_name", "") or self.config.get("source_id", "")
+        if self.source_name and self._looks_like_source_id(self.source_name):
+            self.source_id = self.source_name
+            logger.info("Using Yearning source %s", self.source_id[:12])
+            return
+        if config_source and self._looks_like_source_id(config_source) and self.source_name in ("", "root"):
+            self.source_id = config_source
+            logger.info("Using Yearning source %s", self.source_id[:12])
+            return
+
+        # Fetch all available sources. GUI clients often open several MySQL
+        # connections, so keep this metadata briefly in process.
+        sources = self._list_sources_cached()
+        source_name_to_id = {src.get("source"): src["source_id"] for src in sources}
+
+        # Default source from config (could be name or ID)
+        default_source_id = ""
+        if config_source:
+            # Check if it's a source name
+            if config_source in source_name_to_id:
+                default_source_id = source_name_to_id[config_source]
+            else:
+                # Assume it's already a source ID
+                default_source_id = config_source
+
+        # If username was provided, try to resolve it as a source name
+        if self.source_name:
+            if self.source_name in source_name_to_id:
+                self.source_id = source_name_to_id[self.source_name]
+                logger.info("Resolved username '%s' -> source %s", self.source_name, self.source_id[:12])
+            else:
+                # Fallback to default config source
+                self.source_id = default_source_id
+                logger.info("Username '%s' not found as source, falling back to default %s",
+                            self.source_name, self.source_id[:12] if self.source_id else "NONE")
+        else:
+            # No username, use default
+            self.source_id = default_source_id
+
+        if self.source_id:
+            logger.info("Using Yearning source %s", self.source_id[:12])
+
+    def _ensure_yearning_initialized(self):
+        if not self.yearning:
+            self._init_yearning()
+        return self.yearning and self.yearning.token
+
+    def _ensure_query_order(self):
+        if not self._ensure_yearning_initialized() or not self.source_id:
+            return False
+
+        if self._has_recent_query_order():
+            logger.debug("Using recent Yearning query order for source %s", self.source_id[:12])
+            return True
+
+        logger.info("Creating Yearning query order for source %s", self.source_id[:12])
+        if self.yearning.create_query_order(self.source_id, verify_wait=0.1):
+            self._mark_query_order_ready()
+            return True
+
+        return False
+
+    @staticmethod
+    def _looks_like_source_id(value: str):
+        return len(value) > 30 and "-" in value
+
+    def _cache_key(self, *parts):
+        token = self.yearning.token if self.yearning else ""
+        return (self.config.get("base_url", "http://192.168.1.135"), token, *parts)
+
+    def _list_sources_cached(self):
+        key = self._cache_key("sources")
+        now = time.monotonic()
+        with self._cache_lock:
+            entry = self._source_cache.get(key)
+            if entry and entry["expires_at"] > now:
+                return entry["sources"]
+
+        sources = self.yearning.list_sources()
+        with self._cache_lock:
+            self._source_cache[key] = {
+                "sources": sources,
+                "expires_at": now + self.SOURCE_CACHE_TTL,
+            }
+        return sources
+
+    def _query_order_key(self):
+        return self._cache_key("query_order", self.source_id)
+
+    def _query_order_disk_key(self):
+        raw = "|".join(str(part) for part in self._query_order_key())
+        return hashlib.sha256(raw.encode("utf-8")).hexdigest()
+
+    def _has_recent_query_order(self):
+        key = self._query_order_key()
+        now = time.monotonic()
+        with self._cache_lock:
+            expires_at = self._query_order_cache.get(key, 0)
+            if expires_at > now:
+                return True
+
+        disk_expires_at = self._read_query_order_disk_cache().get(self._query_order_disk_key(), 0)
+        remaining = disk_expires_at - time.time()
+        if remaining > 0:
+            with self._cache_lock:
+                self._query_order_cache[key] = time.monotonic() + min(
+                    remaining,
+                    self.QUERY_ORDER_TTL,
+                )
+            return True
+
+        return False
+
+    def _mark_query_order_ready(self):
+        key = self._query_order_key()
+        disk_key = self._query_order_disk_key()
+        disk_expires_at = time.time() + self.QUERY_ORDER_TTL
+        with self._cache_lock:
+            self._query_order_cache[key] = time.monotonic() + self.QUERY_ORDER_TTL
+        self._write_query_order_disk_cache(disk_key, disk_expires_at)
+
+    @staticmethod
+    def _read_query_order_disk_cache():
+        data = read_state()
+        now = time.time()
+        entries = data.get("query_orders", {})
+        if not isinstance(entries, dict):
+            return {}
+        return {
+            key: expires_at
+            for key, expires_at in entries.items()
+            if isinstance(key, str)
+            and isinstance(expires_at, (int, float))
+            and expires_at > now
+        }
+
+    @classmethod
+    def _write_query_order_disk_cache(cls, key, expires_at):
+        state = read_state()
+        entries = cls._read_query_order_disk_cache()
+        entries[key] = expires_at
+        state["query_orders"] = entries
+        try:
+            write_state(state)
+        except OSError as e:
+            logger.debug("Failed to write query order cache to %s: %s", STATE_FILE, e)
+
+    def _command_loop(self):
+        """Process client commands."""
+        while True:
+            payload = self._read_packet()
+            if not payload:
+                break
+
+            cmd = payload[0]
+
+            if cmd == 0x03:  # COM_QUERY
+                sql = payload[1:].decode("utf-8", errors="replace").strip()
+                self._handle_query(sql)
+            elif cmd == 0x02:  # COM_INIT_DB (USE database)
+                db = payload[1:].decode("utf-8", errors="replace").strip()
+                self.current_db = db
+                self._send(make_ok(message=f"Changed to database '{db}'"))
+            elif cmd == 0x0E:  # COM_PING
+                self._send(make_ok())
+            elif cmd == 0x01:  # COM_QUIT
+                break
+            elif cmd == 0x00:  # COM_SLEEP / COM_STMT_CLOSE (ignore)
+                pass
+            elif cmd == 0x16:  # COM_STMT_PREPARE (not supported)
+                self._send(make_err(1295, "Prepared statements not supported", "HY000"))
+            elif cmd == 0x17:  # COM_STMT_EXECUTE (not supported)
+                self._send(make_err(1295, "Prepared statements not supported", "HY000"))
+            elif cmd == 0x14:  # COM_STMT_FETCH
+                self._send(make_err(1295, "Prepared statements not supported", "HY000"))
+            elif cmd == 0x19:  # COM_STMT_RESET
+                self._send(make_ok())
+            elif cmd == 0x1A:  # COM_STMT_SEND_LONG_DATA
+                pass
+            elif cmd == 0x04:  # COM_FIELD_LIST
+                self._send(make_err(1105, "COM_FIELD_LIST not supported", "HY000"))
+            elif cmd == 0x09:  # COM_STATISTICS
+                stats = "Uptime: 999999  Threads: 1  Questions: 0  Slow queries: 0"
+                self._send(make_ok(message=stats))
+            else:
+                logger.warning("Unknown command: 0x%02x", cmd)
+                self._send(make_err(1047, f"Unknown command 0x{cmd:02x}", "08S01"))
+
+    def _handle_query(self, sql: str):
+        """Execute SQL via Yearning and return results."""
+        logger.info("Query: %s", sql[:200])
+
+        # Intercept MySQL client initialization commands — return OK without Yearning
+        upper = sql.upper().lstrip()
+        if upper.startswith(("SET ", "SET\t", "SET\n")):
+            self._send(make_ok(message="OK"))
+            return
+        if upper.startswith("SHOW ") and any(
+            kw in upper for kw in ("VARIABLES", "COLLATION", "SESSION", "GLOBAL", "CHARACTER SET", "ENGINES", "PLUGINS", "WARNINGS", "STATUS")
+        ):
+            self._send(make_ok(message="OK"))
+            return
+        if upper.startswith("USE "):
+            db = sql[3:].strip().strip("`\"'")
+            self.current_db = db
+            self._send(make_ok(message=f"Changed to database '{db}'"))
+            return
+        # SELECT @@version, SELECT @@version_comment, etc.
+        if upper.startswith("SELECT @@"):
+            var = upper[7:].strip().split()[0].rstrip(",")
+            val = self._fake_sysvar(var)
+            self._send_simple_result(var, val)
+            return
+        # SELECT DATABASE(), SELECT VERSION(), etc.
+        if upper in ("SELECT DATABASE()", "SELECT DATABASE() ;"):
+            self._send_simple_result("DATABASE()", self.current_db or "NULL")
+            return
+        if upper in ("SELECT VERSION()", "SELECT VERSION() ;"):
+            self._send_simple_result("VERSION()", "8.0.0-proxy")
+            return
+        if upper.startswith("SELECT CONNECTION_ID()"):
+            self._send_simple_result("CONNECTION_ID()", str(self.connection_id))
+            return
+        # SHOW DATABASES / SHOW TABLES
+        if upper in ("SHOW DATABASES", "SHOW DATABASES;"):
+            self._handle_show_databases()
+            return
+        if upper in ("SHOW TABLES", "SHOW TABLES;") or upper.startswith("SHOW TABLES "):
+            self._handle_show_tables()
+            return
+        if upper.startswith("SHOW FULL TABLES"):
+            self._handle_show_tables(full=True)
+            return
+        if upper.startswith("SHOW COLUMNS") or upper.startswith("SHOW FULL COLUMNS"):
+            self._handle_show_columns(sql)
+            return
+        if upper.startswith("DESCRIBE ") or upper.startswith("DESC "):
+            self._handle_describe(sql)
+            return
+
+        self._ensure_yearning_initialized()
+        if not self.yearning or not self.yearning.token:
+            self._send(make_err(1045, "Yearning not authenticated. Run 'sql login' first."))
+            return
+
+        if not self.source_id:
+            self._send(make_err(1046, "No data source configured. Set source_id in config."))
+            return
+
+        if not self.current_db:
+            self._send(make_err(1046, "No database selected"))
+            return
+
+        self._ensure_query_order()
+        try:
+            result = self.yearning.execute_query(self.source_id, self.current_db, sql, timeout=120)
+        except Exception as e:
+            logger.error("Query error: %s", e)
+            self._send(make_err(1105, str(e), "HY000"))
+            return
+
+        if not result["success"]:
+            error_msg = result.get("error", "Unknown error")
+            # If query order expired, try to recreate
+            if "工单" in error_msg or "expired" in error_msg.lower():
+                logger.info("Query order expired, recreating...")
+                try:
+                    if self.yearning.create_query_order(self.source_id, verify_wait=0.1):
+                        self._mark_query_order_ready()
+                    result = self.yearning.execute_query(self.source_id, self.current_db, sql, timeout=120)
+                    if result["success"]:
+                        self._mark_query_order_ready()
+                        self._send_result(result)
+                        return
+                except Exception as e:
+                    error_msg = str(e)
+            self._send(make_err(1105, error_msg, "HY000"))
+            return
+
+        self._mark_query_order_ready()
+        self._send_result(result)
+
+    def _fake_sysvar(self, var: str) -> str:
+        """Return fake system variable values for client compatibility."""
+        var = var.upper().lstrip("@")
+        mapping = {
+            "VERSION": "8.0.0-proxy",
+            "VERSION_COMMENT": "Yearning MySQL Proxy",
+            "VERSION_COMPILE_MACHINE": "x86_64",
+            "VERSION_COMPILE_OS": "Linux",
+            "CHARACTER_SET_CLIENT": "utf8mb4",
+            "CHARACTER_SET_CONNECTION": "utf8mb4",
+            "CHARACTER_SET_RESULTS": "utf8mb4",
+            "COLLATION_CONNECTION": "utf8mb4_general_ci",
+            "AUTOCOMMIT": "1",
+            "SQL_MODE": "",
+            "TIME_ZONE": "+08:00",
+            "SYSTEM_TIME_ZONE": "CST",
+            "TX_ISOLATION": "REPEATABLE-READ",
+            "TRANSACTION_ISOLATION": "REPEATABLE-READ",
+            "MAX_ALLOWED_PACKET": "67108864",
+            "NET_WRITE_TIMEOUT": "60",
+            "WAIT_TIMEOUT": "28800",
+            "INTERACTIVE_TIMEOUT": "28800",
+            "LOWER_CASE_TABLE_NAMES": "0",
+            "PORT": "3307",
+            "BASEDIR": "/",
+            "DATADIR": "/data/",
+            "SOCKET": "/tmp/mysql.sock",
+        }
+        return mapping.get(var, "")
+
+    def _send_simple_result(self, name: str, value: str):
+        """Send a single-column, single-row result."""
+        packets = make_result_set([name], [[value]], seq_start=1)
+        for pkt, _ in packets:
+            self._send(pkt)
+
+    def _handle_show_databases(self):
+        """SHOW DATABASES — list databases from Yearning."""
+        self._ensure_yearning_initialized()
+        if not self.yearning or not self.source_id:
+            self._send(make_err(1046, "No data source configured"))
+            return
+        try:
+            dbs = self.yearning.list_databases(self.source_id)
+            rows = [[db] for db in dbs]
+            packets = make_result_set(["Database"], rows, seq_start=1)
+            for pkt, _ in packets:
+                self._send(pkt)
+        except Exception as e:
+            self._send(make_err(1105, str(e)))
+
+    def _handle_show_tables(self, full=False):
+        """SHOW TABLES — list tables from Yearning."""
+        self._ensure_yearning_initialized()
+        if not self.yearning or not self.source_id or not self.current_db:
+            self._send(make_err(1046, "No database selected"))
+            return
+        try:
+            tables = self.yearning.list_tables(self.source_id, self.current_db)
+            col_name = f"Tables_in_{self.current_db}"
+            if full:
+                rows = [[t, "BASE TABLE"] for t in tables]
+                packets = make_result_set([col_name, "Table_type"], rows, seq_start=1)
+            else:
+                rows = [[t] for t in tables]
+                packets = make_result_set([col_name], rows, seq_start=1)
+            for pkt, _ in packets:
+                self._send(pkt)
+        except Exception as e:
+            self._send(make_err(1105, str(e)))
+
+    def _handle_show_columns(self, sql: str):
+        """SHOW COLUMNS FROM table — execute via Yearning."""
+        self._execute_direct(f"SHOW COLUMNS FROM {sql.split('FROM')[-1].strip()}")
+
+    def _handle_describe(self, sql: str):
+        """DESCRIBE table — execute via Yearning."""
+        parts = sql.split(None, 1)
+        if len(parts) < 2:
+            self._send(make_err(1064, "Syntax error"))
+            return
+        table = parts[1].strip().rstrip(";")
+        self._execute_direct(f"DESCRIBE {table}")
+
+    def _execute_direct(self, sql: str):
+        """Execute SQL directly via Yearning, bypassing command interception."""
+        self._ensure_yearning_initialized()
+        if not self.yearning or not self.yearning.token:
+            self._send(make_err(1045, "Yearning not authenticated"))
+            return
+        if not self.source_id:
+            self._send(make_err(1046, "No data source configured"))
+            return
+        if not self.current_db:
+            self._send(make_err(1046, "No database selected"))
+            return
+        self._ensure_query_order()
+        try:
+            result = self.yearning.execute_query(self.source_id, self.current_db, sql, timeout=120)
+        except Exception as e:
+            self._send(make_err(1105, str(e)))
+            return
+        if not result["success"]:
+            self._send(make_err(1105, result.get("error", "Unknown error")))
+            return
+        self._mark_query_order_ready()
+        self._send_result(result)
+
+    def _send_result(self, result: dict):
+        """Send query result as MySQL result set.
+
+        For small result sets (< 100 rows), build all packets in memory.
+        For large result sets, stream rows one by one to avoid socket buffer
+        issues and memory pressure.
+        """
+        columns = result.get("columns", [])
+        rows = result.get("rows", [])
+
+        if not columns:
+            # DML or empty result
+            msg = f"OK ({result.get('query_time', 0)}ms)"
+            self._send(make_ok(message=msg))
+            return
+
+        # Use streaming for large result sets to avoid "Lost connection" errors
+        STREAM_THRESHOLD = 100
+        if len(rows) > STREAM_THRESHOLD:
+            self._stream_result(columns, rows)
+        else:
+            packets = make_result_set(columns, rows, seq_start=1)
+            for pkt, _ in packets:
+                self._send(pkt)
+
+    def _stream_result(self, columns: list, rows: list):
+        """Stream result set row by row to avoid large memory allocations."""
+        logger.debug("Streaming %d rows", len(rows))
+        # Send header (column count + column defs + EOF)
+        header_packets, next_seq = make_result_header(columns, rows[:1], seq_start=1)
+        for pkt, _ in header_packets:
+            self._send(pkt)
+
+        # Stream rows one by one
+        try:
+            for pkt, _ in stream_rows(columns, rows, seq_start=next_seq):
+                self._send(pkt)
+        except (ConnectionResetError, BrokenPipeError, OSError) as e:
+            logger.warning("Client disconnected during streaming: %s", e)
+            raise
+
+
+def _create_server_socket(host: str, port: int) -> socket.socket:
+    """Create a listening TCP socket for IPv4 or IPv6 hosts."""
+    infos = socket.getaddrinfo(
+        host,
+        port,
+        socket.AF_UNSPEC,
+        socket.SOCK_STREAM,
+        0,
+        socket.AI_PASSIVE,
+    )
+
+    last_error = None
+    for family, socktype, proto, _, sockaddr in infos:
+        server = socket.socket(family, socktype, proto)
+        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+        if family == socket.AF_INET6:
+            try:
+                server.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0)
+            except OSError:
+                logger.debug("Could not enable IPv4-mapped IPv6 sockets", exc_info=True)
+
+        try:
+            server.bind(sockaddr)
+            server.listen(10)
+            return server
+        except OSError as exc:
+            last_error = exc
+            server.close()
+
+    raise last_error or OSError(f"Could not bind MySQL proxy to {host}:{port}")
+
+
+def _client_host_hint(host: str) -> str:
+    if host in ("0.0.0.0", ""):
+        return "127.0.0.1 或本机局域网 IPv4"
+    if host == "::":
+        return "::1 或本机 IPv6"
+    return host
+
+
+def serve(host="0.0.0.0", port=3307, config=None):
+    """Start MySQL proxy server."""
+    if config is None:
+        config = {}
+
+    server = _create_server_socket(host, port)
+
+    logger.info("MySQL proxy listening on %s:%d", host, port)
+    logger.info("  Yearning URL: %s", config.get("base_url", "http://192.168.1.135"))
+    logger.info("  Source: %s", config.get("source_name", config.get("source_id", "N/A")))
+    logger.info("  Database: %s", config.get("database", "N/A"))
+    if config.get("user"):
+        logger.info("  Auth user: %s", config["user"])
+    else:
+        logger.info("  Auth: disabled (accept any credentials)")
+
+    print(f"MySQL proxy 已启动: {host}:{port}")
+    print(f"连接命令: mysql -h {_client_host_hint(host)} -P {port} -u root")
+
+    try:
+        while True:
+            conn, addr = server.accept()
+            logger.info("New connection from %s", addr)
+            handler = ConnectionHandler(conn, addr, config)
+            t = threading.Thread(target=handler.run, daemon=True)
+            t.start()
+    except KeyboardInterrupt:
+        logger.info("Shutting down...")
+        print("\nBye!")
+    finally:
+        server.close()

pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "yearning-cli"
+version = "0.1.5"
+description = "Yearning MySQL Audit Platform CLI Tool"
+readme = "README.md"
+authors = [
+    { name = "la3rence" },
+]
+license = "MIT"
+requires-python = ">=3.11"
+dependencies = [
+    "msgpack>=1.1.2",
+    "openpyxl>=3.1",
+    "requests>=2.31",
+    "websocket-client>=1.9.0",
+]
+
+[project.scripts]
+sql = "yearning_cli.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/la3rence/yearning-cli"
+Repository = "https://github.com/la3rence/yearning-cli"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["yearning_cli", "mysql_proxy"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"pyproject.toml" = "pyproject.toml"

yearning_cli/__init__.py

@@ -0,0 +1 @@
+"""Yearning MySQL Audit Platform CLI."""