Find out the Apps installed on corrupted? Bullseye os

[namlow]

How do I Find out the Apps installed on corrupted? Bullseye os so that I can reinstall them on a fresh copy of Bullseys os flash drive?
I mean from the rootfs of the corrupted? Bullseye OS ssd file system. Where to look for the exact name of the apps that had been installed.

[kerry_s]

Code: Select all

/var/log/apt/history.log

[namlow]

Code: Select all

/var/log/apt/history.log

Looked at it. It is too details technically.

What I want is to use the 'Add/Remove Software' in the Preferences menu windows to install the packages or apps I used.

In this window's menu I have different categories of apps/packages installed for the Programming, Office, Internet, Sound & Video, Graphics, etc. I am looking for the package names for these so that I can use the 'Add/Remove Software' to install them.

Sometimes it is quit confusing because there are too many apps/packages with the same general names.

appsPackages2.jpeg (30.7 KiB) Viewed 2604 times

appsPackages.jpg (37.32 KiB) Viewed 2604 times

[bjtheone]

That names in the menu are related but not identical to the actual package names.

[BigRedMailbox]

The usual answer to this is: dpkg --get-selections


This is, of course, assuming you can still boot it up and run the above command.

If you can't (i.e., if the card really is corrupted and unbootable), then you can use chroot to do it from having booted up on a new card. The details for this have been posted to the forum in the past. I can probably re-create those instructions if you want that.

[namlow]

That names in the menu are related but not identical to the actual package names.

Yes. This is the problem that I need to try by error to get the one I want!

[namlow]

The usual answer to this is: dpkg --get-selections


This is, of course, assuming you can still boot it up and run the above command.

If you can't (i.e., if the card really is corrupted and unbootable), then you can use chroot to do it from having booted up on a new card. The details for this have been posted to the forum in the past. I can probably re-create those instructions if you want that.

Seeing this post to late because I had reloaded my ssd's Bullseye OS with a fresh copy of the Bullseye OS; I had backup my usage data but not the installed apps/packages.

Thanks for showing me these two tools for checking the installed apps/packages. However, the dpkg --get-selections gives overwhelming info on all the packages. Good to know there is something like chroot to use instead of using the file system to check them manually.

[BigRedMailbox]

The idea is that you should plan ahead for disaster.

Do the "dpkg --get-selections" immediately after installing the base system, saving the output in a file.

Then, later on, do the same command and diff the output against the previous file. The diff will tell you what you've installed since the base install.

Obviously, none of this helps in the instant situation (especially, since you've already wiped out the old system), but it is words for the future.

[namlow]

The idea is that you should plan ahead for disaster.

Good Idea!

[rpdom]

As an alternative to dpkg --get-selections, you could use apt-mark showmanual. This will give a much shorter list. It only shows the packages that have been requested by a user, not any packages that were also installed as dependencies. Installing those packages will cause the rest of the packages to be installed automatically.

For example if I use apt to install cmake on a Lite system it also installs cmake-data libarchive13 libjsoncpp24 librhash0 libuv1. Using apt-mark showmanual will then list cmake, but not any of the other packages as they weren't explicitly requested.

Thinking about it, if I wanted to be clever, I would use apt-mark auto $blah on each package in that list on a clean build. Then running apt-mark showmanual later on will only list all the packages that I have installed in addition to the base system.
[edit]No, that's a bad idea. With everything marked as auto using apt autoremove will try to remove everything!!!![/edit]

The only thing that won't highlight is any packages that were in the base system that were later removed.

Hmm... think I'll add something to do that to my autobuild script. Could be handy.

[BigRedMailbox]

As an alternative to dpkg --get-selections, you could use apt-mark showmanual. This will give a much shorter list. It only shows the packages that have been requested by a user, not any packages that were also installed as dependencies. Installing those packages will cause the rest of the packages to be installed automatically.

This looks good. Thanks for the tip.

However, I think it should be clarified that "user" includes the base system. Someone might assume (i.e., hope) that it only means things installed by me ("the user").

So, you still have to do the thing where you make a note of what is installed in the base, before you start installing your own stuff.

[rpdom]

So, you still have to do the thing where you make a note of what is installed in the base, before you start installing your own stuff.

Yep. That's what I settled on in the end. My autobuild script does the apt-mark to get a baseline list of what is installed before it starts adding the packages I want installed. Later I can compare that list with a current one to see what I've added.

[hippy]

Not being able to find what one installed in a meaningful and concise manner seems to be a problem which has never been properly addressed in Linux, and more so on a Raspberry Pi where trying things out is encouraged.

I know I have installed things just to see what they did, then forgot about them, and can't remember what they were when I need to delete them to recover disk space.

I had written an app to analyse '/var/log/apt/history.log' and friends which gave a lovely, and prefect for me, 'on this date you sudo apt installed this' which made it easier to remember why I may have installed a particular thing, what it related to. I think it also records 'dpkg' installs and tracks things I later uninstalled, removed or purged. But then I got bitten by some annual file rotation I hadn't expected which eradicated most of the data it relied upon

I can now only identify what was installed in the last 12 months, and most of what I have was installed long before -

Code: Select all

For unknown reason
  2022-05-21    code
  2022-07-19    qemu-user
  2022-11-07    binwalk
  2022-11-24    lld
  2023-01-01    bc
  2023-01-01    git
  2023-01-01    dkms
  2023-01-01    build-essential
SoftUart device driver
  2023-01-01    raspberrypi-kernel-headers
For unknown reason
  2023-03-24    raspinfo

[BigRedMailbox]

I'd noticed that, too - that the history files only go back a certain length of time (or number of files, not sure which...)

So, again, a little disaster planning would be needed - to backup/save these files before they get deleted by the system.

The thing is, it turns out that the most critical time to be tracking this is going to be the first few days after initial installation. That's when you install most of your custom stuff. That's when you really need to keep and be able to refer back to, the history files.

[hippy]

The thing is, it turns out that the most critical time to be tracking this is going to be the first few days after initial installation. That's when you install most of your custom stuff. That's when you really need to keep and be able to refer back to, the history files.

With hindsight, I'd have written my app to read the history files on a daily basis, updating a separate file tracking new installs and removals in date order. Get that up and running within the first 12 months of a fresh install and it should be good forever and right back to 'year dot'. It wouldn't matter how rotation was set-up, if history files do disappear.

Unfortunately, by the time I realised how I should have been doing it, it was well beyond too late. As you say, most things get installed during the first few days.

Now I am migrating to a new install of Bullseye it's back on my To Do list.

[BigRedMailbox]

I usually find that for this sort of thing - where I have log files that get "rotated" - I write my script to add records to a SQLITE3 database. I use "INSERT OR IGNORE", so that I can add basically all the records (i.e., all the records currently in the primary data source - the log files) every time I run my script, knowing that most of the INSERTs will be ignored (because the record is already there). Only the new records actually get added.

[hippy]

The usual answer to this is: dpkg --get-selections

The problem with this, as with similar commands, is that it's a huge list of exactly what one has installed, the packages or components which are dependencies of some installed application, and it's not easy to determine what application was installed by the user which brought those in.

Even if one has a list from a fresh install and can filter out a lot of things, something like "apt install mono-complete" can bring in around 160 packages. A user isn't usually interested in any of those, only that they installed "mono-complete".

The tricky part for someone trying to figure it out by hand is what those packages were brought in by, what single install command they issued to get that huge set of packages.

Having looked at what I had implemented, as part of my effort to do that again but properly, looking at '/var/log/apt/history.log' and archives of it does still seem to be the best route to me. That history also contains a lot of detail but just 'Start-Date' and 'Commandline' entries are all one needs if usually using 'apt' or 'apt-get', and GUI installation and removal can be handled by jumping through a few hoops.

The hard part is figuring out what those "Commandline" entries would be when others may have used installation routes I haven't.

The following is my code to show what's in the history which is present on disk in a concise and useful format. It works for me and it would be useful to know how well it works for others, and when it doesn't, if others are willing to join the adventure.

Code: Select all

#!/usr/bin/python3

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

PRODUCT = "List Installed App History"
PACKAGE = "list.py"
VERSION = "0.00"
CHANGES = "0001"
TOUCHED = "2023-05-28 14:46:17"
LICENSE = "MIT Licensed"
DETAILS = "https://opensource.org/licenses/MIT"

# .---------------------------------------------------------------------------.
# |
# `---------------------------------------------------------------------------'

import sys;     python3 = sys.version_info[0] >= 3
import os;      windows = os.name == "nt"
import time
import gzip

# .---------------------------------------------------------------------------.
# |
# `---------------------------------------------------------------------------'

failed = []

def Failed(s):
  print(s)
  s = s.strip()
  if not s in failed:
    failed.append(s)

def ShowFailed():
  if len(failed) > 0:
    print("Failures")
    for s in failed:
      print("  {}".format(s))

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

HISTORY_FILE = "/var/log/apt/history.log"
ARCHIVE_FILE = "/var/log/apt/history.log.{}.gz"

def FindHighestNumberedArchiveFile():
  n = 0
  while os.path.isfile(ARCHIVE_FILE.format(n + 1)):
    n += 1
  return n

def FindInstalled():
  print("Listing installed app history")
  # Check the history file exists
  if not os.path.isfile(HISTORY_FILE):
    print("  No history file found")
    return
  # Find how many archives there are
  n = FindHighestNumberedArchiveFile()
  # Report status
  if   n == 0 : print("  Found history file, no archives")
  elif n == 1 : print("  Found history file and 1 archive")
  else        : print("  Found history file and {} archives".format(n))
  # Load the histories
  print("Loading history")
  # Load any archives. The archive with the highest number is the oldest, the
  # one numbered 1 is the most recent, so we load them from highest to lowest.
  while n > 0:
    ParseArchiveFile(ARCHIVE_FILE.format(n))
    n -= 1
  # Load the current history file
  ParseHistoryFile(HISTORY_FILE)

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

def ParseHistoryFile(filename):
  print("  Load history file '{}'".format(filename))
  with open(filename, "r") as f:
    for s in f:
      ParseLine(s)

def ParseArchiveFile(filename):
  print("  Load archive file '{}'".format(filename))
  with gzip.open(filename, "r") as f:
    if python3:
      for line in f:
        s = ""
        for c in line:
          s = s + chr(c)
        ParseLine(s)
    else:
      for s in f:
        ParseLine(s)

def ParseLine(s):
  s = s.strip()
  if s != "":
    n = s.find(":")
    if n > 0:
      lhs = s[:n]
      rhs = s[n+1:].lstrip()
      if lhs == "Start-Date"   : return StartDate(rhs)
      if lhs == "End-Date"     : return
      if lhs == "Commandline"  : return CommandLine(rhs)
      if lhs == "Requested-By" : return
      if lhs == "Install"      : return Action(rhs, action)
      if lhs == "Upgrade"      : return
      if lhs == "Remove"       : return Action(rhs, action)
      if lhs == "Purge"        : return Action(rhs, action)
    Failed("    Unknown line : {}".format(s[:60]))

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

startDate = ""
action    = ""

def StartDate(s):
  # s = "2022-05-04  23:16:59"
  global startDate; startDate = s.replace("  ", " ")

def CommandLine(s):
  global action; action = ""
  if startDate != "":
    if s.startswith("apt install")     : return Action(s, "Install", "apt install")
    if s.startswith("apt remove")      : return Action(s, "Remove",  "apt remove")
    if s.startswith("apt purge")       : return Action(s, "Purge",   "apt purge")
    if s.startswith("apt-get install") : return Action(s, "Install", "apt-get install")
    if s.startswith("apt-get remove")  : return Action(s, "Remove",  "apt-get remove")
    if s.startswith("apt-get purge")   : return Action(s, "Purge",   "apt-get purge")
    if s.startswith("apt upgrade")          \
    or s.startswith("apt dist-upgrade")     \
    or s.startswith("apt full-upgrade")     \
    or s.startswith("apt autoremove")       \
    or s.startswith("apt-get upgrade")      \
    or s.startswith("apt-get dist-upgrade") \
    or s.startswith("apt-get full-upgrade") \
    or s.startswith("apt-get autoremove"):
      return
    if s == "packagekit role='install-packages'":
      action = "Install"
      return
    if s == "packagekit role='remove-packages'":
      action = "Remove"
      return
    Failed("    Unknown command : {}".format(s))

def Action(s, how="", prefix=""):
  if startDate != "":
    if how != "":
      if prefix != "":
        lst = s[len(prefix):].split()
      else:
        lst = MakePackageList(s)
      for this in lst:
        this = this.strip()
        if this != "":
          print("{:<3} {} : {:<7} {}".format("", startDate, how, this))
          RemoveFromInstalledList(this)
          if how == "Install":
           AddToInstalledList(startDate, this)

def MakePackageList(s):
  lst = []
  def Add(this):
    this = this.strip()
    if this != "":
      if this.find(", authomatic") < 0:
        n = this.find(":")
        if n > 0:
          lst.append(this[:n])
  this = ""
  depth = 0
  for c in s:
    if c == "," and depth == 0:
      Add(this)
      this = ""
    else:
      this += c
      if   c == "(" : depth += 1
      elif c == ")" : depth -= 1
  Add(this)
  return lst

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

installedList = []

def RemoveFromInstalledList(this):
  for n in range(len(installedList) - 1, -1, -1):
    date, app = installedList[n]
    if app == this:
      installedList.pop(n)

def AddToInstalledList(date, this):
  installedList.append([date, this])

def ShowInstalledList():
  print("Installed")
  if len(installedList) == 0:
    print("  None")
  else:
    for date, app in installedList:
      print("  {} : {}".format(date, app))

# *****************************************************************************
# *                                                                           *
# *
# *                                                                           *
# *****************************************************************************

def Main():
  FindInstalled()
  ShowInstalledList()
  ShowFailed()

if __name__ == "__main__":
  Main()

Code: Select all

pi@Pi3B:~/apps/installed $ python3 list.py
Listing installed app history
  Found history file and 12 archives
Loading history
  Load archive file '/var/log/apt/history.log.12.gz'
    2022-05-19 20:43:54 : Install libglibmm-2.4-dev
    2022-05-19 20:50:20 : Purge   libglibmm-2.4-dev
    2022-05-21 19:04:47 : Purge   code
    2022-05-21 19:08:21 : Purge   code-oss
    2022-05-21 19:10:51 : Install code
  Load archive file '/var/log/apt/history.log.11.gz'
  Load archive file '/var/log/apt/history.log.10.gz'
    2022-07-19 09:35:19 : Install qemu-user
  Load archive file '/var/log/apt/history.log.9.gz'
  Load archive file '/var/log/apt/history.log.8.gz'
  Load archive file '/var/log/apt/history.log.7.gz'
  Load archive file '/var/log/apt/history.log.6.gz'
    2022-11-07 14:46:48 : Install binwalk
    2022-11-24 14:29:21 : Install lld
  Load archive file '/var/log/apt/history.log.5.gz'
  Load archive file '/var/log/apt/history.log.4.gz'
    2023-01-01 15:12:01 : Install bc
    2023-01-01 15:12:01 : Install git
    2023-01-01 15:12:01 : Install dkms
    2023-01-01 15:12:01 : Install build-essential
    2023-01-01 15:12:01 : Install raspberrypi-kernel-headers
    2023-01-16 14:27:53 : Purge   ruby
    2023-01-16 14:31:49 : Purge   julia-common
  Load archive file '/var/log/apt/history.log.3.gz'
  Load archive file '/var/log/apt/history.log.2.gz'
    2023-03-14 16:57:28 : Purge   mu-editor
    2023-03-14 17:02:28 : Install mu-editor
    2023-03-14 17:03:28 : Purge   mu-editor
    2023-03-14 17:14:06 : Install mu-editor
    2023-03-14 17:16:14 : Remove  mu-editor
    2023-03-14 17:16:14 : Remove  python3-guizero
    2023-03-24 15:25:16 : Install raspinfo
  Load archive file '/var/log/apt/history.log.1.gz'
  Load history file '/var/log/apt/history.log
Installed
  2022-05-21 19:10:51 : code
  2022-07-19 09:35:19 : qemu-user
  2022-11-07 14:46:48 : binwalk
  2022-11-24 14:29:21 : lld
  2023-01-01 15:12:01 : bc
  2023-01-01 15:12:01 : git
  2023-01-01 15:12:01 : dkms
  2023-01-01 15:12:01 : build-essential
  2023-01-01 15:12:01 : raspberrypi-kernel-headers
  2023-03-24 15:25:16 : raspinfo
pi@Pi3B:~/apps/installed $

[BigRedMailbox]

The problem with this, as with similar commands, is that it's a huge list of exactly what one has installed, the packages or components which are dependencies of some installed application, and it's not easy to determine what application was installed by the user which brought those in.

Right. That's the point of using "apt-mark showmanual" (as suggested by rpdom). That's better than "dpkg --get-selections". Note that I haven't tested the apt-mark idea much (some, but not a lot), but it looks right to me.

I share your general idea that there should be a better way to do this overall - a systematic solution implemented by someone at Debian or RPi, that everyone could get behind and use.

The problem, though, is the fact that it requires pre-planning - and you usually only hear (on these forums) from people who didn't pre-plan. And, yes, that's been me on too many occasions...

Finally note that there have been other solutions promulgated by various forum regulars, who have developed their own solutions to the general problem of "How do I create and manage (a) custom version(s) of Raspbian?". No doubt, we will hear from them by and by.

[hippy]

The problem with this, as with similar commands, is that it's a huge list of exactly what one has installed, the packages or components which are dependencies of some installed application, and it's not easy to determine what application was installed by the user which brought those in.

Right. That's the point of using "apt-mark showmanual" (as suggested by rpdom). That's better than "dpkg --get-selections". Note that I haven't tested the apt-mark idea much (some, but not a lot), but it looks right to me.

I am sure that can work but does appear to require intervention or configuration by the user and doesn't seem it would be a great help when users haven't pre-planned - And I think it's fair to say few Pi users will have.

I am looking for a solution which doesn't require configuring or changing anything, will work back to when they first installed their system as long as they installed the tracking app and set it up to run on boot within the first 12 months of an install.

I share your general idea that there should be a better way to do this overall - a systematic solution implemented by someone at Debian or RPi, that everyone could get behind and use.

That's what I am aiming for but if someone wants to take that on themselves, include it as part of Raspberry Pi OS or more widely they are welcome to do that - I would be more than happy for someone else to take on its stewardship, or do it in some better way.

Using 'apt' history worked well for me. At least for the first 12 months, before I got bitten by my oversight on file rotation. I have reworked things so that shouldn't be a problem any more, and it seems solved for me. It's really now a case of making it work well for others.

[hippy]

It all seems to be going well and I am able to track app installations, removals and purgings, done via -

• apt and apt-get
• aptitude
• Raspberry Pi Recommended Software GUI
• Add/Remove Software GUI
• Synaptic GUI
• dpkg command lines for local '.deb' files

Are there any others for Raspberry Pi OS I need to consider ?

The 'dpkg' tracking is somewhat tricky and may not be entirely accurate if there are edge cases I haven't encountered, but something is better than nothing and it seems quite reliable other than that.

Once I have it handling tracking in the background I'll publish what I have. Tested so far on Pi 3B Buster 32-bit and Pi 4B Bullseye 64-bit ...

Code: Select all

pi@Pi4B:~/apps/installed $ python list.py
Listing apps installed on Pi4B
  No installed list found
  Found 'apt' history file and 1 archive
  Found 'dpkg' history file and 1 archive
Determining history
  Loading 'apt' archive file '/var/log/apt/history.log.1.gz'
    2023-04-17 18:28:58 : Install telnetd
    2023-04-17 20:00:14 : Install samba
    2023-04-17 20:17:02 : Install cmake
    2023-04-17 20:17:02 : Install gcc-arm-none-eabi
    2023-04-17 20:17:02 : Install libnewlib-arm-none-eabi
    2023-04-17 20:17:02 : Install build-essential
    2023-04-17 21:03:05 : Install espeak
    2023-04-17 21:52:29 : Install gdb-multiarch
    2023-04-17 21:55:34 : Install libusb-1.0-0-dev
    2023-04-18 12:45:28 : Install minicom
    2023-04-18 16:07:21 : Purge   nano
    2023-04-18 16:07:40 : Install nano
    2023-04-18 16:09:14 : Purge   nano
    2023-04-18 16:13:49 : Install nano
    2023-04-18 17:35:52 : Install libncursesw5-dev
    2023-04-19 21:49:06 : Install code
    2023-04-20 00:43:33 : Install mplayer
  Loading 'apt' history file '/var/log/apt/history.log'
    2023-05-29 19:02:28 : Install kicad
    2023-05-29 19:31:12 : Install gcc-10-riscv64-linux-gnu
    2023-05-30 12:48:56 : Purge   mplayer
    2023-05-30 12:49:30 : Install mplayer
    2023-05-30 12:55:50 : Install synaptic
    2023-05-30 12:58:40 : Install elvis-tiny
    2023-05-30 13:17:27 : Remove  elvis-tiny
    2023-05-30 13:18:16 : Install elvis-tiny
    2023-05-30 13:18:53 : Purge   elvis-tiny
    2023-05-30 13:24:56 : Install aptitude
    2023-05-30 13:33:29 : Install elvis-tiny
  Loading 'dpkg' archive file '/var/log/dpkg.log.1'
    2023-04-18 12:56:56 : Remove  libfuse2
    2023-04-18 16:07:22 : Remove  nano
    2023-04-18 16:07:24 : Purge   nano
    2023-04-18 16:09:14 : Remove  nano
    2023-04-18 16:09:16 : Purge   nano
  Loading 'dpkg' history file '/var/log/dpkg.log'
    2023-05-29 20:05:08 : Install tinygo
    2023-05-29 22:08:14 : Purge   tinygo
    2023-05-30 12:47:57 : Install tinygo
    2023-05-30 12:48:56 : Remove  mplayer
    2023-05-30 12:48:58 : Purge   mplayer
    2023-05-30 13:17:27 : Remove  elvis-tiny
    2023-05-30 13:18:53 : Remove  elvis-tiny
Installed on Pi4B
  2023-04-17 18:28:58 : telnetd
  2023-04-17 20:00:14 : samba
  2023-04-17 20:17:02 : cmake
  2023-04-17 20:17:02 : gcc-arm-none-eabi
  2023-04-17 20:17:02 : libnewlib-arm-none-eabi
  2023-04-17 20:17:02 : build-essential
  2023-04-17 21:03:05 : espeak
  2023-04-17 21:52:29 : gdb-multiarch
  2023-04-17 21:55:34 : libusb-1.0-0-dev
  2023-04-18 12:45:28 : minicom
  2023-04-18 16:13:49 : nano
  2023-04-18 17:35:52 : libncursesw5-dev
  2023-04-19 21:49:06 : code
  2023-05-29 19:02:28 : kicad
  2023-05-29 19:31:12 : gcc-10-riscv64-linux-gnu
  2023-05-30 12:47:57 : tinygo
  2023-05-30 12:49:30 : mplayer
  2023-05-30 12:55:50 : synaptic
  2023-05-30 13:24:56 : aptitude
  2023-05-30 13:33:29 : elvis-tiny
pi@Pi4B:~/apps/installed $

[hippy]

When it comes to tracking what's installed, what one might want to also install on a fresh system, could be removed to free-up disk space, what's completely missing are those things which get installed using 'git', things from Raspberry Pi and others -

Code: Select all

pico-sdk
pico-extras
pico-examples
pico-playground
pico-project-generator
picoprobe
openocd
python-build-hat
micropython
circuitpython
tinyusb
OpenPicoRTOS
RP2040-FreeRTOS
picoreg
fuzix
pshell
luapico

And I know I have more which I have forgotten where they were placed.

Does anyone know of any mechanism short of walking the entire disk to determine which things were 'git installed' ?

[bls]

When it comes to tracking what's installed, what one might want to also install on a fresh system, could be removed to free-up disk space, what's completely missing are those things which get installed using 'git', things from Raspberry Pi and others -

Code: Select all

pico-sdk
pico-extras
pico-examples
pico-playground
pico-project-generator
picoprobe
openocd
python-build-hat
micropython
circuitpython
tinyusb
OpenPicoRTOS
RP2040-FreeRTOS
picoreg
fuzix
pshell
luapico

And I know I have more which I have forgotten where they were placed.

Does anyone know of any mechanism short of walking the entire disk to determine which things were 'git installed' ?

Judiciously save and search your bash command history?

[bjtheone]

What about wandering fully away and using snap or manually? Or do you just declare "in that lies madness, don't do it"

[hippy]

Judiciously save and search your bash command history?

Not sure why you added the 'eye-roll' icon as if that's somehow the solution. My command history doesn't go back three years or more and people shouldn't have to do the work themselves or continually take steps to facilitate what a computer should be able to figure out for itself.

And my command history won't help at all when it comes to what other users may have installed or may have been installed using a GUI installer.

What about wandering fully away and using snap or manually? Or do you just declare "in that lies madness, don't do it"

Not sure how you mean by using snap or manually. The challenge here is to identify what's been installed regardless of how a user chose to install things, without forcing them into any particular course or onerous effort.

I have tried to keep note of what I install and remove but that is inevitably incomplete or incorrect through forgetting to do so. Most people won't, and won't realise they perhaps should have, until it comes to wanting to know what has been installed.

[bls]

Judiciously save and search your bash command history?

Not sure why you added the 'eye-roll' icon as if that's somehow the solution. My command history doesn't go back three years or more and people shouldn't have to do the work themselves or continually take steps to facilitate what a computer should be able to figure out for itself.

And my command history won't help at all when it comes to what other users may have installed or may have been installed using a GUI installer.

Eye-roll because bash command history searching is ad hoc, but seems like it could work. One could automate regular (nightly? weekly?) history searching to ensure that nothing gets lost. I set HISTSIZE to 32K and have yet to overflow it in a couple of years.

And, while you're correct that command history won't help with things installed via a GUI, one could use it to help with the git install commands you mentioned.