APTLY(1)

📦
version 1.6.2 · 3 versions
, in debian trixie, ubuntu questing, ubuntu resolute, ubuntu stonking

🎀 APTLY(1) 🎀

Hey bestie! Welcome to the aptly manual — yes, that aptly, the Debian repository management tool. This is part 1 of 6, and we are going to vibe through every single flag and config like the main character we are. 💅✨

✨ NAME ✨

  • aptly — Debian repository management tool

🌸 SYNOPSIS 🌸

Common command format:

aptly [global options...] command subcommand [options...] arguments

aptly has integrated help that matches contents of this manual page, to get help, prepend help to command name:

aptly help mirror create

🦋 DESCRIPTION 🦋

aptly is a tool to create partial and full mirrors of remote repositories, manage local repositories, filter them, merge, upgrade individual packages, take snapshots and publish them back as Debian repositories.

aptly’s goal is to establish repeatability and controlled changes in a package-centric environment. aptly allows one to fix a set of packages in a repository, so that package installation and upgrade becomes deterministic. At the same time aptly allows one to perform controlled, fine-grained changes in repository contents to transition your package environment to new version.

💖 CONFIGURATION 💖

aptly looks for configuration file first in ~/.aptly.conf then in /usr/local/etc/aptly.conf and /etc/aptly.conf. If no config file found (or they are not readable), a new one is created in the home directory. If -config= flag is specified, aptly would use config file at specified location. Also aptly needs root directory for database, package and published repository storage. If not specified, directory defaults to ~/.aptly/, it will be created if missing.

With aptly version 1.6.0, yaml configuration with inline documentation is supported and recommended (see debian/aptly.conf).

The legacy json configuration is still supported (and also supports comments):

           // vim: : filetype=json
           // json configuration file with comments
           // validate with: sed ’/\/\//d’ aptly.conf | json_pp
           {

           // Aptly Configuration File
           ////////////////////////////

             // Root directory for:
             // - downloaded packages (`rootDir`/pool)
             // - database (`rootDir`/db)
             // - published repositories (`rootDir`/public)
             "rootDir": "~/.aptly",

             // Number of attempts to open database if it’s locked by other instance
             // * -1 (no retry)
             "databaseOpenAttempts": -1,

             // Log Level
             // * debug
             // * info
             // * warning
             // * error
             "logLevel": "info",

             // Log Format
             // * default (text)
             // * json
             "logFormat": "default",

             // Default Architectures
             // empty array defaults to all available architectures
             "architectures": [],

             // Follow contents of `Suggests:` field when processing dependencies for the package
             "dependencyFollowSuggests": false,

             // Follow contents of `Recommends:` field when processing dependencies for the package
             "dependencyFollowRecommends": false,

             // When dependency looks like `package-a | package-b`, follow both variants always
             "dependencyFollowAllVariants": false,

             // Follow dependency from binary package to source package
             "dependencyFollowSource": false,

             // Log additional details while resolving dependencies (useful for debugging)
             "dependencyVerboseResolve": false,

             // Specifies paramaters for short PPA url expansion
             // empty defaults to output of `lsb_release` command
             "ppaDistributorID": "ubuntu",

             // Codename for short PPA url expansion
             "ppaCodename": "",

             // OBSOLETE
             // in aptly up to version 1.0.0, package files were stored in internal package pool
             // with MD5-dervied path, since 1.1.0 package pool layout was changed;
             // if option is enabled, aptly stops checking for legacy paths;
             // by default option is enabled for new aptly installations and disabled when
             // upgrading from older versions
             "skipLegacyPool": true,

           // Aptly Server
           ////////////////

             // Serve published repos as well as API
             "serveInAPIMode": false,

             // Enable metrics for Prometheus client
             "enableMetricsEndpoint": false,

             // Not implemented in this version.
             // Enable API documentation on /docs
             //"enableSwaggerEndpoint": false,

             // OBSOLETE: use via url param ?_async=true
             "AsyncAPI": false,

           // Database
           ////////////

             // Database backend
             // Type must be one of:
             // * leveldb (default)
             // * etcd
             "databaseBackend": {
               // LevelDB
               "type": "leveldb",
               // Path to leveldb files
               // empty dbPath defaults to `rootDir`/db
               "dbPath": ""

               // // etcd
               // "type": "etcd",
               // // URL to db server
               // "url": "127.0.0.1:2379"
             },

           // Mirroring
           /////////////

             // Downloader
             // * "default"
             // * "grab"      (more robust)
             "downloader": "default",

             // Number of parallel download threads to use when downloading packages
             "downloadConcurrency": 4,

             // Limit in kbytes/sec on download speed while mirroring remote repositories
             "downloadSpeedLimit": 0,

             // Number of retries for download attempts
             "downloadRetries": 0,

             // Download source packages per default
             "downloadSourcePackages": false,

           // Signing
           ///////////

             // GPG Provider
             // * "internal" (Go internal implementation)
             // * "gpg"      (External `gpg` utility)
             "gpgProvider": "gpg",

             // Disable signing of published repositories
             "gpgDisableSign": false,

             // Disable signature verification of remote repositories
             "gpgDisableVerify": false,

           // Publishing
           //////////////

             // Do not publish Contents files
             "skipContentsPublishing": false,

             // Do not create bz2 files
             "skipBz2Publishing": false,

           // Storage
           ///////////

             // Filesystem publishing endpoints
             //
             // aptly defaults to publish to a single publish directory under `rootDir`/public. For
             // a more advanced publishing strategy, you can define one or more filesystem endpoints in the
             // `FileSystemPublishEndpoints` list of the aptly configuration file. Each endpoint has a name
             // and the following associated settings.
             //
             // In order to publish to such an endpoint, specify the endpoint as `filesystem:endpoint-name`
             // with `endpoint-name` as the name given in the aptly configuration file. For example:
             //
             //   `aptly publish snapshot wheezy-main filesystem:test1:wheezy/daily`
             //
             "FileSystemPublishEndpoints": {
               // // Endpoint Name
               // "test1": {
               //    // Directory for publishing
               //    "rootDir": "/opt/srv/aptly_public",

               //    // File Link Method for linking files from the internal pool to the published directory
               //    // * hardlink
               //    // * symlink
               //    // * copy
               //    "linkMethod": "hardlink",

               //    // File Copare Method for comparing existing links from the internal pool to the published directory
               //    // Only used when "linkMethod" is set to "copy"
               //    // * md5 (default: compare md5 sum)
               //    // * size (compare file size)
               //    "verifyMethod": "md5"
               // }
             },

             // S3 Endpoint Support
             //
             // cloud storage). First, publishing
             // endpoints should be described in aptly configuration file. Each endpoint has name
             // and associated settings.
             //
             // In order to publish to S3, specify endpoint as `s3:endpoint-name:` before
             // publishing prefix on the command line, e.g.:
             //
             //   `aptly publish snapshot wheezy-main s3:test:`
             //
             "S3PublishEndpoints": {
               // // Endpoint Name
               // "test": {

               //    // Amazon region for S3 bucket
               //    "region": "us-east-1",

               //    // Bucket name
               //    "bucket": "test-bucket",

               //    // Endpoint (optional)
               //    // When using S3-compatible cloud storage, specify hostname of service endpoint here,
               //    // region is ignored if endpoint is set (set region to some human-readable name)
               //    // (should be left blank for real Amazon S3)
               //    "endpoint": "",

               //    // Prefix (optional)
               //    // publishing under specified prefix in the bucket, defaults to
               //    // no prefix (bucket root)
               //    "prefix": "",

               //    // Default ACLs (optional)
               //    // assign ACL to published files (one of the canned ACLs in Amazon
               //    // terminology). Useful values: `private` (default), `public-read` (public
               //    // repository) or `none` (don’t set ACL). Public repositories could be consumed by `apt` using
               //    // HTTP endpoint (Amazon bucket should be configured for "website hosting"),
               //    // for private repositories special apt S3 transport is required.
               //    "acl": "private",

               //    // Credentials (optional)
               //    // Amazon credentials to access S3 bucket. If not supplied,
               //    // environment variables `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`
               //    // are used.
               //    "awsAccessKeyID": "",
               //    "awsSecretAccessKey": "",

               //    // Storage Class (optional)
               //    // Amazon S3 storage class, defaults to `STANDARD`. Other values
               //    // available: `REDUCED_REDUNDANCY` (lower price, lower redundancy)
               //    "storageClass": "STANDARD",

               //    // Encryption Method (optional)
               //    // Server-side encryption method, defaults to none. Currently
               //    // the only available encryption method is `AES256`
               //    "encryptionMethod": "none",

               //    // Plus Workaround (optional)
               //    // Workaround misbehavior in apt and Amazon S3 for files with `+` in filename by
               //    // creating two copies of package files with `+` in filename: one original
               //    // and another one with spaces instead of plus signs
               //    // With `plusWorkaround` enabled, package files with plus sign
               //    // would be stored twice. aptly might not cleanup files with spaces when published
               //    // repository is dropped or updated (switched) to new version of repository (snapshot)
               //    "plusWorkaround": false,
               //    // Disable MultiDel (optional)
               //    // For S3-compatible cloud storages which do not support `MultiDel` S3 API,
               //    // enable this setting (file deletion would be slower with this setting enabled)
               //    "disableMultiDel": false,

               //    // ForceSig2 (optional)
               //    // Disable Signature V4 support, useful with non-AWS S3-compatible object stores
               //    // which do not support SigV4, shouldn’t be enabled for AWS
               //    "forceSigV2": false,

               //    // ForceVirtualHostedStyle (optional)
               //    // Disable path style visit, useful with non-AWS S3-compatible object stores
               //    // which only support virtual hosted style
               //    "forceVirtualHostedStyle": false,

               //    // Debug (optional)
               //    // Enables detailed request/response dump for each S3 operation
               //    "debug": false
               // }
             },

             // Swift Endpoint Support
             //
             // aptly could be configured to publish repository directly to OpenStack Swift. First,
             // publishing endpoints should be described in aptly configuration file. Each endpoint
             // has name and associated settings.
             //
             // In order to publish to Swift, specify endpoint as `swift:endpoint-name:` before
             // publishing prefix on the command line, e.g.:
             //
             //   `aptly publish snapshot jessie-main swift:test:`
             //
             "SwiftPublishEndpoints": {
               // Endpoint Name
               // "test": {

               //    // Container Name
               "container": "taylor1",

               //    // Prefix (optional)
               //    // Publish under specified prefix in the container, defaults to no prefix (container root)
               "prefix": "",

               //    // Credentials (optional)
               //    // OpenStack credentials to access Keystone. If not supplied, environment variables `OS_USERNAME` and `OS_PASSWORD` are used
               "osname": "",
               "password": "",

               //    // Tenant (optional)
               //    // OpenStack tenant name and id (in order to use v2 authentication)
               "tenant": "",
               "tenantid": "",

               //    // Auth URL (optional)
               //    // Full url of Keystone server (including port, and version).
               //    // Example `http://identity.example.com:5000/v2.0`
               "authurl": ""
               // }
             },

             // Azure Endpoint Support
             //
             // aptly can be configured to publish repositories directly to Microsoft Azure Blob
             // Storage. First, publishing endpoints should be described in the aptly
             // configuration file. Each endpoint has its name and associated settings.
             "AzurePublishEndpoints": {
               // // Endpoint Name
               // "test": {

               //    // Container Name
               "container": "container1",

               //    // Prefix (optional)
               //    // Publishing under specified prefix in the container, defaults to no prefix (container root)
               "prefix": "",

               //    // Credentials
               //    // Azure storage account access key to access blob storage
               "accountName": "",
               "accountKey": "",

               //    // Endpoint URL
               //    // See: Azure documentation https://docs.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string
               //    // defaults to "https://<accountName>.blob.core.windows.net"
               "endpoint": ""
               // }
             },

             // Package Pool
             // Location for storing downloaded packages
             // Type must be one of:
             // * local
             // * azure
             "packagePoolStorage": {
               // Local Pool
               "type": "local",
               // Local Pool Path
               // empty path defaults to `rootDir`/pool
               "path": ""

               // // Azure Azure Blob Storage Pool
               // "type": "azure",
               // "container": "pool1",

               // // Prefix (optional)
               // // Publishing under specified prefix in the container, defaults to no prefix (container root)
               // "prefix": "",

               // // Credentials
               // // Azure storage account access key to access blob storage
               // "accountName": "",
               // "accountKey": "",

               // // Endpoint URL
               // // See: Azure documentation https://docs.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string
               // // defaults to "https://<accountName>.blob.core.windows.net"
               // "endpoint": ""
             }

           // End of config
           }

🔍 PACKAGE QUERY 🔍

okay bestie listen UP because this section is the moment 💅 some commands let you hand over a package query to say exactly which packages you want to mess with. The syntax is almost a carbon copy of the reprepro query language, so if you've met reprepro before, this is giving déjà vu 🫶

A query is built out of these little simple terms:

  • direct package reference — points at exactly one package. The format is identical to the way aptly lists packages in show commands with the -with-packages flag: name_version_arch, like:
libmysqlclient18_5.5.35-rel33.0-611.squeeze_amd64
  • dependency condition — syntax follows the Debian dependency specification: package_name followed by an optional version specification and architecture limit, e.g.:
mysql-client (>= 3.6)
  • query against package fields — same syntax as dependency conditions, but instead of the package name you use a field name, e.g. Priority (optional).

✨ Supported fields ✨

  • all field names from Debian package control files are supported except for Filename, MD5sum, SHA1, SHA256, Size, Files, Checksums-SHA1, Checksums-SHA256.
  • $Source is a name of source package (for binary packages)
  • $SourceVersion is a version of source package
  • $Architecture is Architecture for binary packages and source for source packages; when matching with the equal (=) operator, a package with any architecture matches all architectures but source.
  • $Version has the same value as Version, but comparison operators use Debian version precedence rules
  • $PackageType is deb for binary packages and source for source packages

✨ Operators ✨

  • = — strict match, and this is also the default operator if you give no operator at all
  • >=, <=, =, >> (strictly greater), << (strictly less) — lexicographical comparison for all fields, plus special rules when comparing package versions
  • % — pattern matching, like shell patterns; supported special symbols are [^]?*, e.g.: $Version (% 3.5-*)
  • ~ — regular expression matching, e.g.: Name (~ .*-dev)

Simple terms can be combined into more complex queries using the operators , (and), | (or) and ! (not), and parentheses () are used to change operator precedence. A match value can be enclosed in single (’) or double (") quotes if you need to resolve ambiguity, and quotes inside a quoted string should be escaped with a slash (\).

✨ Examples ✨

  • mysql-client — matches package mysql-client of any version and architecture (including source), and also matches packages that Provide: mysql-client.
  • mysql-client (>= 3.6) — matches package mysql-client with version greater or equal to 3.6. Valid operators for version are: >=, <=, =, >> (strictly greater), << (strictly less).
  • mysql-client {i386} — matches package mysql-client on architecture i386; architecture all matches all architectures but source.
  • mysql-client (>= 3.6) {i386} — version and architecture conditions combined 💫
  • libmysqlclient18_5.5.35-rel33.0-611.squeeze_amd64 — direct package reference.
  • $Source (nginx) — all binary packages with nginx as source package.
  • !Name (~ .*-dev), mail-transport, $Version (>= 3.5) — matches all packages that provide mail-transport with a name that has no suffix -dev and with version greater or equal to 3.5.
heads up bestie 🚨 when you specify a query on the command line, you may have to quote it according to shell rules so it stays a single argument:
aptly repo import percona stable ’mysql-client (>= 3.6)’

🎀 PACKAGE DISPLAY FORMAT 🎀

Some aptly commands (aptly mirror search, aptly package search, ...) support the -format flag, which lets you customize how search results get printed ✨ Golang templates are used to specify the display format, and all package stanza fields are available to the template. On top of the package stanza fields, aptly gives you these extra ones:

  • Key — internal aptly package ID, unique for all packages in aptly (combination of ShortKey and FilesHash).
  • FilesHash — hash that includes MD5 of all packages files.
  • ShortKey — package ID, which is unique in a single list (mirror, repo, snapshot, ...), but not unique in the whole aptly package collection.

For example, the default aptly display format could be presented with the following template: {{.Package}}_{{.Version}}_{{.Architecture}}. To display package name with dependencies: {{.Package}} | {{.Depends}}. More information on Golang template syntax: http://godoc.org/text/template

👑 GLOBAL OPTIONS 👑

  • -architectures= — list of architectures to consider during (comma-separated), default to all available
  • -config= — location of configuration file (default locations in order: ~/.aptly.conf, /usr/local/etc/aptly.conf, /etc/aptly.conf)
  • -db-open-attempts=10 — number of attempts to open DB if it’s locked by other instance
  • -dep-follow-all-variants — when processing dependencies, follow a & b if dependency is ’a|b’
  • -dep-follow-recommends — when processing dependencies, follow Recommends
  • -dep-follow-source — when processing dependencies, follow from binary to Source packages
  • -dep-follow-suggests — when processing dependencies, follow Suggests
  • -dep-verbose-resolve — when processing dependencies, print detailed logs
  • -gpg-provider= — PGP implementation ("gpg", "gpg1", "gpg2" for external gpg or "internal" for Go internal implementation)

🪞 CREATE NEW MIRROR 🪞

bestie, this is where the magic starts. The synopsis is:

aptly mirror create name archive url distribution [component1 ...]

So you're making a mirror literally named name of a remote repository. aptly is down for both regular AND flat Debian repos exported over HTTP and FTP (yes, both, we love range 💅). aptly will try to download the Release file from the remote repo and verify its signature — no fake releases on her watch. And the command line format? It resembles the apt utility sources.list(5), so if you already speak apt, you already speak this.

PPA urls can be given in the short format, which is giving convenience:

$ aptly mirror create name ppa:user/project

Example time, periodt:

$ aptly mirror create wheezy-main http://mirror.yandex.ru/debian/ wheezy main

✨ Options ✨

  • -filter= — filter packages in the mirror. Use @file to read the filter from a file, or @- for stdin.
  • -filter-with-deps — when filtering, also include the dependencies of the packages that matched.
  • -force-architectures — (only works when you pass an architecture list) skips the check that the requested architectures are actually listed in the Release file.
  • -force-components — (only with a component list) skips the check that the requested components are listed in the Release file.
  • -ignore-signatures — turns off verification of Release file signatures.
  • -keyring= — the gpg keyring to use when verifying the Release file. You can pass it more than once, no cap.
  • -max-tries=1 — max download tries before the process fails with a download error. Default is 1.
  • -with-installer — downloads the extra not-packaged installer files too.
  • -with-sources — grabs source packages on top of binary packages.
  • -with-udebs — downloads .udeb packages (that's Debian installer support, iconic).

📋 LIST MIRRORS 📋

aptly mirror list

This shows the full list of remote repository mirrors. All of them. Every single one.

Example:

$ aptly mirror list

✨ Options ✨

  • -json — display the list in JSON format.
  • -raw — display the list in machine-readable format.

🔍 SHOW DETAILS ABOUT MIRROR 🔍

aptly mirror show name

Shows detailed info about the mirror. Receipts, basically.

Example:

$ aptly mirror show wheezy-main

✨ Options ✨

  • -json — display the record in JSON format.
  • -with-packages — show the detailed list of packages and versions stored in the mirror.

🗑️ DELETE MIRROR 🗑️

aptly mirror drop name

drop deletes the information about the remote repository mirror name. Important: the package data is not deleted (because it could still be used by other mirrors or snapshots — sharing is caring).

Heads up bestie: if the mirror is used as a source to create a snapshot, aptly will refuse to delete it. Use the -force flag to override that. She's just looking out for you. 😭

Example:

$ aptly mirror drop wheezy-main

✨ Options ✨

  • -force — force mirror deletion even if it's used by snapshots.

🔄 UPDATE MIRROR 🔄

aptly mirror update name

Updates the remote mirror — downloads package files and meta information. When a mirror is first created, you should run this command for the first time to actually fetch the mirror contents. And you can run it multiple times to get updated repository contents, so it stays fresh ✨. If it gets interrupted, no stress — the command can be safely restarted.

Example:

$ aptly mirror update wheezy-main

✨ Options ✨

  • -download-limit=0 — limit download speed (in kbytes/sec). Default 0.
  • -downloader=default — the downloader to use (e.g. grab). Default is default.
  • -force — force update the mirror even if it's locked by another process.
  • -ignore-checksums — ignore checksum mismatches while downloading package files and metadata.
  • -ignore-signatures — disable verification of Release file signatures.
  • -keyring= — the gpg keyring to use when verifying the Release file (can be specified multiple times).
  • -max-tries=1 — max download tries until the process fails with a download error. Default 1.
  • -skip-existing-packages — don't check file existence for packages listed in the mirror's internal database.

🏷️ RENAMES MIRROR 🏷️

aptly mirror rename old-name new-name

This command changes the name of the mirror. And btw: mirror names should be unique. One name, one mirror, no duplicates.

Example:

$ aptly mirror rename wheezy-min wheezy-main

✏️ EDIT MIRROR SETTINGS ✏️

aptly mirror edit name

edit lets you change the settings of a mirror: filters, the list of architectures, all of it. Glow-up mode.

Example:

$ aptly mirror edit -filter=nginx -filter-with-deps some-mirror

✨ Options ✨

  • -archive-url= — archive url is the root of the archive.
  • -filter= — filter packages in the mirror. Use @file to read the filter from a file, or @- for stdin.
  • -filter-with-deps — when filtering, include dependencies of matching packages as well.
  • -ignore-signatures — disable verification of Release file signatures.
  • -keyring= — the gpg keyring to use when verifying the Release file (can be specified multiple times).
  • -with-installer — download the additional not-packaged installer files.
  • -with-sources — download source packages in addition to binary packages.
  • -with-udebs — download .udeb packages (Debian installer support).

🔎 SEARCH MIRROR FOR PACKAGES MATCHING QUERY 🔎

aptly mirror search name [package-query]

search displays the list of packages in the mirror that match the package query.

If you don't specify a query, all the packages are displayed. Everything. The whole menu.

Example:

$ aptly mirror search wheezy-main '$Architecture (i386), Name (% *-dev)'

✨ Options ✨

  • -format= — custom format for result printing.
  • -with-deps — include dependencies in the search results.

📦 ADD PACKAGES TO LOCAL REPOSITORY 📦

aptly repo add name (<package file.deb>|<directory>)...

This command adds packages to a local repository from .deb, .udeb (binary packages) and .dsc (source packages) files. When you import from a directory, aptly does a recursive scan looking for all files matching .[u]deb or .dsc patterns. Every file she discovers gets analyzed to extract metadata, a package gets created from it, and then it's added to the database. Files are imported into the internal package pool. For source packages, all required files are added automatically as well — and any extra files for a source package should live in the same directory as the *.dsc file. iykyk.

Example:

$ aptly repo add testing myapp-0.1.2.deb incoming/

✨ Options ✨

  • -force-replace — when adding a package that conflicts with an existing package, remove the existing one instead.
  • -remove-files — remove files that have been imported successfully into the repository.

📋 COPY PACKAGES BETWEEN LOCAL REPOSITORIES 📋

aptly repo copy src-name dst-name package-query ...

copy copies packages matching package-query from the local repo src-name to the local repo dst-name. Simple as.

Example:

$ aptly repo copy testing stable 'myapp (=0.1.12)'

✨ Options ✨

  • -dry-run — don't copy, just show what would be copied.
  • -with-deps — follow dependencies when processing package-spec.

🆕 CREATE LOCAL REPOSITORY 🆕

aptly repo create name [ from snapshot snapshot ]

Creates a local package repository. When created it's empty — packages can then be added from files, copied or moved from another local repository, or imported from a mirror. Build it up like a playlist ✨.

If a local package repository is created from snapshot, the repo's initial contents are copied from the snapshot's contents.

Example:

$ aptly repo create testing

$ aptly repo create mysql35 from snapshot mysql-35-2017

✨ Options ✨

  • -comment= — any text that would be used to describe the local repository.
  • -component=main — default component when publishing. Default is main.
  • -distribution= — default distribution when publishing.
  • -uploaders-file= — the uploaders.json to be used when including .changes into this repository.

💀 DELETE LOCAL REPOSITORY 💀

aptly repo drop name

Drops information about deletions from the local repo. Important, bestie: the package data is not deleted (since it could still be used by other mirrors or snapshots).

Example:

$ aptly repo drop local-repo

✨ Options ✨

  • -force — force local repo deletion even if it's used by snapshots.

✏️ EDIT PROPERTIES OF LOCAL REPOSITORY ✏️

aptly repo edit name

edit lets you change the metadata of a local repository: comment, default distribution and component. Little makeover moment 🎀.

Example:

$ aptly repo edit -distribution=wheezy testing

✨ Options ✨

  • -comment= — any text that would be used to describe the local repository.
  • -component= — default component when publishing.
  • -distribution= — default distribution when publishing.
  • -uploaders-file= — the uploaders.json to be used when including .changes into this repository.

🚚 IMPORT PACKAGES FROM MIRROR TO LOCAL REPOSITORY 🚚

aptly repo import src-mirror dst-repo package-query ...

import looks up packages matching package-query in the mirror src-mirror and copies them to the local repo dst-repo. Moving them from the big pond to your pond 🐟.

Example:

$ aptly repo import wheezy-main testing nginx

✨ Options ✨

  • -dry-run — don't import, just show what would be imported.
  • -with-deps — follow dependencies when processing package-spec.

📃 LIST LOCAL REPOSITORIES 📃

aptly repo list

list shows the full list of local package repositories. All of them, front to back.

Example:

$ aptly repo list

✨ Options ✨

  • -json — display the list in JSON format.
  • -raw — display the list in machine-readable format.

🔀 MOVE PACKAGES BETWEEN LOCAL REPOSITORIES 🔀

aptly repo move src-name dst-name package-query ...

move moves packages matching package-query from the local repo src-name to the local repo dst-name. And remember: use @file to read package queries from a file, or @- for stdin.

Example:

$ aptly repo move testing stable 'myapp (=0.1.12)'

✨ Options ✨

  • -dry-run — don't move, just show what would be moved.
  • -with-deps — follow dependencies when processing package-spec.

❌ REMOVE PACKAGES FROM LOCAL REPOSITORY ❌

aptly repo remove name package-query ...

This command removes packages matching package-query from the local repository name. And here's the tea: if the removed packages are not referenced by other repos or snapshots, they can be removed completely (files included) by running aptly db cleanup.

Again: use @file to read package queries from a file, or @- for stdin.

Example:

$ aptly repo remove testing 'myapp (=0.1.12)'

✨ Options ✨

  • -dry-run — don't remove, just show what would be removed.

👀 SHOW DETAILS ABOUT LOCAL REPOSITORY 👀

aptly repo show name

show shows the full information about a local package repository. The whole lore.

ex:

$ aptly repo show testing

✨ Options ✨

  • -json — display the record in JSON format.
  • -with-packages — show the list of packages.

🏷️ RENAMES LOCAL REPOSITORY 🏷️

aptly repo rename old-name new-name

This command changes the name of the local repo. And yes — the local repo name should be unique. No two repos wearing the same name, that's not the vibe.

Example:

$ aptly repo rename wheezy-min wheezy-main

🔍 SEARCH REPO FOR PACKAGES MATCHING QUERY

aptly repo search name [package-query]

So search shows you the list of packages sitting in a local repository that match a package query. That's it. That's the whole job. 💅

And if you don't pass a query at all? Every single package shows up. All of them. The whole roster. 🌈

Example:

$ aptly repo search my-software '$Architecture (i386), Name (% *-dev)'

Options:

  • -format= — custom format for result printing
  • -with-deps — include dependencies into search results

📥 ADD PACKAGES TO LOCAL REPOSITORIES BASED ON .CHANGES FILES

aptly repo include (<file.changes>|<directory>)...

include goes hunting for .changes files in the arguments you gave it, or in the directories you pointed at. Each .changes file gets verified, parsed, and every referenced file is dropped into its own temporary directory and added into the local repository. And here's the vibe: files that imported successfully get removed by default. Gone. Slayed. 🗑️✨

Oh and also — uploads can be locked down with an uploaders.json file. The rules in that file gate uploads based on the GPG key ID of the .changes file signature, plus queries on .changes file fields. Very gatekeep-y of it, love that. 🚪

Example:

$ aptly repo include -repo=foo-release incoming/

Options:

  • -accept-unsigned — accept unsigned .changes files
  • -force-replace — when adding a package that conflicts with an existing package, remove the existing package
  • -ignore-signatures — disable verification of the .changes file signature
  • -keyring= — gpg keyring to use when verifying the Release file (could be specified multiple times)
  • -no-remove-files — don't remove files that have been imported successfully into the repository
  • -repo={{.Distribution}} — which repo the files should go to; defaults to the Distribution field of the .changes file
  • -uploaders-file= — path to the uploaders.json file

📸 CREATES SNAPSHOT OF MIRROR (LOCAL REPOSITORY) CONTENTS

aptly snapshot create name (from mirror mirror-name | from repo repo-name | empty)

create name from mirror makes a persistent, immutable snapshot of a remote repository mirror. Immutable, bestie. It cannot be changed. But it can be published, or further modified using merge, pull, and other aptly features. ✨

create name from repo makes a persistent, immutable snapshot of a local repository. You can process these just like mirror snapshots, and mix them with snapshots of remote mirrors. Chaos, but organized chaos. 🦋

create name empty makes an empty snapshot — perfect as a basis for snapshot pull operations, for example. And because snapshots are immutable, making one empty snapshot should be enough. You only need the one. Periodt.

Example:

$ aptly snapshot create wheezy-main-today from mirror wheezy-main

📋 LIST SNAPSHOTS

aptly snapshot list

list shows the full list of snapshots you've created. The whole collection. 👑

Example:

$ aptly snapshot list

Options:

  • -json — display list in JSON format
  • -raw — display list in machine-readable format
  • -sort=name — display list in 'name' or creation 'time' order

👀 SHOWS DETAILS ABOUT SNAPSHOT

aptly snapshot show name

show spills the full information about a snapshot. Everything. The whole tea. ☕

Example:

$ aptly snapshot show wheezy-main

Options:

  • -json — display record in JSON format
  • -with-packages — show list of packages

✅ VERIFY DEPENDENCIES IN SNAPSHOT

aptly snapshot verify name [source ...]

verify does dependency resolution inside the snapshot name, and it can use additional snapshots listed as source to act as dependency sources. Every unsatisfied dependency gets printed out. Every last one. 😭

Example:

$ aptly snapshot verify wheezy-main wheezy-contrib wheezy-non-free

🧲 PULL PACKAGES FROM ANOTHER SNAPSHOT

aptly snapshot pull name source destination package-query ...

pull grabs new packages along with their dependencies into the snapshot name, pulling from snapshot source. And it can upgrade a package version in name using versions from source, following dependencies as it goes. A brand new snapshot destination is created as the result of all this. 🎀

Packages can be named simply as package-name, or as package queries. Your call.

Use the @file syntax to read package queries from a file, and @- to read from stdin.

Example:

$ aptly snapshot pull wheezy-main wheezy-backports wheezy-new-xorg xorg-server-server

Options:

  • -all-matches — pull all the packages that satisfy the dependency version requirements
  • -dry-run — don't create the destination snapshot, just show what would be pulled
  • -no-deps — don't process dependencies, just pull the listed packages
  • -no-remove — don't remove other package versions when pulling a package

🆚 DIFFERENCE BETWEEN TWO SNAPSHOTS

aptly snapshot diff name-a name-b

Shows you the difference in packages between two snapshots. A snapshot is literally just a list of packages, so the difference between snapshots is a difference between package lists. A package is either completely missing from one snapshot, or it's present in both but with different versions. That's the whole drama. 💀

Example:

$ aptly snapshot diff -only-matching wheezy-main wheezy-backports

Options:

  • -only-matching — display diff only for matching packages (don't display missing packages)

🧬 MERGES SNAPSHOTS

aptly snapshot merge destination source [source...]

merge merges several source snapshots into one destination snapshot. The merge happens from left to right. By default, packages with the same name-architecture pair get replaced during the merge — the package from the latest snapshot on the list wins. Winner takes all. 👑 If you run it with only one source snapshot, merge just copies that source into destination.

Example:

$ aptly snapshot merge wheezy-w-backports wheezy-main wheezy-backports

Options:

  • -latest — use only the latest version of each package
  • -no-remove — don't remove duplicate arch/name packages

🗑️ DELETE SNAPSHOT

aptly snapshot drop name

drop removes all information about a snapshot. But heads up bestie: if the snapshot is published, it can't be dropped. Nope. Not happening. 🙅

Example:

$ aptly snapshot drop wheezy-main

Options:

  • -force — remove snapshot even if it was used as source for other snapshots

🏷️ RENAMES SNAPSHOT

aptly snapshot rename old-name new-name

Changes the name of the snapshot. And the snapshot name has to be unique. No duplicates in this house. 💅

Example:

$ aptly snapshot rename wheezy-min wheezy-main

🔍 SEARCH SNAPSHOT FOR PACKAGES MATCHING QUERY

aptly snapshot search name [package-query]

search shows the list of packages in a snapshot that match a package query. 🌸

No query specified? Then all the packages get displayed. Every one.

Use the @file syntax to read a package query from a file, and @- to read from stdin.

Example:

$ aptly snapshot search wheezy-main '$Architecture (i386), Name (% *-dev)'

Options:

  • -format= — custom format for result printing
  • -with-deps — include dependencies into search results

🎛️ FILTER PACKAGES IN SNAPSHOT PRODUCING ANOTHER SNAPSHOT

aptly snapshot filter source destination package-query ...

filter filters inside snapshot source, producing another snapshot, destination. Packages can be specified simply as package-name, or as package queries.

Use the @file syntax to read package queries from a file, and @- to read from stdin.

Example:

$ aptly snapshot filter wheezy-main wheezy-required 'Priority (required)'

Options:

  • -with-deps — include dependent packages as well

🚮 REMOVE PUBLISHED REPOSITORY

aptly publish drop distribution [[endpoint:]prefix]

This command removes whatever has been published under the specified prefix, publishing endpoint, and distribution name. Poof. Gone. 🫥

Example:

$ aptly publish drop wheezy

Options:

  • -force-drop — remove the published repository even if some files could not be cleaned up
  • -skip-cleanup — don't remove unreferenced files in prefix/component

📜 LIST OF PUBLISHED REPOSITORIES

aptly publish list

Displays the list of snapshots that are currently published. ✨

Example:

$ aptly publish list

Options:

  • -json — display list in JSON format
  • -raw — display list in machine-readable format

🌐 PUBLISH LOCAL REPOSITORY

aptly publish repo name [[endpoint:]prefix]

This one publishes the current state of a local repository, all ready to be consumed by apt tools. Published repositories appear under the rootDir/public directory. And a valid GPG key is required for publishing. Non-negotiable. 🔑

You can publish a multi-component repository by specifying several components split by commas via the -component flag, and multiple local repositories as the arguments:

aptly publish repo -component=main,contrib repo-main repo-contrib
⚠️ It is not recommended to publish local repositories directly unless the repository is for testing purposes and changes happen frequently. For production usage, please take a snapshot of the repository and publish it using the publish snapshot command. For real. Don't skip this one. 😭

Example:

$ aptly publish repo testing

Options:

  • -acquire-by-hash — provide index files by hash
  • -batch — run GPG with detached tty
  • -butautomaticupgrades= — set value for the ButAutomaticUpgrades field
  • -codename= — codename to publish (defaults to distribution)
  • -component= — component name to publish (for multi-component publishing, separate components with commas)
  • -distribution= — distribution name to publish
  • -force-overwrite — overwrite files in package pool in case of mismatch
  • -gpg-key= — GPG key ID to use when signing the release
  • -keyring= — GPG keyring to use (instead of default)
  • -label= — label to publish
  • -multi-dist — enable multiple packages with the same filename in different distributions
  • -notautomatic= — set value for the NotAutomatic field
  • -origin= — origin name to publish
  • -passphrase= — GPG passphrase for the key (warning: could be insecure)
  • -passphrase-file= — GPG passphrase-file for the key (warning: could be insecure)
  • -secret-keyring= — GPG secret keyring to use (instead of default)
  • -skip-bz2 — don't generate bzipped indexes
  • -skip-contents — don't generate Contents indexes
  • -skip-signing — don't sign Release files with GPG
  • -suite= — suite to publish (defaults to distribution)

🔎 SHOWS DETAILS OF PUBLISHED REPOSITORY

aptly publish show distribution [[endpoint:]prefix]

show displays the full information of a published repository. All of it. 💖

Example:

$ aptly publish show wheezy

Options:

  • -json — display record in JSON format

🌸 PUBLISH SNAPSHOT 🌸

aptly publish snapshot name [[endpoint:]prefix]

okay so this one? this one is the main character of publishing. it takes a snapshot and turns it into a real Debian repository that your apt tools can actually eat. published repos show up under rootDir/public, and bestie, you need a valid GPG key for this. no key, no publish, no exceptions 💅

you can also publish a multi-component repo by listing several components split by commas via the -component flag, with multiple snapshots as the arguments:

aptly publish snapshot -component=main,contrib snap-main snap-contrib

Example:

$ aptly publish snapshot wheezy-main

✨ Options ✨

  • -acquire-by-hash — hand out index files by hash, iconic behaviour honestly
  • -batch — run GPG with a detached tty
  • -butautomaticupgrades= — overwrite the value for the ButAutomaticUpgrades field
  • -codename= — codename to publish (defaults to distribution)
  • -component= — component name to publish (for multi-component publishing, separate components with commas)
  • -distribution= — distribution name to publish
  • -force-overwrite — overwrite files in the package pool when there's a mismatch
  • -gpg-key= — GPG key ID to use when signing the release
  • -keyring= — GPG keyring to use (instead of the default)
  • -label= — label to publish
  • -multi-dist — enable multiple packages with the same filename in different distributions
  • -notautomatic= — overwrite the value for the NotAutomatic field
  • -origin= — overwrite origin name to publish
  • -passphrase= — GPG passphrase for the key (warning: could be insecure)
  • -passphrase-file= — GPG passphrase-file for the key (warning: could be insecure)
  • -secret-keyring= — GPG secret keyring to use (instead of the default)
  • -skip-bz2 — don't generate bzipped indexes
  • -skip-contents — don't generate Contents indexes
  • -skip-signing — don't sign Release files with GPG
  • -suite= — suite to publish (defaults to distribution)

🦋 ADD SOURCE COMPONENTS TO A PUBLISHED REPO 🦋

aptly publish source add distribution source

this command adds components of a snapshot or local repository so they get published. 🫶

heads up though: it does not publish the changes right away. it lowkey just schedules them for a later aptly publish update. so it's giving "not yet, bestie" energy.

the -component flag is mandatory. use a comma-separated list of components if you're modifying multiple ones. and the number of components you give has to equal the number of sources you give, like:

aptly publish source add -component=main,contrib wheezy wheezy-main wheezy-contrib

Example:

$ aptly publish source add -component=contrib wheezy ppa wheezy-contrib

this assigns the snapshot wheezy-contrib to the component contrib and adds it to the published repository revision of ppa/wheezy. slay 💅

✨ Options ✨

  • -component= — component names to add (for multi-component publishing, separate components with commas)
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

💀 DROP PENDING SOURCE COMPONENT CHANGES OF A PUBLISHED REPOSITORY 💀

aptly publish source drop distribution

removes all the pending changes that would've been applied with a subsequent aptly publish update. it's the "never mind, forget I said anything" of commands 😭

Example:

$ aptly publish source drop wheezy

✨ Options ✨

  • -component= — component names to add (for multi-component publishing, separate components with commas)
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

⭐ LISTS REVISION OF PUBLISHED REPOSITORY ⭐

aptly publish source list distribution

lists the sources of a published repository. simple. clean. we love a list 📋

Example:

$ aptly publish source list wheezy

✨ Options ✨

  • -component= — component names to add (for multi-component publishing, separate components with commas)
  • -json — display record in JSON format
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

🌈 REMOVE SOURCE COMPONENTS FROM A PUBLISHED REPO 🌈

aptly publish source remove distribution [[endpoint:]prefix] source

this one removes source components (snapshot / local repo) from a published repository. bye felicia 👋

again, it does not publish the changes directly — it schedules them for a subsequent aptly publish update.

the -component flag is mandatory. comma-separated list when you're removing multiple components, e.g.:

Example:

$ aptly publish source remove -component=contrib,non-free wheezy filesystem:symlink:debian

✨ Options ✨

  • -component= — component names to remove (for multi-component publishing, separate components with commas)
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

🎀 REPLACE THE SOURCE COMPONENTS OF A PUBLISHED REPOSITORY 🎀

aptly publish source replace distribution source

replaces the source components of a snapshot or local repository to be published. out with the old, in with the new ✨

yep, you guessed it — it does not publish the changes directly, it schedules them for a subsequent aptly publish update.

the -component flag is mandatory. comma-separated list if you're modifying multiple components, and the number of components must equal the number of sources, e.g.:

aptly publish source replace -component=main,contrib wheezy wheezy-main wheezy-contrib

Example:

$ aptly publish source replace -component=contrib wheezy ppa wheezy-contrib

✨ Options ✨

  • -component= — component names to add (for multi-component publishing, separate components with commas)
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

🧚 UPDATE THE SOURCE COMPONENTS OF A PUBLISHED REPOSITORY 🧚

aptly publish source update distribution source

updates the source components of a snapshot or local repository to be published. glow-up but for components 💖

and yes, same deal: it does not publish the changes directly, it schedules them for a subsequent aptly publish update.

the -component flag is mandatory. comma-separated list for multiple components, number of components must equal number of sources, e.g.:

aptly publish source update -component=main,contrib wheezy wheezy-main wheezy-contrib

Example:

$ aptly publish source update -component=contrib wheezy ppa wheezy-contrib

✨ Options ✨

  • -component= — component names to add (for multi-component publishing, separate components with commas)
  • -prefix=. — publishing prefix in the form of [endpoint:]prefix

👑 UPDATE PUBLISHED REPOSITORY BY SWITCHING TO NEW SOURCE 👑

aptly publish switch distribution [[endpoint:]prefix] new-source

this command switches in-place published snapshots with new source contents. all the publishing parameters are preserved (architecture list, distribution, component). nothing else changes, just the source — periodt 💅

for multiple component repositories, the -component flag should be given with the list of components to update, and the corresponding sources should be given in the same order, e.g.:

aptly publish switch -component=main,contrib wheezy wh-main wh-contrib

Example:

$ aptly publish switch wheezy ppa wheezy-7.5

this command would switch the published repository (with one component) named ppa/wheezy (prefix ppa, dsitribution wheezy) to the new snapshot wheezy-7.5. iconic switch-up ✨

✨ Options ✨

  • -batch — run GPG with a detached tty
  • -component= — component names to update (for multi-component publishing, separate components with commas)
  • -force-overwrite — overwrite files in package pool in case of mismatch
  • -gpg-key= — GPG key ID to use when signing the release
  • -keyring= — GPG keyring to use (instead of default)
  • -multi-dist — enable multiple packages with the same filename in different distributions
  • -passphrase= — GPG passphrase for the key (warning: could be insecure)
  • -passphrase-file= — GPG passphrase-file for the key (warning: could be insecure)
  • -secret-keyring= — GPG secret keyring to use (instead of default)
  • -skip-bz2 — don't generate bzipped indexes
  • -skip-cleanup — don't remove unreferenced files in prefix/component
  • -skip-contents — don't generate Contents indexes
  • -skip-signing — don't sign Release files with GPG

💜 UPDATE PUBLISHED REPOSITORY 💜

aptly publish update distribution [[endpoint:]prefix]

this command updates updates a published repository after applying pending changes to the sources. yes it says "updates updates", we're all just vibing fr fr 😭

for published local repositories:

  • update to match local repository contents

for published snapshots:

  • switch components to new snapshot

the update happens in-place with the minimum possible downtime for the published repository — like a smooth transition, no glitching 🫶

for multiple component published repositories, all local repositories are updated.

Example:

$ aptly publish update wheezy ppa

✨ Options ✨

  • -batch — run GPG with a detached tty
  • -force-overwrite — overwrite files in package pool in case of mismatch
  • -gpg-key= — GPG key ID to use when signing the release
  • -keyring= — GPG keyring to use (instead of default)
  • -multi-dist — enable multiple packages with the same filename in different distributions
  • -passphrase= — GPG passphrase for the key (warning: could be insecure)
  • -passphrase-file= — GPG passphrase-file for the key (warning: could be insecure)
  • -secret-keyring= — GPG secret keyring to use (instead of default)
  • -skip-bz2 — don't generate bzipped indexes
  • -skip-cleanup — don't remove unreferenced files in prefix/component
  • -skip-contents — don't generate Contents indexes
  • -skip-signing — don't sign Release files with GPG

🔥 SEARCH FOR PACKAGES MATCHING QUERY 🔥

aptly package search [package-query]

this command searches and displays a list of packages in the whole DB that match the package query. it's giving detective energy 🔍

use '@file' to read the query from a file, or '@-' for stdin. and if you don't specify a query at all? every single package gets displayed. all of them. no cap.

Example:

$ aptly package search '$Architecture (i386), Name (% *-dev)'

✨ Options ✨

  • -format= — custom format for result printing

✨ SHOW DETAILS ABOUT PACKAGES MATCHING QUERY ✨

aptly package show package-query

Bestie, this one is the deep-dive 💅 — it shows you detailed meta-information about packages matching your query. All that good stuff straight out of the Debian control file. And if you want even more, you can optionally also see info about package files and which mirrors / snapshots / local repos the package is included in. 👑

Need to feed it a query from somewhere else? Use @file to read the query from a file, or @- for stdin. 🫶

Example, because we love a visual:

$ aptly package show 'nginx-light_1.2.1-2.2+wheezy2_i386'

Options, let's go:

  • -with-files — display information about files from the package pool
  • -with-references — display information about mirrors, snapshots and local repos referencing this package

🧹 CLEANUP DB AND PACKAGE POOL 🧹

aptly db cleanup

Spring cleaning era 🌸 — the database cleanup removes information about unreferenced packages and removes files in the package pool that aren't used by packages anymore. Like, it literally gets rid of the dead weight, no cap.

Example:

$ aptly db cleanup

Options:

  • -dry-run — don't delete anything
  • -verbose — be verbose when loading objects/removing them

🚑 RECOVER DB AFTER CRASH 🚑

aptly db recover

This one does its absolute best to recover the database after a crash. 😭 It's giving emergency room energy.

Okay so real talk: it is recommended to backup the DB before running recover. Do not skip this. Please.

Example:

$ aptly db recover

🌐 HTTP SERVE PUBLISHED REPOSITORIES 🌐

aptly serve

The serve command starts an embedded HTTP server to serve contents of the public/ subdirectory of aptly's root that contains published repositories. 🎀

Not suitable for real production usage, bestie. This is a vibe, not a load balancer. 💀

Example:

$ aptly serve -listen=:8080

Options:

  • -listen=:8080 — host:port for HTTP listening

🛰️ START API HTTP SERVICE 🛰️

aptly api serve

Start an HTTP server with the aptly REST API, periodt. ✨ The server can listen to either a port or a Unix domain socket. When you're using a socket, aptly will fully manage the socket file for you. And this command also supports taking over from systemd file descriptors, which enables systemd socket activation. iconic behaviour honestly.

Example:

$ aptly api serve -listen=:8080
$ aptly api serve -listen=unix:///tmp/aptly.sock

Options:

  • -listen=:8080 — host:port for HTTP listening or unix://path to listen on a Unix domain socket
  • -no-lock — don't lock the database

📊 RENDER GRAPH OF RELATIONSHIPS 📊

aptly graph

The graph command displays the relationship between mirrors, local repositories, snapshots and published repositories, using the graphviz package to render the graph as an image. The way this maps out your whole setup… main character energy fr fr. 🌈

Example:

$ aptly graph

Options:

  • -format=png — render graph to specified format (png, svg, pdf, etc.)
  • -layout=horizontal — create a more 'vertical' or a more 'horizontal' graph layout
  • -output= — specify output filename, default is to open result in viewer

⚙️ SHOW CURRENT APTLY'S CONFIG ⚙️

aptly config show

The show command displays the current aptly configuration. Simple, clean, slay. 💖

Example:

$ aptly config show

Options:

  • -yaml — show yaml config

🎀 RUN APTLY TASKS 🎀

aptly task run (-filename=filename | commands...)

This command helps you organise multiple aptly commands into one single aptly task, running as a single thread. 🧚 Group-chat but for commands.

Example:

$ aptly task run
> repo create local
> repo add local pkg1
> publish repo local
> serve
>

Options:

  • -filename= — specifies the filename that contains the commands to run

⚙️ SHOW CURRENT APTLY'S CONFIG ⚙️

Okay bestie I know, we're back here again — and yes, it really is listed twice. Not me gaslighting you, this is literally what the page says. 🙈

aptly config show

The show command displays the current aptly configuration.

Example:

$ aptly config show

Options:

  • -yaml — show yaml config

🌍 ENVIRONMENT 🌍

If environment variable HTTP_PROXY is set, aptly would use its value to proxy all HTTP requests. 💜

🔢 RETURN VALUES 🔢

aptly exists with:

  • 0 — success
  • 1 — general failure
  • 2 — command parse failure

👑 AUTHORS 👑

List of contributors, in chronological order (look at this lineup, actual legends only):

And that's a wrap on the whole page, bestie!! 🎉 This version is dated December 2024 and it's APTLY(1) — go forth and mirror, snapshot, publish and slay. 💖✨🦋

📦 where this page comes from