Cobble

Post install. Perfected.

Reproducible post-install configuration for Linux — install packages, mount shares, link folders, and resume after a reboot. You describe your setup once as a profile; Cobble applies it, and you can run the same profile again after a reinstall to get your machine back exactly as you like it.

Built and tested on Linux Mint. See Distro support for where it works today.

Forged with Python on Linux.

Features

• Declarative profiles — your setup is data (YAML), not a script you have to maintain. Build and edit it entirely in the interface; you never have to touch YAML unless you want to.
• A setup wizard for first-time users, and full editors for building profiles section by section.
• Dry run rehearses a profile without changing anything.
• Check — a pre-flight pass that validates every step, confirms downloads are reachable, and checks disks are mounted, before you run for real.
• Resume after reboot — if a step needs a restart, Cobble saves its place and carries on afterwards.
• Keep your profile on persistent storage so it survives a reinstall.

Requirements

• Python 3, PyQt5, and PolicyKit (policykit-1). ./install.sh installs what is missing.
• Optional: python3-ruamel.yaml, which lets Cobble preserve comments when it saves edited sections. It works without it.

Running it

./install.sh

This installs any missing dependencies and launches the app. On first run, Cobble offers a wizard that builds a starter profile for you; decline it and you start with an empty profile to fill in yourself.

Recommended first-run sequence: press Check (validates everything, changes nothing), then Forge system with Dry run ticked (a rehearsal), then untick Dry run for the real thing.

A full user guide is built in — press Help in the app, or open docs/guide.html.

To add a Cobble entry to your applications menu, run:

./install-desktop.sh

This installs a menu launcher and icon for the current user, and also writes a double-clickable cobble.desktop into the Cobble folder, both pointing at wherever you cloned it. Run it again if you move the folder.

Note: keep the Cobble folder outside any directory the Desktop section relinks (not in ~/Desktop, ~/Documents, etc.). ~/cobble is a good home. Cobble refuses to relink a folder it is running from inside, and tells you so.

How it is organised

app/            the engine (generic; contains no personal data)
  main.py         PyQt5 interface
  runner.py       the execution engine and step handlers
  checks.py       Check mode (validate without changing anything)
  schema.py       the declared shape of every step type
  profile.py      profile discovery and loading
  wizard.py       the first-run setup wizard
  i18n.py         translation loader
library/          generic building-block sections the wizard assembles from
profiles/
  example/        a documented reference profile (study it; not run by default)
scripts/          generic scripts shared by the engine (empty by default)
docs/             the user guide, generated step reference, and images
locale/           translation template (.pot); languages added by contributors
tools/            gen_docs.py, gen_pot.py

Engine vs profile

The engine — everything under app/ — is generic and contains nobody's personal setup. A profile is one person's configuration: which sections run, in what order, their settings, and any personal scripts.

Profiles live in their own named folders under ~/.config/cobble/. A profile is used in place, so you can keep yours on a data disk or NAS and it survives a reinstall — after reinstalling, mount the disk and use Load profile… to point at it.

The profiles/example profile is a documented reference: it demonstrates every step type with placeholder values. It is marked read-only-for-running (a banner explains this in the app) so you cannot run its placeholders by accident. Study it or copy from it; remove reference_only: true from its settings.yaml to turn it into a profile of your own.

Distro support

Cobble is designed to be distro-agnostic: it detects your distro family, and some steps (like the system upgrade) already choose the right commands for it.

Today it is complete and tested on the Debian family (Linux Mint, Ubuntu, Debian). Other families (Fedora, Arch, openSUSE) are partially implemented and not yet tested — several package-related steps are Debian-only for now. Treat Cobble as a Debian-family tool at present, with wider support as work in progress. Contributions to extend it are welcome.

Contributing

• Step types are declared in app/schema.py. That one declaration drives Check-mode validation, the generated step reference, and the GUI editor forms. Regenerate the reference with python3 tools/gen_docs.py; verify the schema matches the handlers with python3 app/schema.py.
• Translations: see docs/translating.md. Regenerate the string template with python3 tools/gen_pot.py.

Licence

See LICENSE.