pkgmate 0.0.1__py3-none-any.whl

pkgtool/backends/deb.py

@@ -0,0 +1,167 @@
+"""pkgtool.backends.deb — deb/apt 已安装包 + 磁盘散落 .deb 文件的采集。
+
+数据来源（按可信度排序）：
+  1. /var/lib/dpkg/status       当前装了什么（名字/版本/状态）
+  2. /var/lib/dpkg/info/*.list  每个包的文件清单（安装路径、可执行文件）
+  3. /var/log/dpkg.log*         所有 dpkg 操作的时间线（含 dpkg -i，最接近事实）
+  4. /var/log/apt/history.log*  仅 apt 系工具的操作记录（apt install ./x.deb 也在里面）
+  5. extended_states            auto/manual 标记的权威存储
+  6. /var/lib/apt/lists         当前已配置的源（apt 不持久记录"包从哪个源下载"，
+                                只能用当前索引反推来源）
+
+关键设计：安装通道(channel) 与 是否在源里(in_repo) 是两个正交维度，分开存。
+原实现把两者挤进 extra["channel"] 一个字段，上层再用索引结论覆盖后端的日志结论，
+154 个镜像自带包因此被误报成 "apt 源安装"，前端判预装的分支成了死代码。
+"""
+import os
+
+from ..apt import deps, dpkg, lists, logs
+from ..base import (Backend, Channel, OriginKind, PackageRecord, file_size_mb,
+                    scan_file_areas)
+from ..config import CFG
+
+
+def resolve_channel(has_log, in_history, in_repo, cutoff, log_ts=None):
+    """安装通道判定 —— 全项目唯一一处（原实现分散在 deb_backend.collect 和
+    update_channels.deb_channels，两套规则还会互相覆盖）。
+
+    优先级（从强证据到弱证据）：
+      1. dpkg.log 无记录：apt history 有 → APT；否则在源里 → APT（日志已轮转，
+         但 apt 能管）；都不满足 → UNKNOWN
+      2. 首次安装落在系统出生时间窗内，且 apt history 无记录 → PREINSTALLED
+         （history 优先于时间窗：镜像构建期的 apt 操作也会进 history）
+      3. apt history 有记录：在源里 → APT；不在 → APT_LOCAL（源已移除/本地 .deb）
+      4. 只有 dpkg.log 记录（= 有人跑过 dpkg -i）→ DPKG_LOCAL
+         注意：即使这个包同时存在于源里，也判 DPKG_LOCAL —— 通道回答的是
+         "怎么装进来的"，"能不能用 apt 升级"由 in_repo/candidate 单独回答。
+    """
+    if not has_log:
+        if in_history:
+            return Channel.APT
+        return Channel.APT if in_repo else Channel.UNKNOWN
+    if in_history:
+        return Channel.APT if in_repo else Channel.APT_LOCAL
+    if cutoff is not None:
+        dt = logs.parse_ts(log_ts)
+        if dt is not None and dt <= cutoff:
+            return Channel.PREINSTALLED
+    return Channel.DPKG_LOCAL
+
+
+def resolve_origin(name, version, index):
+    """来源判定 → (OriginKind, [源标签])。三级置信度：
+      (包,版本) 精确命中某源 → REPO（高置信）
+      包在源里但版本对不上   → REPO_STALE（源已更新，或源被移除后重新配置过）
+      包不在任何源           → LOCAL（本地 .deb，高置信）
+    """
+    exact = index.repos(name, version)
+    if exact:
+        return OriginKind.REPO, exact
+    any_ver = index.repos(name)
+    if any_ver:
+        return OriginKind.REPO_STALE, any_ver
+    return OriginKind.LOCAL, []
+
+
+def _top_dirs(files):
+    """文件清单里的顶层目录（去重排序）。
+    清单首行常是 "/."（dpkg 用来声明根目录所有权），lstrip 后会变成 "."，
+    不排除就会在安装路径里显示成一个 meaningless 的点。"""
+    out = set()
+    for p in files:
+        if not p.startswith("/"):
+            continue
+        head = p.lstrip("/").split("/")[0]
+        if head and head != ".":
+            out.add(head)
+    return sorted(out)
+
+
+class DebBackend(Backend):
+    pkg_type = "deb"
+
+    @classmethod
+    def available(cls, cfg=CFG):
+        return os.path.isfile(cfg.dpkg_status)
+
+    def collect(self):
+        cfg = self.cfg
+        installed = dpkg.installed(cfg)
+        first_install, earliest = logs.dpkg_installs(cfg)
+        history = logs.apt_history(cfg)
+        manual, auto = dpkg.apt_marks(cfg)
+        ext_autos, ext_path = dpkg.extended_states(cfg)
+        cutoff = logs.birth_cutoff(earliest, cfg)
+        index = lists.load_index(cfg)
+        graph = deps.DepGraph(installed, manual)
+
+        records = []
+        for name in sorted(installed):
+            entry = installed[name]
+            version = entry.version
+            files = dpkg.package_files(name, cfg)[0]
+            exes = [p for p in files
+                    if any(p.startswith(d + "/") for d in cfg.bin_dirs)
+                    and os.access(p, os.X_OK)]
+            top_dirs = _top_dirs(files)
+            desktops = [f.rsplit("/", 1)[-1][: -len(".desktop")]
+                        for f in files if f.endswith(".desktop")]
+
+            log_ts, _log_ver = first_install.get(name, ("", ""))
+            channel = resolve_channel(has_log=bool(log_ts),
+                                      in_history=name in history,
+                                      in_repo=name in index, cutoff=cutoff,
+                                      log_ts=log_ts)
+            mark = "manual" if name in manual else ("auto" if name in auto else "?")
+            ext_mark = "absent" if ext_path is None else \
+                ("auto" if ext_autos.get(name, False) else "manual")
+            extra = {"apt_mark": mark, "ext_states": ext_mark, "top_dirs": top_dirs}
+            if mark != "?" and ext_mark != "absent" and mark != ext_mark:
+                extra["mark_conflict"] = f"apt-mark={mark} extended_states={ext_mark}"
+            if len(desktops) == 1:
+                # 只有一个 .desktop 时才把它当作该包的应用标识。装了多个的包
+                # （ubuntu-settings 顺带 gnome-initial-setup.desktop / info.desktop）
+                # 拿第一个去匹配残留，会删到别的包的配置目录。
+                extra["desktop_id"] = desktops[0]
+            elif desktops:
+                extra["desktop_files"] = desktops
+
+            kind, repos = resolve_origin(name, version, index)
+            candidate = index.candidate(name)
+            own, dep_mb, _total = graph.total_mb(name)
+            records.append(PackageRecord(
+                pkg_type=self.pkg_type, name=name, version=version,
+                origin_kind=kind, origin_repos=repos, channel=channel,
+                in_repo=name in index,
+                candidate=candidate if lists.is_upgrade(candidate, version) else "",
+                size_mb=own, exclusive_deps=sorted(graph.exclusive(name)),
+                deps_size_mb=dep_mb,
+                install_path=";".join(top_dirs[:cfg.top_dirs_limit]),
+                executables=exes, first_install=log_ts, extra=extra))
+
+        records.extend(self._loose_files(installed, index))
+        return records
+
+    def _loose_files(self, installed, index):
+        """磁盘上散落（未安装，或已安装但文件重复留着）的 .deb。"""
+        out = []
+        for path in scan_file_areas((".deb",), cfg=self.cfg):
+            info = dpkg.deb_file_info(path, cfg=self.cfg)
+            if not info:
+                continue
+            name, version = info["Package"], info.get("Version", "?")
+            kind, repos = resolve_origin(name, version, index)
+            out.append(PackageRecord(
+                pkg_type=self.pkg_type, name=name, version=version,
+                # 用文件名做变体：散落文件与同名已安装包是两条不同的事实
+                #（一条说"装了什么"，一条说"磁盘上还留着多大的安装包"），
+                # 合并成一条会把"这个 .deb 可以删了回收 220MB"的信息丢掉。
+                variant=os.path.basename(path),
+                origin_kind=OriginKind.FILE,
+                in_repo=name in index,
+                size_mb=file_size_mb(path), extra={
+                    "loose": path,
+                    "found_in": os.path.basename(os.path.dirname(path)),
+                    "state": "duplicate" if name in installed else "uninstalled",
+                    "repo_kind": kind.value, "repo_labels": repos}))
+        return out

pkgtool/backends/flatpak.py

@@ -0,0 +1,149 @@
+"""pkgtool.backends.flatpak — flatpak 包识别。
+
+数据源（优先文件系统，元数据就在安装目录里）：
+  <instance>/app/<app-id>/<arch>/<branch>/<commit>/metadata   INI 格式元数据
+      [Application] name/runtime/command/...（注意：通常没有 version 字段）
+  <commit>/export/bin/   该 app 暴露的命令
+  <commit>/files/        实际文件负载
+实例位置：system=/var/lib/flatpak   user=~/.local/share/flatpak
+增强（失败自动降级，版本号只能从这里拿）：
+  flatpak list --app/--runtime --columns=...
+远端更新检测（需要联网，默认不做，见 check_updates）：
+  flatpak remote-ls --updates
+"""
+import configparser
+import glob
+import os
+import re
+import subprocess
+
+from ..base import Backend, OriginKind, PackageRecord, file_size_mb
+from ..config import CFG
+
+# app-id 允许下划线：app.zen_browser.zen 这类很常见，漏掉它会让这些应用
+# 的更新检测被静默跳过（正则不匹配就当成非法行丢弃）
+_APP_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._\-]*\.[A-Za-z0-9_\-]+$")
+_COLUMNS = "application,version,name,arch,branch,installation,origin"
+
+
+def _flatpak_list(kind, cfg):
+    """flatpak list --app|--runtime → [(id, version, name, arch, branch, install, origin)]。
+    显式指定 --columns，避免默认列序随版本/locale 变化。"""
+    try:
+        out = subprocess.run(
+            ["flatpak", "list", f"--{kind}", f"--columns={_COLUMNS}"],
+            capture_output=True, text=True, timeout=cfg.timeout_query).stdout
+    except (OSError, subprocess.SubprocessError):
+        return []
+    rows = []
+    for line in out.splitlines():
+        cols = [c.strip() for c in line.split("\t")]
+        if len(cols) >= 7 and cols[0]:
+            rows.append(tuple(cols[:7]))
+    return rows
+
+
+def _parse_metadata(path):
+    """读 flatpak metadata 的 [Application] 段。
+    注意用 read_file 而不是 read：read() 不接受 errors=，原实现传了这个参数，
+    TypeError 又被 except Exception 静默吞掉，结果每个 metadata 都解析成空 dict。"""
+    cp = configparser.ConfigParser(interpolation=None)
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            cp.read_file(fh)
+    except (configparser.Error, OSError, UnicodeDecodeError):
+        return {}
+    return dict(cp["Application"]) if cp.has_section("Application") else {}
+
+
+def check_updates(cfg=CFG, timeout=90):
+    """有新版的 flatpak 应用 → {app_id: 显示名}。
+    需要联网（每个 installation 约 2 秒），所以默认不调用，由 --check-updates 触发。
+
+    两个 installation 都要查：不带作用域时 flatpak 只看默认（系统）安装，
+    用户级装的应用有新版会被整个漏掉。"""
+    out = {}
+    for scope in ("--system", "--user"):
+        try:
+            p = subprocess.run(["flatpak", "remote-ls", "--updates", scope,
+                                "--columns=name,application"],
+                               capture_output=True, text=True, timeout=timeout)
+        except (OSError, subprocess.SubprocessError):
+            continue
+        for line in p.stdout.splitlines():
+            cols = [c.strip() for c in line.split("\t")]
+            if len(cols) >= 2 and _APP_ID_RE.match(cols[1]):
+                out[cols[1]] = cols[0]
+    return out
+
+
+class FlatpakBackend(Backend):
+    pkg_type = "flatpak"
+    runtime_pkg_type = "flatpak-runtime"
+
+    @classmethod
+    def available(cls, cfg=CFG):
+        return (os.path.isdir(os.path.join(cfg.flatpak_system_dir, "app"))
+                or os.path.isdir(os.path.join(cfg.flatpak_user_dir, "app")))
+
+    def _instances(self):
+        for label, d in (("system", self.cfg.flatpak_system_dir),
+                         ("user", self.cfg.flatpak_user_dir)):
+            if os.path.isdir(os.path.join(d, "app")):
+                yield label, d
+
+    def collect(self):
+        cfg = self.cfg
+        cli_app = {(r[0], r[3], r[4]): r for r in _flatpak_list("app", cfg)}
+        cli_rt = {(r[0], r[3], r[4]): r for r in _flatpak_list("runtime", cfg)}
+        records = []
+        for inst_label, base in self._instances():
+            exports_bin = (os.path.join(base, "exports", "bin") if inst_label == "user"
+                           else cfg.flatpak_exports_bin)
+            for kind, cli_db in (("app", cli_app), ("runtime", cli_rt)):
+                app_dir = os.path.join(base, kind)
+                if not os.path.isdir(app_dir):
+                    continue
+                for meta in glob.glob(os.path.join(app_dir, "*/*/*/*/metadata")):
+                    records.append(self._record(meta, kind, inst_label,
+                                                cli_db, exports_bin))
+        return [r for r in records if r is not None]
+
+    def _record(self, meta, kind, inst_label, cli_db, exports_bin):
+        commit_dir = os.path.dirname(meta)
+        # active/current 是回指真实 commit 目录的符号链接，跳过避免重复计数
+        if os.path.islink(commit_dir):
+            return None
+        parts = meta.split(os.sep)      # .../app/<id>/<arch>/<branch>/<commit>/metadata
+        app_id, arch, branch = parts[-5], parts[-4], parts[-3]
+        md = _parse_metadata(meta)
+        row = cli_db.get((app_id, arch, branch))
+        version, disp_name, origin = (row[1], row[2], row[6]) if row else ("?", "", "")
+
+        cmd = md.get("command", "")
+        exes = []
+        exp_bin = os.path.join(commit_dir, "export", "bin")
+        if os.path.isdir(exp_bin):
+            exes += [os.path.join(exp_bin, e) for e in sorted(os.listdir(exp_bin))]
+        if os.path.isdir(exports_bin):
+            for e in sorted(os.listdir(exports_bin)):
+                if e in (app_id, cmd):
+                    exes.append(os.path.join(exports_bin, e))
+
+        extra = {"kind": kind, "installation": inst_label, "arch": arch,
+                 "branch": branch, "commit": os.path.basename(commit_dir)[:12]}
+        if disp_name:
+            extra["display_name"] = disp_name
+        if md.get("runtime"):
+            extra["runtime"] = md["runtime"]
+        return PackageRecord(
+            pkg_type=self.runtime_pkg_type if kind == "runtime" else self.pkg_type,
+            name=app_id, version=version or "?",
+            # 同一 app-id 可以并存多个 arch/branch（如 GL.default 的 25.08 与
+            # 25.08-extra），不设变体维度它们会撞 key，按名字定位时无法区分
+            variant=f"{arch}/{branch}",
+            origin_kind=OriginKind.REPO if origin else OriginKind.LOCAL,
+            origin_repos=[origin] if origin else [f"flatpak({inst_label})"],
+            size_mb=file_size_mb(os.path.join(commit_dir, "files")),
+            install_path=os.path.join(commit_dir, "files"),
+            executables=exes, extra=extra)

pkgtool/backends/linyap.py

@@ -0,0 +1,110 @@
+"""pkgtool.backends.linyap — 如意玲珑（linyaps）应用识别。
+
+数据源（离线、无需 root）：
+  ll-cli list --json            已安装应用与 base/runtime 的完整元数据
+  <repo>/states.json 的 layers  CLI 不可用时的降级来源（字段与上同构）
+
+实测与社区反馈的坑点，这里逐条处理：
+  · ll-cli 不带 --json 的表格输出会漏条目（本机 VSCode + base 两层只有
+    --json 吐出来了），所以只用 --json，表格一概不解析
+  · base 层的 kind 也是 "runtime"，区分应用与运行时只看 kind，不看名字
+  · ref 完整形态是 渠道:ID/版本/架构/模块；应用与 deb/snap 同名很常见
+    （firefox 三格式都有），变体里保留架构与模块
+  · 同一应用多版本可能并存（升级后旧版未清），同变体键取先出现的，
+    避免升级期间两条记录互相顶掉
+"""
+import json
+import os
+import subprocess
+import time
+
+from ..base import (BYTES_PER_MB, Backend, OriginKind, PackageRecord,
+                    is_safe_name)
+from ..config import CFG
+
+
+def _list_json(cfg):
+    """ll-cli list --json → [PackageInfo dict]；任何失败返回 []。"""
+    try:
+        p = subprocess.run(["ll-cli", "list", "--json"],
+                           capture_output=True, text=True,
+                           timeout=cfg.timeout_query)
+    except (OSError, subprocess.SubprocessError):
+        return []
+    if p.returncode != 0:
+        return []
+    try:
+        data = json.loads(p.stdout)
+    except json.JSONDecodeError:
+        return []
+    return data if isinstance(data, list) else []
+
+
+def _states_layers(cfg):
+    """states.json 的 layers 数组，CLI 失败时的降级来源。"""
+    path = os.path.join(cfg.linyap_repo_dir, "states.json")
+    try:
+        with open(path, encoding="utf-8", errors="replace") as fh:
+            data = json.load(fh)
+    except (OSError, json.JSONDecodeError):
+        return []
+    layers = data.get("layers") if isinstance(data, dict) else None
+    if not isinstance(layers, list):
+        return []
+    # 字段结构未经真实数据核实，只接受长得像 PackageInfo 的条目
+    return [x for x in layers
+            if isinstance(x, dict) and x.get("id") and x.get("version")]
+
+
+def _first_install(ts):
+    try:
+        return time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(float(ts)))
+    except (TypeError, ValueError, OSError, OverflowError):
+        return ""
+
+
+class LinyapBackend(Backend):
+    pkg_type = "linyap"
+
+    @classmethod
+    def available(cls, cfg=CFG):
+        return (os.path.isdir(cfg.linyap_repo_dir)
+                or bool(cls._which_ll_cli()))
+
+    @staticmethod
+    def _which_ll_cli():
+        import shutil
+        return shutil.which("ll-cli")
+
+    def collect(self):
+        items = _list_json(self.cfg) or _states_layers(self.cfg)
+        records = []
+        for it in items:
+            app_id = it.get("id")
+            version = it.get("version") or "?"
+            if not app_id or not is_safe_name(str(app_id)):
+                continue
+            archs = it.get("arch") or []
+            module = it.get("module") or ""
+            arch = archs[0] if archs else "?"
+            extra = {"kind": it.get("kind") or "",
+                     "channel": it.get("channel") or "",
+                     "module": module,
+                     "arch": ",".join(str(a) for a in archs)}
+            if it.get("base"):
+                extra["base"] = it["base"]
+            command = [str(c) for c in (it.get("command") or [])]
+            if command:
+                extra["command"] = " ".join(command)
+            records.append(PackageRecord(
+                pkg_type=self.pkg_type, name=str(app_id), version=version,
+                variant=f"{arch}/{module or '?'}",
+                origin_kind=(OriginKind.REPO if it.get("channel")
+                             else OriginKind.LOCAL),
+                origin_repos=(["linglong " + it["channel"]]
+                              if it.get("channel") else []),
+                size_mb=round(float(it.get("size") or 0) / BYTES_PER_MB, 1),
+                executables=command,
+                first_install=_first_install(it.get("install_time")),
+                extra=extra))
+        return records

pkgtool/backends/snap.py

@@ -0,0 +1,106 @@
+"""pkgtool.backends.snap — snap 包识别。
+
+数据源（优先文件系统，离线可用、无需 root）：
+  /var/lib/snapd/snaps/<name>_<rev>.snap   已下载的每个修订版本（持久缓存）
+  /snap/<name>/current -> <rev>            当前激活的修订
+  /snap/<name>/<rev>/bin/                  包内可执行文件
+  /snap/<name>.<app>                       /snap/bin 下的全局命令入口
+增强（失败自动降级）：
+  snap list —— 人类可读版本、追踪频道、发布者。表头随 locale 变，
+  所以按列位置解析，并要求第 3 列是纯数字修订号才认这一行。
+"""
+import glob
+import os
+import re
+import subprocess
+
+from ..base import Backend, OriginKind, PackageRecord, file_size_mb
+from ..config import CFG
+
+_SNAP_FILE_RE = re.compile(r"(.+)_(\d+)\.snap$")
+_STORE_LABEL = "snap-store"
+
+
+class SnapBackend(Backend):
+    pkg_type = "snap"
+
+    @classmethod
+    def available(cls, cfg=CFG):
+        return os.path.isdir(cfg.snap_store_dir)
+
+    def _list_info(self):
+        """解析 `snap list` 表格 → {包名: (版本, 修订, 追踪, 发布者)}。"""
+        try:
+            out = subprocess.run(["snap", "list"], capture_output=True, text=True,
+                                 timeout=self.cfg.timeout_query).stdout
+        except (OSError, subprocess.SubprocessError):
+            return {}
+        info = {}
+        for line in out.splitlines():
+            cols = line.split()
+            # 位置: [名称, 版本, 修订, 追踪, (发布者), (注记)] —— 与表头语言无关
+            if len(cols) >= 4 and cols[2].isdigit() and not cols[0][0].isupper():
+                info[cols[0]] = (cols[1], cols[2], cols[3],
+                                 cols[4] if len(cols) > 4 else "")
+        return info
+
+    def stored_revisions(self):
+        """→ {包名: {修订号: .snap 文件路径}}。clean 子命令用它找旧修订。"""
+        stored = {}
+        for f in glob.glob(os.path.join(self.cfg.snap_store_dir, "*.snap")):
+            m = _SNAP_FILE_RE.match(os.path.basename(f))
+            if m:
+                stored.setdefault(m.group(1), {})[m.group(2)] = f
+        return stored
+
+    def active_revision(self, name, revs):
+        """/snap/<name>/current 符号链接指向的修订；链接缺失时取最高修订兜底。
+        注意按整数比：修订号是数字，字符串比较会得出 "9" > "10"。"""
+        try:
+            tgt = os.readlink(os.path.join(self.cfg.snap_mount_dir, name, "current"))
+            if tgt.isdigit() and tgt in revs:
+                return tgt
+        except OSError:
+            pass
+        return max(revs, key=int)
+
+    def _executables(self, name, rev):
+        cfg = self.cfg
+        exes = []
+        bin_dir = os.path.join(cfg.snap_mount_dir, name, rev, "bin")
+        if os.path.isdir(bin_dir):
+            for e in sorted(os.listdir(bin_dir)):
+                if not os.path.isdir(os.path.join(bin_dir, e)):
+                    exes.append(f"{cfg.snap_mount_dir}/{name}/current/bin/{e}")
+        for w in sorted(glob.glob(os.path.join(cfg.snap_mount_dir, "bin", "*"))):
+            wn = os.path.basename(w)
+            if wn == name or wn.startswith(name + "."):
+                exes.append(w)
+        return exes
+
+    def collect(self):
+        info = self._list_info()
+        records = []
+        for name, revs in sorted(self.stored_revisions().items()):
+            active = self.active_revision(name, revs)
+            version, tracking, publisher = "?", "", ""
+            row = info.get(name)
+            if row and row[1] == active:
+                version, _rev, tracking, publisher = row
+
+            extra = {"revision": active,
+                     "stored_revs": ",".join(sorted(revs, key=int)),
+                     "snap_file": revs[active]}
+            if tracking:
+                extra["tracking"] = tracking
+            if publisher:
+                extra["publisher"] = publisher
+            records.append(PackageRecord(
+                pkg_type=self.pkg_type, name=name, version=version,
+                # 有追踪频道 = 来自 snap store 且能自动刷新；否则只是本地缓存目录里的文件
+                origin_kind=OriginKind.REPO if tracking else OriginKind.LOCAL,
+                origin_repos=[f"{_STORE_LABEL} {tracking}".strip()] if tracking else [],
+                size_mb=file_size_mb(revs[active]),
+                install_path=f"{self.cfg.snap_mount_dir}/{name}",
+                executables=self._executables(name, active), extra=extra))
+        return records