damon-devtools 0.1.0__tar.gz

damon_devtools-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: damon-devtools
+Version: 0.1.0
+Summary: Developer CLI tools — portkill, removebg, apkpull
+Author: damon
+License: MIT
+Keywords: cli,devtools,android,apk,adb
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9
+
+# devtools
+
+Developer CLI tools: portkill, removebg, apkpull.
+
+## Tools
+
+### portkill
+Kill Node.js processes by port or scan all node processes.
+
+```bash
+python -m devtools portkill
+python -m devtools portkill --listen-only
+```
+
+### apkpull
+Pull APK files from Android device via ADB.
+
+```bash
+python -m devtools apkpull [target_dir]
+```
+
+### removebg
+Remove image backgrounds using the remove.bg API.
+
+```bash
+python -m devtools removebg input.jpg
+```
+
+## Install
+
+```bash
+pip install damon-devtools
+```
+
+Requires: Python >=3.10

damon_devtools-0.1.0/README.md

@@ -0,0 +1,35 @@
+# devtools
+
+Developer CLI tools: portkill, removebg, apkpull.
+
+## Tools
+
+### portkill
+Kill Node.js processes by port or scan all node processes.
+
+```bash
+python -m devtools portkill
+python -m devtools portkill --listen-only
+```
+
+### apkpull
+Pull APK files from Android device via ADB.
+
+```bash
+python -m devtools apkpull [target_dir]
+```
+
+### removebg
+Remove image backgrounds using the remove.bg API.
+
+```bash
+python -m devtools removebg input.jpg
+```
+
+## Install
+
+```bash
+pip install damon-devtools
+```
+
+Requires: Python >=3.10

damon_devtools-0.1.0/damon_devtools.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: damon-devtools
+Version: 0.1.0
+Summary: Developer CLI tools — portkill, removebg, apkpull
+Author: damon
+License: MIT
+Keywords: cli,devtools,android,apk,adb
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: psutil>=5.9
+
+# devtools
+
+Developer CLI tools: portkill, removebg, apkpull.
+
+## Tools
+
+### portkill
+Kill Node.js processes by port or scan all node processes.
+
+```bash
+python -m devtools portkill
+python -m devtools portkill --listen-only
+```
+
+### apkpull
+Pull APK files from Android device via ADB.
+
+```bash
+python -m devtools apkpull [target_dir]
+```
+
+### removebg
+Remove image backgrounds using the remove.bg API.
+
+```bash
+python -m devtools removebg input.jpg
+```
+
+## Install
+
+```bash
+pip install damon-devtools
+```
+
+Requires: Python >=3.10

damon_devtools-0.1.0/damon_devtools.egg-info/SOURCES.txt

@@ -0,0 +1,27 @@
+README.md
+pyproject.toml
+damon_devtools.egg-info/PKG-INFO
+damon_devtools.egg-info/SOURCES.txt
+damon_devtools.egg-info/dependency_links.txt
+damon_devtools.egg-info/entry_points.txt
+damon_devtools.egg-info/requires.txt
+damon_devtools.egg-info/top_level.txt
+devtools/__init__.py
+devtools/__main__.py
+devtools/launcher.py
+devtools/types.py
+devtools/tools/__init__.py
+devtools/tools/apkpull/__init__.py
+devtools/tools/apkpull/__main__.py
+devtools/tools/apkpull/core.py
+devtools/tools/apkpull/models.py
+devtools/tools/apkpull/ui.py
+devtools/tools/portkill/__init__.py
+devtools/tools/portkill/__main__.py
+devtools/tools/portkill/core.py
+devtools/tools/portkill/models.py
+devtools/tools/portkill/ui.py
+devtools/tools/removebg/__init__.py
+devtools/tools/removebg/__main__.py
+devtools/tools/removebg/cli.py
+devtools/tools/removebg/core.py

damon_devtools-0.1.0/damon_devtools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

damon_devtools-0.1.0/damon_devtools.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devtools = devtools.__main__:main

damon_devtools-0.1.0/damon_devtools.egg-info/requires.txt

@@ -0,0 +1 @@
+psutil>=5.9

damon_devtools-0.1.0/damon_devtools.egg-info/top_level.txt

@@ -0,0 +1 @@
+devtools

damon_devtools-0.1.0/devtools/__init__.py

@@ -0,0 +1,2 @@
+"""devtools - Developer tools CLI launcher"""
+__version__ = "0.1.0"

damon_devtools-0.1.0/devtools/__main__.py

@@ -0,0 +1,53 @@
+import sys
+from importlib import import_module
+from devtools.tools import get_tool
+
+
+def run_tool(tool_name: str, args: list[str]):
+    tool = get_tool(tool_name)
+    if tool is None:
+        print(f"Unknown tool: {tool_name}")
+        print("Run `devtools` to see available tools.")
+        sys.exit(1)
+
+    module_name = tool.module
+
+    # Try module.run directly (if tool exposes run at module root)
+    mod = import_module(module_name)
+    if hasattr(mod, "run"):
+        mod.run(args)
+        return
+
+    # Try module.cli.run (removebg pattern)
+    try:
+        cli_mod = import_module(f"{module_name}.cli")
+        if hasattr(cli_mod, "run"):
+            cli_mod.run(args)
+            return
+    except ImportError:
+        pass
+
+    # Try module.ui.run (portkill pattern)
+    try:
+        ui_mod = import_module(f"{module_name}.ui")
+        if hasattr(ui_mod, "run"):
+            ui_mod.run(args)
+            return
+    except ImportError:
+        pass
+
+    print(f"Tool module {module_name} has no run() function")
+    sys.exit(1)
+
+
+def main():
+    if len(sys.argv) > 1:
+        run_tool(sys.argv[1], sys.argv[2:])
+    else:
+        from devtools.launcher import render_launcher
+        result = render_launcher()
+        if result:
+            run_tool(result, [])
+
+if __name__ == "__main__":
+    main()

damon_devtools-0.1.0/devtools/launcher.py

@@ -0,0 +1,43 @@
+import sys
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8")
+
+from devtools.tools import TOOLS
+
+
+def render_launcher():
+    """
+    CLI launcher — list all tools with numbers, read selection.
+    Returns: tool name string to launch, or None to quit
+    """
+    if not TOOLS:
+        print("No tools registered!")
+        return None
+
+    print()
+    print("=" * 50)
+    print("  devtools — 开发者工具箱")
+    print("=" * 50)
+    print()
+    for i, tool in enumerate(TOOLS):
+        print(f"  {i + 1}. {tool.name:15s} — {tool.description}")
+    print()
+    print(f"  [1-{len(TOOLS)}] 选择工具  |  [Q] 退出")
+    print()
+
+    try:
+        choice = input("> ").strip()
+    except (EOFError, KeyboardInterrupt):
+        return None
+
+    if choice.lower() == "q":
+        return None
+
+    try:
+        idx = int(choice) - 1
+        if 0 <= idx < len(TOOLS):
+            return TOOLS[idx].name
+    except ValueError:
+        pass
+
+    return None

damon_devtools-0.1.0/devtools/tools/__init__.py

@@ -0,0 +1,29 @@
+"""Tools registry for devtools"""
+from devtools.types import Tool
+
+TOOLS = [
+    Tool(
+        name="portkill",
+        category="进程/端口",
+        description="按端口杀 Node.js 进程",
+        module="devtools.tools.portkill",
+    ),
+    Tool(
+        name="removebg",
+        category="图像处理",
+        description="批量删除图片背景",
+        module="devtools.tools.removebg",
+    ),
+    Tool(
+        name="apkpull",
+        category="设备管理",
+        description="提取手机 APK 文件",
+        module="devtools.tools.apkpull",
+    ),
+]
+
+def get_tool(name: str):
+    for tool in TOOLS:
+        if tool.name == name:
+            return tool
+    return None

damon_devtools-0.1.0/devtools/tools/apkpull/__init__.py

@@ -0,0 +1 @@
+"""apkpull - Extract APK files from Android device via ADB"""

damon_devtools-0.1.0/devtools/tools/apkpull/__main__.py

@@ -0,0 +1,5 @@
+from devtools.tools.apkpull.ui import run
+
+if __name__ == "__main__":
+    import sys
+    run(sys.argv[1:])

damon_devtools-0.1.0/devtools/tools/apkpull/core.py

@@ -0,0 +1,123 @@
+import subprocess
+import re
+import os
+import tempfile
+
+def _find_aapt() -> str | None:
+    """Find aapt.exe — checks PATH first, then Android SDK build-tools"""
+    # 1. Check PATH
+    import shutil as _shutil
+    path_aapt = _shutil.which("aapt")
+    if path_aapt and os.path.isfile(path_aapt):
+        return path_aapt
+    path_aapt2 = _shutil.which("aapt2")
+    if path_aapt2 and os.path.isfile(path_aapt2):
+        return path_aapt2
+    # 2. Check Android SDK build-tools
+    sdk_base = os.environ.get("LOCALAPPDATA", "") + "/Android/Sdk"
+    build_tools = os.path.join(sdk_base, "build-tools")
+    if os.path.isdir(build_tools):
+        versions = sorted(os.listdir(build_tools), reverse=True)
+        for v in versions:
+            for binary in ("aapt.exe", "aapt2.exe"):
+                aapt = os.path.join(build_tools, v, binary)
+                if os.path.isfile(aapt):
+                    return aapt
+    return None
+
+AAPT_PATH = _find_aapt()
+
+def check_adb() -> bool:
+    """检查 ADB 是否可用"""
+    try:
+        subprocess.run(["adb", "version"], capture_output=True, check=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def check_device() -> bool:
+    """检查设备是否连接"""
+    try:
+        result = subprocess.run(["adb", "devices"], capture_output=True, text=True, encoding="utf-8", errors="replace", check=True)
+        lines = result.stdout.strip().split("\n")
+        for line in lines[1:]:
+            if line.strip() and not line.startswith("*"):
+                parts = line.split()
+                if len(parts) >= 2 and parts[1] == "device":
+                    return True
+        return False
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
+
+def scan_packages() -> list[str]:
+    """执行 adb shell pm list packages -3，返回包名列表"""
+    result = subprocess.run(
+        ["adb", "shell", "pm", "list", "packages", "-3"],
+        capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+    )
+    pkgs = []
+    for line in result.stdout.strip().split("\n"):
+        line = line.strip()
+        if line.startswith("package:"):
+            pkgs.append(line[8:])
+    return pkgs
+
+def get_apk_path(pkg: str) -> str | None:
+    """执行 pm path，返回 APK 物理路径"""
+    try:
+        result = subprocess.run(
+            ["adb", "shell", "pm", "path", pkg],
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        for line in result.stdout.strip().split("\n"):
+            if line.startswith("package:"):
+                return line[8:].strip()
+        return None
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+def get_app_name(pkg: str) -> str:
+    """通过 aapt 提取 APK 的 application label"""
+    if not AAPT_PATH:
+        return pkg
+    apk_path = get_apk_path(pkg)
+    if not apk_path:
+        return pkg
+    tmp = os.path.join(tempfile.gettempdir(), f"apkpull_{os.getpid()}_{pkg.replace('.', '_')}.apk")
+    try:
+        # pull APK to temp file
+        pull_ok = subprocess.run(
+            ["adb", "pull", apk_path, tmp],
+            capture_output=True, encoding="utf-8", errors="replace"
+        ).returncode == 0
+        if not pull_ok or not os.path.exists(tmp):
+            return pkg
+        # extract label via aapt
+        result = subprocess.run(
+            [AAPT_PATH, "dump", "badging", tmp],
+            capture_output=True, encoding="utf-8", errors="replace"
+        )
+        for line in result.stdout.split("\n"):
+            m = re.search(r"application-label:'(.+?)'", line)
+            if m:
+                return m.group(1)
+        return pkg
+    except Exception:
+        return pkg
+    finally:
+        if os.path.exists(tmp):
+            try:
+                os.remove(tmp)
+            except OSError:
+                pass
+
+def pull_apk(apk_path: str, dest_dir: str) -> bool:
+    """执行 adb pull，拉取 APK 到目标目录"""
+    try:
+        subprocess.run(
+            ["adb", "pull", apk_path, dest_dir],
+            capture_output=True, text=True, encoding="utf-8", errors="replace", check=True
+        )
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False

damon_devtools-0.1.0/devtools/tools/apkpull/models.py

@@ -0,0 +1,6 @@
+from dataclasses import dataclass
+
+@dataclass
+class PackageInfo:
+    pkg: str   # 包名 (com.example.app)
+    label: str  # 应用名 (My App)

damon_devtools-0.1.0/devtools/tools/apkpull/ui.py

@@ -0,0 +1,171 @@
+import sys
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8")
+
+import os
+import threading
+from devtools.tools.apkpull.models import PackageInfo
+
+def scan_packages_with_labels() -> list[PackageInfo]:
+    """Scan packages and fetch labels in parallel threads (max 10 concurrent)"""
+    from devtools.tools.apkpull.core import scan_packages, check_adb, check_device, get_app_name
+
+    if not check_adb():
+        print("错误: 未找到 adb 命令，请确保 Android SDK platform-tools 已安装并加入 PATH")
+        return []
+    if not check_device():
+        print("错误: 未检测到设备，请确保手机已通过 USB 连接并开启了 USB 调试模式")
+        return []
+
+    print("正在获取应用列表...")
+    pkgs = scan_packages()
+    if not pkgs:
+        print("未找到第三方应用")
+        return []
+
+    print(f"共 {len(pkgs)} 个应用，正在获取应用名称...")
+
+    packages: list[PackageInfo] = []
+    lock = threading.Lock()
+
+    def fetch(pkg: str):
+        try:
+            label = get_app_name(pkg)
+        except Exception:
+            label = pkg  # fallback on error
+        with lock:
+            packages.append(PackageInfo(pkg=pkg, label=label))
+
+    threads: list[threading.Thread] = []
+    for pkg in pkgs:
+        t = threading.Thread(target=fetch, args=(pkg,))
+        t.start()
+        threads.append(t)
+        if len(threads) >= 10:
+            threads[0].join()
+            threads = threads[1:]
+
+    for t in threads:
+        t.join()
+
+    packages.sort(key=lambda x: x.label.lower())
+    return packages
+
+def show_packages(packages: list[PackageInfo], short: bool = True) -> None:
+    print()
+    print(f"{'#':<5} {'应用名':<30} {'包名'}")
+    print("-" * 90)
+    for i, p in enumerate(packages):
+        label = p.label[:28] + ".." if short and len(p.label) > 30 else p.label
+        pkg = p.pkg[:50] if short and len(p.pkg) > 50 else p.pkg
+        print(f"{i+1:<5} {label:<30} {pkg}")
+
+def select_packages(packages: list[PackageInfo], user_input: str) -> list[PackageInfo]:
+    """Parse user input: keyword search or numeric selection (1,3-5, 1,3,5)"""
+    if not user_input:
+        return []
+    # If input contains letters, treat as search keyword
+    if any(c.isalpha() for c in user_input):
+        keyword = user_input.lower()
+        return [p for p in packages if keyword in p.label.lower() or keyword in p.pkg.lower()]
+    # Numeric selection
+    indices: list[int] = []
+    for part in user_input.split(","):
+        part = part.strip()
+        if "-" in part:
+            start, end = part.split("-", 1)
+            try:
+                indices.extend(range(int(start) - 1, int(end) + 1))  # +1 because range end is exclusive
+            except ValueError:
+                print(f"无效输入: {part}")
+                return []
+        else:
+            try:
+                indices.append(int(part) - 1)
+            except ValueError:
+                print(f"无效输入: {part}")
+                return []
+    return [packages[i] for i in indices if 0 <= i < len(packages)]
+
+def confirm_pull(packages: list[PackageInfo], dest_dir: str) -> bool:
+    print()
+    print("=" * 70)
+    for p in packages:
+        print(f"  应用名: {p.label}")
+        print(f"  包名: {p.pkg}")
+        print("-" * 70)
+    print(f"目标目录: {dest_dir}")
+    print(f"共 {len(packages)} 个 APK")
+    print()
+    try:
+        answer = input("确认拉取？ (y/N): ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        return False
+    return answer in ("y", "yes")
+
+def run(args: list[str] | None = None):
+    """Main entry point"""
+    if args is None:
+        args = []
+
+    # Determine destination directory
+    if args:
+        dest_dir = args[0]
+    else:
+        dest_dir = os.getcwd()
+
+    packages = scan_packages_with_labels()
+    if not packages:
+        return
+
+    show_packages(packages)
+
+    while True:
+        print()
+        print("输入应用名/包名关键字搜索，或输入序号选择 (1,3-5, 1,3,5)")
+        print("回车退出")
+
+        try:
+            user_input = input("\n> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+
+        if not user_input:
+            print("未选择，退出")
+            return
+
+        selected = select_packages(packages, user_input)
+        if not selected:
+            print("未匹配到应用")
+            continue
+
+        show_packages(selected, short=False)
+
+        if not confirm_pull(selected, dest_dir):
+            print("取消拉取")
+            continue
+
+        # Pull APKs
+        from devtools.tools.apkpull.core import get_apk_path, pull_apk
+        succeeded: list[str] = []
+        failed: list[tuple] = []
+
+        for p in selected:
+            apk_path = get_apk_path(p.pkg)
+            if not apk_path:
+                failed.append((p.label, "未找到 APK 路径"))
+                continue
+            if pull_apk(apk_path, dest_dir):
+                succeeded.append(p.label)
+            else:
+                failed.append((p.label, "拉取失败"))
+
+        print()
+        if succeeded:
+            print(f"成功: {len(succeeded)} 个")
+        if failed:
+            print(f"失败: {len(failed)} 个")
+            for label, reason in failed:
+                print(f"  {label}: {reason}")
+        return

damon_devtools-0.1.0/devtools/tools/portkill/__init__.py

@@ -0,0 +1 @@
+"""portkill - kill Node.js processes by port"""

damon_devtools-0.1.0/devtools/tools/portkill/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from devtools.tools.portkill.ui import run
+
+if __name__ == "__main__":
+    run(sys.argv[1:])

damon_devtools-0.1.0/devtools/tools/portkill/core.py

@@ -0,0 +1,97 @@
+import os
+import signal
+import psutil
+from typing import List, Dict
+from devtools.tools.portkill.models import ProcessInfo
+
+
+def scan_node_ports() -> List[ProcessInfo]:
+    """扫描所有 Node.js 进程，返回按 PID 升序排列的列表"""
+    results: List[ProcessInfo] = []
+    seen_pids: Dict[int, ProcessInfo] = {}
+
+    # 首先找出所有 Node.js 进程
+    node_processes = []
+    for proc in psutil.process_iter():
+        try:
+            name = proc.name().lower()
+            if "node" not in name:
+                continue
+            node_processes.append(proc)
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            continue
+
+    # 获取所有监听中的 TCP 连接（用于查端口）
+    connections_by_pid: Dict[int, List[int]] = {}
+    for conn in psutil.net_connections(kind="inet"):
+        if conn.status != "LISTEN":
+            continue
+        if not conn.laddr:
+            continue
+        pid = conn.pid
+        port = conn.laddr.port
+        if pid not in connections_by_pid:
+            connections_by_pid[pid] = []
+        connections_by_pid[pid].append(port)
+
+    # 为每个 Node.js 进程创建 ProcessInfo
+    for proc in node_processes:
+        pid = proc.pid
+        if pid in seen_pids:
+            continue
+
+        ports = connections_by_pid.get(pid, [])
+        port = ports[0] if ports else 0
+
+        try:
+            cmdline = " ".join(proc.cmdline())
+            cwd = proc.cwd()
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            cmdline = ""
+            cwd = ""
+
+        try:
+            children = [child.pid for child in proc.children(recursive=True)]
+        except (psutil.NoSuchProcess, psutil.AccessDenied):
+            children = []
+
+        seen_pids[pid] = ProcessInfo(
+            pid=pid,
+            port=port,
+            name=proc.name(),
+            cmdline=cmdline,
+            cwd=cwd,
+            children=children,
+        )
+
+    results = list(seen_pids.values())
+    results.sort(key=lambda x: (-x.port, x.pid))  # 有端口优先，按端口降序；无端口按 PID 升序
+    return results
+
+
+def get_process_tree(pid: int) -> List[int]:
+    """获取指定进程及其所有子进程的 PID 列表"""
+    try:
+        proc = psutil.Process(pid)
+        pids = [pid]
+        for child in proc.children(recursive=True):
+            pids.append(child.pid)
+        return pids
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return [pid]  # 进程不存在时只返回自身
+
+
+def kill_process(pid: int, kill_children: bool = False) -> bool:
+    """向目标进程发送 SIGTERM 信号，成功返回 True"""
+    try:
+        proc = psutil.Process(pid)
+        if kill_children:
+            for child in proc.children(recursive=True):
+                try:
+                    os.kill(child.pid, signal.SIGTERM)
+                except (OSError, psutil.NoSuchProcess):
+                    pass
+        os.kill(pid, signal.SIGTERM)
+        return True
+    except (psutil.NoSuchProcess, psutil.AccessDenied, OSError):
+        return False

damon_devtools-0.1.0/devtools/tools/portkill/models.py

@@ -0,0 +1,17 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class ProcessInfo:
+    """Node.js 进程信息"""
+    pid: int
+    port: int
+    name: str
+    cmdline: str
+    cwd: str
+    children: list[int] = field(default_factory=list)
+    cmdline_short: Optional[str] = None  # 截断后的命令摘要
+
+    def __post_init__(self):
+        self.cmdline_short = self.cmdline

damon_devtools-0.1.0/devtools/tools/portkill/ui.py

@@ -0,0 +1,203 @@
+import sys
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8")
+
+from devtools.tools.portkill.models import ProcessInfo
+
+
+def show_processes(processes: list[ProcessInfo], short: bool = False) -> None:
+    """Display processes in a simple table"""
+    print()
+    print(f"{'#':<4} {'PORT':<6} {'PID':<8} {'NAME':<20} {'CMDLINE'}")
+    print("-" * 120)
+    for i, p in enumerate(processes):
+        port_str = str(p.port) if p.port > 0 else "-"
+        cmdline = p.cmdline
+        if short:
+            cmdline = (p.cmdline[:50] + "...") if len(p.cmdline) > 50 else p.cmdline
+        print(f"{i+1:<4} {port_str:<6} {p.pid:<8} {p.name:<20} {cmdline}")
+
+
+def select_processes(processes: list[ProcessInfo], user_input: str) -> list[ProcessInfo]:
+    """
+    Parse user selection from input string.
+    Supports: 1,3-5 or 1,3,5 or 1-3 style selection.
+    Returns selected ProcessInfo list.
+    """
+    if not processes:
+        print("没有发现 Node.js 进程")
+        return []
+
+    if not user_input:
+        return []
+
+    # Parse selection
+    indices: list[int] = []
+    for part in user_input.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        if "-" in part:
+            start, end = part.split("-", 1)
+            try:
+                indices.extend(range(int(start) - 1, int(end)))
+            except ValueError:
+                print(f"无效输入: {part}")
+                return []
+        else:
+            try:
+                indices.append(int(part) - 1)
+            except ValueError:
+                print(f"无效输入: {part}")
+                return []
+
+    selected = [processes[i] for i in indices if 0 <= i < len(processes)]
+    return selected
+
+
+def confirm_kill(processes: list[ProcessInfo]) -> bool:
+    """Show confirmation with process details"""
+    print()
+    print("=" * 60)
+    for p in processes:
+        print(f"  端口: {p.port}  |  PID: {p.pid}  |  进程名: {p.name}")
+        print(f"  命令: {p.cmdline}")
+        print(f"  目录: {p.cwd}")
+        if p.children:
+            print(f"  子进程: {p.children}")
+        print("-" * 60)
+    print()
+
+    try:
+        answer = input("确认关闭以上进程？ (y/N): ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        return False
+    return answer in ("y", "yes")
+
+
+def execute_kill(pids: list[int], kill_children: bool = False) -> dict:
+    """
+    Execute kill on given PIDs.
+    Returns {"killed": [...], "failed": [...]}
+    """
+    from devtools.tools.portkill.core import kill_process, get_process_tree
+
+    killed: list[int] = []
+    failed: list[tuple] = []
+
+    all_pids: list[int] = []
+    for pid in pids:
+        if kill_children:
+            all_pids.extend(get_process_tree(pid))
+        else:
+            all_pids.append(pid)
+
+    seen = set()
+    unique_pids = []
+    for pid in all_pids:
+        if pid not in seen:
+            seen.add(pid)
+            unique_pids.append(pid)
+
+    for pid in unique_pids:
+        if kill_process(pid, kill_children=False):
+            killed.append(pid)
+        else:
+            failed.append((pid, "进程不存在或无权限"))
+
+    return {"killed": killed, "failed": failed}
+
+
+def run(args: list[str] | None = None):
+    """Main entry point for portkill CLI"""
+    from devtools.tools.portkill.core import scan_node_ports
+
+    if args is None:
+        args = []
+
+    short = "--long" not in args      # short mode by default
+    listen_only = "--listen-only" in args
+
+    print("扫描 Node.js 进程...")
+
+    try:
+        all_processes = scan_node_ports()
+    except Exception as e:
+        print(f"扫描失败: {e}")
+        return
+
+    if not all_processes:
+        print("未发现 Node.js 进程")
+        return
+
+    short_mode = short
+    listen_filter = listen_only
+
+    while True:
+        # Apply filters
+        processes = all_processes
+        if listen_filter:
+            processes = [p for p in processes if p.port > 0]
+
+        if not processes:
+            print("没有符合条件的进程")
+            print("提示: 按 l 切换显示模式，或 p 关闭端口筛选")
+        else:
+            show_processes(processes, short=short_mode)
+
+        print()
+        print("快捷: l=长短显示  p=端口筛选  r=重新扫描  回车=退出")
+
+        try:
+            user_input = input("\n> ").strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return
+
+        if not user_input:
+            print("未选择任何进程，退出")
+            return
+
+        # Interactive commands
+        if user_input == "l":
+            short_mode = not short_mode
+            continue
+        if user_input == "p":
+            listen_filter = not listen_filter
+            continue
+        if user_input == "r":
+            try:
+                all_processes = scan_node_ports()
+            except Exception as e:
+                print(f"扫描失败: {e}")
+                return
+            if not all_processes:
+                print("未发现 Node.js 进程")
+                return
+            continue
+
+        # Try to parse as selection
+        selected = select_processes(processes, user_input)
+        if not selected:
+            print("未选择任何进程，退出")
+            return
+
+        if not confirm_kill(selected):
+            print("取消关闭")
+            continue
+
+        try:
+            child_answer = input("是否同时关闭子进程？ (y/N): ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            child_answer = "n"
+        kill_children = child_answer in ("y", "yes")
+
+        pids = [p.pid for p in selected]
+        result = execute_kill(pids, kill_children=kill_children)
+
+        print()
+        if result["killed"]:
+            print(f"已关闭: {result['killed']}")
+        if result["failed"]:
+            print(f"失败: {result['failed']}")
+        return

damon_devtools-0.1.0/devtools/tools/removebg/__main__.py

@@ -0,0 +1,5 @@
+import sys
+from devtools.tools.removebg.cli import run
+
+if __name__ == "__main__":
+    run(sys.argv[1:])

damon_devtools-0.1.0/devtools/tools/removebg/cli.py

@@ -0,0 +1,80 @@
+"""CLI entry point for removebg"""
+import argparse
+import sys
+from pathlib import Path
+
+from devtools.tools.removebg.core import process_images
+
+
+MODELS = ["u2net", "u2netp", "u2net_human_seg"]
+
+
+def run(args: list[str] | None = None):
+    if args is None:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        prog="python -m devtools removebg",
+        description="Remove background from images using rembg",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=Path,
+        default=None,
+        metavar="DIR",
+        help="Output directory (default: overwrite originals)",
+    )
+    parser.add_argument(
+        "-m", "--model",
+        choices=MODELS,
+        default="u2net",
+        help="Model to use (default: u2net)",
+    )
+    parser.add_argument(
+        "-a", "--alpha-matting",
+        action="store_true",
+        help="Enable alpha matting for better edge quality",
+    )
+    parser.add_argument(
+        "files",
+        nargs="+",
+        type=Path,
+        help="Image files to process",
+    )
+
+    ns = parser.parse_args(args)
+
+    # Validate files exist
+    missing = [f for f in ns.files if not f.exists()]
+    if missing:
+        for f in missing:
+            print(f"文件不存在: {f}", file=sys.stderr)
+        sys.exit(1)
+
+    # Create output dir if specified
+    if ns.output is not None:
+        ns.output.mkdir(parents=True, exist_ok=True)
+
+    print(f"开始处理 {len(ns.files)} 个文件...")
+
+    result = process_images(
+        input_paths=ns.files,
+        output_dir=ns.output,
+        model=ns.model,
+        alpha_matting=ns.alpha_matting,
+    )
+
+    # Report results
+    print()
+    for path in result["succeeded"]:
+        print(f"  OK: {path}")
+
+    for path, err in result["failed"]:
+        print(f"  FAIL: {path} — {err}")
+
+    total = len(result["succeeded"]) + len(result["failed"])
+    print()
+    print(f"完成: {total} 文件, {len(result['succeeded'])} 成功, {len(result['failed'])} 失败")
+
+    if result["failed"]:
+        sys.exit(1)

damon_devtools-0.1.0/devtools/tools/removebg/core.py

@@ -0,0 +1,66 @@
+"""rembg core wrapper"""
+from pathlib import Path
+from typing import Optional
+
+from rembg import remove, new_session
+from PIL import Image
+
+
+def process_images(
+    input_paths: list[Path],
+    output_dir: Optional[Path],
+    model: str = "u2net",
+    alpha_matting: bool = False,
+    alpha_matting_foreground_threshold: int = 240,
+    alpha_matting_background_threshold: int = 10,
+    alpha_matting_erode_size: int = 0,
+) -> dict:
+    """
+    Process a list of image files with rembg.
+
+    Args:
+        input_paths: List of image file paths
+        output_dir: If set, write output files here. If None, overwrite originals.
+        model: u2net | u2netp | u2net_human_seg
+        alpha_matting: Enable alpha matting
+        alpha_matting_foreground_threshold: Foreground threshold for alpha matting
+        alpha_matting_background_threshold: Background threshold for alpha matting
+        alpha_matting_erode_size: Erode size for alpha matting
+
+    Returns:
+        {"succeeded": [...], "failed": [(path, error_message), ...]}
+    """
+    succeeded = []
+    failed = []
+
+    session = new_session(model_name=model)
+
+    for input_path in input_paths:
+        try:
+            with Image.open(input_path) as img:
+                # rembg returns RGBA
+                output = remove(
+                    img,
+                    session=session,
+                    alpha_matting=alpha_matting,
+                    alpha_matting_foreground_threshold=alpha_matting_foreground_threshold,
+                    alpha_matting_background_threshold=alpha_matting_background_threshold,
+                    alpha_matting_erode_size=alpha_matting_erode_size,
+                )
+
+            if output_dir is None:
+                # Overwrite original
+                output_path = input_path
+            else:
+                output_path = output_dir / input_path.name
+
+            # Ensure output directory exists
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            output.save(output_path, "PNG")
+            succeeded.append(str(output_path))
+
+        except Exception as e:
+            failed.append((str(input_path), str(e)))
+
+    return {"succeeded": succeeded, "failed": failed}

damon_devtools-0.1.0/devtools/types.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+@dataclass
+class Tool:
+    """A tool available in devtools"""
+    name: str
+    category: str
+    description: str
+    module: str

damon_devtools-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "damon-devtools"
+version = "0.1.0"
+description = "Developer CLI tools — portkill, removebg, apkpull"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["psutil>=5.9"]
+license = {text = "MIT"}
+authors = [
+    {name = "damon"},
+]
+keywords = ["cli", "devtools", "android", "apk", "adb"]
+
+[project.scripts]
+devtools = "devtools.__main__:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["devtools*"]
+exclude = ["dotfiles*", "tests*", "build*", "dist*"]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

damon_devtools-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+