appjail 0.1.0__py3-none-any.whl

appjail/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-FileCopyrightText: 2026 Alberto P
+# SPDX-License-Identifier: MPL-2.0

appjail/__main__.py

@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: 2026 Alberto P
+# SPDX-License-Identifier: MPL-2.0
+
+import sys
+
+from .cli import main
+
+sys.exit(main())

appjail/appimage.py

@@ -0,0 +1,278 @@
+# SPDX-FileCopyrightText: 2026 Alberto P
+# SPDX-License-Identifier: MPL-2.0
+
+"""AppImage inspection, jailed extraction and validation of the extracted tree."""
+
+import hashlib
+import os
+import shutil
+import stat
+import struct
+from pathlib import Path
+
+from . import jail
+from .textsafe import clean
+
+ELF_MAGIC = b"\x7fELF"
+MAX_EXTRACTED_BYTES = 4 * 1024 ** 3
+MAX_EXTRACTED_ENTRIES = 500_000
+MAX_SYMLINK_HOPS = 40
+UNSQUASHFS = "/usr/bin/unsquashfs"
+
+
+class NotAnAppImage(Exception):
+    pass
+
+
+class UnsupportedImage(Exception):
+    """A valid image appjail does not handle (DwarFS, unknown filesystem)."""
+
+
+class UnsafeTree(Exception):
+    """The extracted tree violates a rule (escaping links, special files, no entry point)."""
+
+
+class ExtractError(Exception):
+    pass
+
+
+# What a caller of extract() or locate_fs() has to handle (jail failures are JailError and are separate).
+EXTRACT_ERRORS = (UnsupportedImage, ExtractError, UnsafeTree)
+
+
+def sha256_file(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(1 << 20), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def tree_digest(root):
+    """sha256 over every path, type, permission bits, file content and link target of a tree.
+
+    Nothing is followed: a symlink contributes its target text only. Detects any later change
+    to the extracted tree, including added, removed or re-linked entries.
+    """
+    h = hashlib.sha256()
+    root = str(root)
+    stack = [""]
+    while stack:
+        rel = stack.pop()
+        with os.scandir(os.path.join(root, rel)) as it:
+            entries = sorted(it, key=lambda e: e.name)
+        for e in entries:
+            path = os.path.join(rel, e.name)
+            st = e.stat(follow_symlinks=False)
+            if stat.S_ISLNK(st.st_mode):
+                h.update(f"L {path}\0{os.readlink(e.path)}\0".encode("utf-8", "surrogateescape"))
+            elif stat.S_ISDIR(st.st_mode):
+                h.update(f"D {path}\0{stat.S_IMODE(st.st_mode):o}\0".encode("utf-8", "surrogateescape"))
+                stack.append(path)
+            else:
+                h.update(f"F {path}\0{stat.S_IMODE(st.st_mode):o}\0{st.st_size}\0".encode("utf-8", "surrogateescape"))
+                if stat.S_ISREG(st.st_mode):
+                    fd = os.open(e.path, os.O_RDONLY | os.O_NOFOLLOW)
+                    with os.fdopen(fd, "rb") as f:
+                        for chunk in iter(lambda: f.read(1 << 20), b""):
+                            h.update(chunk)
+    return h.hexdigest()
+
+
+def appimage_type(path):
+    """Return 2 for a type-2 AppImage; raise NotAnAppImage otherwise (type 1 is unsupported)."""
+    with open(path, "rb") as f:
+        head = f.read(11)
+    if len(head) < 11 or head[:4] != ELF_MAGIC:
+        raise NotAnAppImage("not an ELF executable")
+    if head[8:10] != b"AI":
+        raise NotAnAppImage("no AppImage marker (not an AppImage)")
+    if head[10] == 2:
+        return 2
+    raise NotAnAppImage(f"AppImage type {head[10]} is not supported (only type 2)")
+
+
+def locate_fs(path):
+    """(kind, offset) of the embedded filesystem: "squashfs" or "dwarfs", right after the ELF runtime."""
+    size = os.path.getsize(path)
+    with open(path, "rb") as f:
+        head = f.read(64)
+        if len(head) < 64 or head[:4] != ELF_MAGIC or head[4] != 2 or head[5] != 1:
+            raise UnsupportedImage("only 64-bit little-endian ELF runtimes are supported")
+        shoff, = struct.unpack_from("<Q", head, 0x28)
+        shentsize, shnum = struct.unpack_from("<HH", head, 0x3A)
+        offset = shoff + shentsize * shnum
+        if not 64 <= offset < size:
+            raise UnsupportedImage("cannot locate the embedded filesystem")
+        f.seek(offset)
+        magic = f.read(8)
+    if magic[:4] == b"hsqs":
+        return "squashfs", offset
+    if magic[:6] == b"DWARFS":
+        return "dwarfs", offset
+    raise UnsupportedImage("unknown embedded filesystem")
+
+
+def check_tree(root):
+    """Validate an extracted tree and make it safe to handle. Never follows symlinks.
+
+    Only regular files, directories and symlinks are allowed. Set-id and sticky bits are
+    cleared and directories are made owner-accessible so the tree can always be removed.
+    Sizes are apparent sizes, so sparse files cannot hide a huge tree. Returns (entries, bytes).
+    """
+    root = Path(root)
+    count = total = 0
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=False):
+        os.chmod(dirpath, (os.lstat(dirpath).st_mode & 0o777) | 0o700)
+        for name in dirnames + filenames:
+            p = os.path.join(dirpath, name)
+            st = os.lstat(p)
+            count += 1
+            if stat.S_ISLNK(st.st_mode) or stat.S_ISDIR(st.st_mode):
+                continue
+            if not stat.S_ISREG(st.st_mode):
+                raise UnsafeTree(f"special file in image: {clean(os.path.relpath(p, root), 200)}")
+            total += st.st_size
+            if st.st_mode & 0o7000:
+                os.chmod(p, st.st_mode & 0o777)
+    if total > MAX_EXTRACTED_BYTES or count > MAX_EXTRACTED_ENTRIES:
+        raise UnsafeTree("extracted tree is too large")
+    return count, total
+
+
+def resolve_entry(root, rel="AppRun"):
+    """Resolve rel inside root as the jail would see it, refusing anything that leaves root.
+
+    Relative symlinks are followed; absolute targets and '..' above the root are rejected.
+    Returns the path of an executable regular file.
+    """
+    root = os.path.realpath(root)
+    parts = [p for p in rel.split("/") if p]
+    resolved = []
+    hops = 0
+    while parts:
+        part = parts.pop(0)
+        if part == ".":
+            continue
+        if part == "..":
+            if not resolved:
+                raise UnsafeTree("entry point path escapes the image")
+            resolved.pop()
+            continue
+        candidate = os.path.join(root, *resolved, part)
+        try:
+            st = os.lstat(candidate)
+        except FileNotFoundError:
+            raise UnsafeTree(f"{rel} not found in the image") from None
+        if stat.S_ISLNK(st.st_mode):
+            hops += 1
+            target = os.readlink(candidate)
+            if hops > MAX_SYMLINK_HOPS:
+                raise UnsafeTree("too many symlinks resolving the entry point")
+            if target.startswith("/"):
+                raise UnsafeTree(f"{rel} resolves through an absolute symlink ({clean(target, 100)})")
+            parts = [p for p in target.split("/") if p] + parts
+        else:
+            resolved.append(part)
+    final = os.path.join(root, *resolved)
+    st = os.lstat(final)
+    if not stat.S_ISREG(st.st_mode) or not st.st_mode & 0o111:
+        raise UnsafeTree(f"{rel} is not an executable file")
+    return final
+
+
+def remove_tree(path):
+    """Delete a tree that may contain read-only directories. Never follows symlinks."""
+    path = str(path)
+    for dirpath, _, _ in os.walk(path, followlinks=False):
+        try:
+            if stat.S_ISDIR(os.lstat(dirpath).st_mode):
+                os.chmod(dirpath, 0o700)
+        except OSError:
+            pass
+    shutil.rmtree(path, ignore_errors=True)
+
+
+def extract_dwarfs(appimage, dest, offset):
+    """DwarFS image: extract with the pinned, hash-checked dwarfs-universal tool, inside the jail."""
+    from . import tools
+    try:
+        tool = tools.require("dwarfs")
+    except tools.ToolError as e:
+        raise ExtractError(str(e)) from e
+    dest = Path(dest)
+    if dest.exists():
+        raise ExtractError(f"{dest} already exists")
+    work = dest.with_name(dest.name + ".tmp")
+    remove_tree(work)
+    work.mkdir(mode=0o700)
+    try:
+        (work / "root").mkdir()
+        cmd = ["/dwarfs-tool", "--tool=dwarfsextract", "-i", "/app.AppImage", "-O", str(offset),
+               "-o", "/out/root", "--skip-devices", "--skip-specials"]
+        proc = _run_extraction(jail.extract_args(appimage, work, cmd, tools=((tool, "/dwarfs-tool"),)), work)
+        if proc.returncode != 0:
+            raise ExtractError("extraction failed: " + clean(proc.stderr.strip() or f"exit {proc.returncode}", 400))
+        tree = work / "root"
+        stats = check_tree(tree)
+        resolve_entry(tree, "AppRun")
+        os.replace(tree, dest)
+        return stats
+    finally:
+        remove_tree(work)
+
+
+def _run_extraction(args, work):
+    """Run an extraction jail, watching its output. Killing it for size and finding the finished tree too large
+    are the same verdict, so both raise UnsafeTree whichever the watcher's poll happens to catch."""
+    try:
+        return jail.run(args, timeout=900, watch=(work, MAX_EXTRACTED_BYTES, MAX_EXTRACTED_ENTRIES))
+    except jail.OutputTooLarge:
+        raise UnsafeTree("extracted tree is too large") from None
+
+
+def have_unsquashfs():
+    return os.access(UNSQUASHFS, os.X_OK)
+
+
+def extract(appimage, dest, runtime_fallback=False):
+    """Extract appimage into dest (must not exist) inside a no-network jail, then validate it.
+
+    Prefers unsquashfs on the filesystem offset, so the AppImage runtime never runs. With
+    runtime_fallback the image's own --appimage-extract is run, still inside the jail.
+    Returns (entries, bytes). On any failure dest is not left behind.
+    """
+    appimage, dest = Path(appimage), Path(dest)
+    kind, offset = locate_fs(appimage)
+    if kind == "dwarfs":
+        return extract_dwarfs(appimage, dest, offset)
+    if not have_unsquashfs() and not runtime_fallback:
+        raise ExtractError("unsquashfs is not installed (apt install squashfs-tools)")
+    if dest.exists():
+        raise ExtractError(f"{dest} already exists")
+    work = dest.with_name(dest.name + ".tmp")
+    remove_tree(work)
+    work.mkdir(mode=0o700)
+    try:
+        if have_unsquashfs():
+            cmd = [UNSQUASHFS, "-no-progress", "-no-xattrs", "-p", "2", "-o", str(offset),
+                   "-d", "/out/root", "/app.AppImage"]
+            tree = work / "root"
+        else:
+            # The runtime must be executable inside the jail: use a private copy.
+            copy = work / "app.AppImage"
+            shutil.copyfile(appimage, copy)
+            copy.chmod(0o700)
+            cmd = ["/out/app.AppImage", "--appimage-extract"]
+            tree = work / "squashfs-root"
+        proc = _run_extraction(jail.extract_args(appimage, work, cmd), work)
+        if proc.returncode != 0:
+            raise ExtractError("extraction failed: " + clean(proc.stderr.strip() or f"exit {proc.returncode}", 400))
+        if not tree.is_dir():
+            raise ExtractError("extraction produced no files")
+        stats = check_tree(tree)
+        resolve_entry(tree, "AppRun")
+        os.replace(tree, dest)
+        return stats
+    finally:
+        remove_tree(work)

appjail/attest.py

@@ -0,0 +1,103 @@
+# SPDX-FileCopyrightText: 2026 Alberto P
+# SPDX-License-Identifier: MPL-2.0
+
+"""Build-attestation verification (evidence tier 1) with the pinned GitHub CLI, inside a jail.
+
+appjail fetches the Sigstore bundles itself (`github.Client.attestation_bundles`) and hands them to
+`gh attestation verify --bundle`, which checks the signature chain against the Sigstore trusted root
+(fetched over TUF, hence the network), that the bundle covers the exact downloaded bytes, and that the
+signing identity belongs to the repository. `gh` runs from `appjail.tools` (size and sha256 pinned),
+sees only the subject, the bundles and a scratch directory, and receives no token (it requires one to
+be set but never uses it with `--bundle`). On top of gh's verdict appjail re-reads the certificate
+fields and requires GitHub Actions as issuer, the exact repository, and, when known, the pinned
+owner account id: a name is not enough, an account id is.
+"""
+
+import json
+import secrets
+import shutil
+from dataclasses import dataclass
+
+from . import jail, store, tools
+from .textsafe import clean
+
+ISSUER = "https://token.actions.githubusercontent.com"
+TIMEOUT = 180
+
+
+class AttestError(Exception):
+    """The attestation could not be verified (tool missing, no valid bundle, identity mismatch)."""
+
+
+@dataclass(frozen=True)
+class Verified:
+    repo: str  # https://github.com/owner/repo
+    workflow: str  # signing workflow with ref, from the certificate
+    ref: str
+    run_url: str
+    owner_id: str
+    repo_id: str
+
+
+def _args(gh, subject, bundles, scratch):
+    return (jail.common_args() + ["--share-net"] + jail.etc_args(private_net=True)
+            + ["--ro-bind", str(gh), "/gh", "--ro-bind", str(subject), "/subject",
+               "--ro-bind", str(bundles), "/bundle.jsonl", "--bind", str(scratch), "/scratch",
+               "--remount-ro", "/", "--chdir", "/scratch",
+               "--setenv", "HOME", "/scratch", "--setenv", "GH_TOKEN", "unused",
+               "--setenv", "GH_PROMPT_DISABLED", "1", "--setenv", "GH_NO_UPDATE_NOTIFIER", "1", "--"])
+
+
+def check_results(results, full_name, owner_id=None):
+    """First verified result whose certificate matches the repository (and owner id); else AttestError."""
+    wanted = f"https://github.com/{full_name}".lower()
+    problems = []
+    for item in results if isinstance(results, list) else []:
+        try:
+            cert = item["verificationResult"]["signature"]["certificate"]
+            repo = str(cert["sourceRepositoryURI"])
+            if repo.lower() != wanted:
+                problems.append(f"signed for {repo}")
+            elif cert.get("issuer") != ISSUER:
+                problems.append(f"unexpected issuer {cert.get('issuer')}")
+            elif owner_id is not None and str(cert.get("sourceRepositoryOwnerIdentifier")) != str(owner_id):
+                problems.append("the signing repository's owner account differs from the pinned owner")
+            else:
+                return Verified(repo, str(cert.get("buildSignerURI", "")), str(cert.get("sourceRepositoryRef", "")),
+                                str(cert.get("runInvocationURI", "")), str(cert.get("sourceRepositoryOwnerIdentifier", "")),
+                                str(cert.get("sourceRepositoryIdentifier", "")))
+        except (KeyError, TypeError):
+            problems.append("unreadable verification result")
+    raise AttestError("no attestation matches this repository: " + ("; ".join(sorted(set(problems))) or "none verified"))
+
+
+def verify(subject, full_name, bundles, owner_id=None, run=jail.run):
+    """Verify the downloaded file against its bundles. Returns Verified or raises AttestError."""
+    if not bundles:
+        raise AttestError("GitHub holds no attestation for this file")
+    try:
+        gh = tools.require("gh")
+    except tools.ToolError as e:
+        raise AttestError(str(e)) from e
+    work = store.staging_root() / ("attest-" + secrets.token_hex(8))
+    work.mkdir(parents=True, mode=0o700)
+    try:
+        bundle_file = work / "bundle.jsonl"
+        bundle_file.write_text("".join(json.dumps(b) + "\n" for b in bundles), encoding="utf-8")
+        scratch = work / "scratch"
+        scratch.mkdir(mode=0o700)
+        cmd = ["/gh", "attestation", "verify", "/subject", "--repo", full_name, "--bundle", "/bundle.jsonl",
+               "--format", "json"]
+        try:
+            proc = run(_args(gh, subject, bundle_file, scratch) + cmd, timeout=TIMEOUT)
+        except jail.JailError as e:
+            raise AttestError(str(e)) from e
+        if proc.returncode != 0:
+            raise AttestError("verification failed: " + clean(proc.stderr.strip() or f"exit {proc.returncode}", 300))
+        try:
+            results = json.loads(proc.stdout)
+        except ValueError as e:
+            raise AttestError("verification output was not understood") from e
+        return check_results(results, full_name, owner_id)
+    finally:
+        shutil.rmtree(work, ignore_errors=True)

appjail/cli.py

@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: 2026 Alberto P
+# SPDX-License-Identifier: MPL-2.0
+
+"""Command line interface: the parser and the dispatcher. The commands live in cmd_*.py.
+
+The names re-exported here are the ones tests and the `appjail` console script (pyproject.toml) import from `appjail.cli`.
+"""
+
+import argparse
+import sys
+
+from . import github, index, indexsync, jail, manifest, runner, tools, updater
+from .cmd_add import cmd_add
+from .cmd_apps import cmd_history, cmd_list, cmd_perms, cmd_remove, cmd_tools
+from .cmd_index import cmd_index_rollback, cmd_index_status, cmd_index_update, cmd_search
+from .cmd_update import cmd_update
+from .console import Abort, Console
+from .permargs import PERMISSION_FLAGS, dirs_from_args, files_from_args
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="appjail", description="Sandboxed AppImage manager")
+    sub = p.add_subparsers(dest="command", required=True)
+    add = sub.add_parser("add", help="add an app from a GitHub owner/repo")
+    add.add_argument("source", help="GitHub owner/repo")
+    add.add_argument("--name", help="local app name (default: repo name)")
+    add.add_argument("--prerelease", action="store_true", help="allow pre-releases")
+    add.add_argument("--tag", help="use this release tag instead of the latest release")
+    add.add_argument("--dir", action="append", default=[], metavar="PATH[:ro|:rw]",
+                     help="let the app see this directory (read-only unless :rw); repeatable")
+    add.add_argument("--dbus", action="append", default=[], metavar="NAME",
+                     help="let the app talk to this session-bus name through a filtering proxy; repeatable")
+    add.add_argument("--dbus-own", action="append", default=[], metavar="NAME",
+                     help="let the app own this session-bus name (MPRIS player, single-instance name); repeatable")
+    add.add_argument("--portal", action="append", default=[], metavar="NAME",
+                     help="also allow this privileged portal interface (needs --allow portals); repeatable")
+    add.add_argument("--allow", action="append", default=[], choices=[f for f in PERMISSION_FLAGS if f not in ("audio", "gpu")],
+                     help="grant a permission (repeatable); audio and gpu are on by default")
+    add.add_argument("--no-audio", action="store_true", help="do not grant audio")
+    add.add_argument("--no-gpu", action="store_true", help="do not grant GPU access")
+    add.add_argument("--display", choices=manifest.DISPLAYS, default="wayland")
+    search = sub.add_parser("search", help="search the local AM index (suggestions only, never installs)")
+    search.add_argument("keywords", nargs="+")
+    search.add_argument("--limit", type=int, default=20, help="maximum results (default 20)")
+    search.add_argument("--all", action="store_true", help="show every match")
+    idx = sub.add_parser("index", help="manage the local AM search index")
+    isub = idx.add_subparsers(dest="index_command", required=True)
+    upd = isub.add_parser("update", help="fetch the AM index, review the changes, then pin it")
+    upd.add_argument("--commit", default="HEAD", help="fetch this commit (40 hex digits) instead of the remote HEAD")
+    isub.add_parser("rollback", help="go back to the previous index snapshot")
+    isub.add_parser("status", help="show the pinned index")
+    upd_app = sub.add_parser("update", help="check for a newer release and install it after review and quarantine")
+    upd_app.add_argument("app", nargs="?", help="app name (default: every installed app)")
+    upd_app.add_argument("--prerelease", action="store_true", help="follow pre-releases for this run (see --channel to make it permanent)")
+    upd_app.add_argument("--channel", choices=manifest.CHANNELS, help="set which releases this app follows from now on: stable, prerelease, or pinned (never updated)")
+    upd_app.add_argument("--quarantine", type=int, default=updater.DEFAULT_QUARANTINE_DAYS, metavar="DAYS",
+                         help="days a new release must wait after it was first seen (default %(default)s; 0 = none)")
+    sub.add_parser("list", help="list installed apps")
+    tl = sub.add_parser("tools", help="pinned helper binaries (e.g. for DwarFS AppImages)")
+    tsub = tl.add_subparsers(dest="tools_command", required=True)
+    tsub.add_parser("status", help="show which helpers are installed and intact")
+    tinst = tsub.add_parser("install", help="download a helper whose size and sha256 are pinned in appjail's source")
+    tinst.add_argument("tool", choices=sorted(tools.TOOLS))
+    hist = sub.add_parser("history", help="show the recorded changes to the manifests")
+    hist.add_argument("app", nargs="?")
+    hist.add_argument("--limit", type=int, default=20)
+    rm = sub.add_parser("remove", help="delete an app, including its private home")
+    rm.add_argument("app")
+    rm.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    perms = sub.add_parser("perms", help="show or change an app's permissions (the pinned release is unchanged)")
+    perms.add_argument("app")
+    perms.add_argument("--allow", action="append", default=[], choices=PERMISSION_FLAGS)
+    perms.add_argument("--deny", action="append", default=[], choices=PERMISSION_FLAGS)
+    perms.add_argument("--display", choices=manifest.DISPLAYS)
+    perms.add_argument("--add-dir", action="append", default=[], metavar="PATH[:ro|:rw]")
+    perms.add_argument("--rm-dir", action="append", default=[], metavar="PATH")
+    perms.add_argument("--add-dbus", action="append", default=[], metavar="NAME", help="allow talking to this session-bus name")
+    perms.add_argument("--rm-dbus", action="append", default=[], metavar="NAME")
+    perms.add_argument("--add-dbus-own", action="append", default=[], metavar="NAME", help="allow owning this session-bus name")
+    perms.add_argument("--rm-dbus-own", action="append", default=[], metavar="NAME")
+    perms.add_argument("--add-portal", action="append", default=[], metavar="NAME", help="also allow this privileged portal interface")
+    perms.add_argument("--rm-portal", action="append", default=[], metavar="NAME")
+    perms.add_argument("--yes", action="store_true", help="do not ask for confirmation")
+    run = sub.add_parser("run", help="run an installed app in its jail")
+    run.add_argument("name")
+    run.add_argument("--dir", action="append", default=[], metavar="PATH[:ro|:rw]",
+                     help="grant this directory for this run only (manifest unchanged); repeatable")
+    run.add_argument("--file", action="append", default=[], metavar="PATH[:rw]",
+                     help="bind just this file for this run (read-only unless :rw) and pass its in-jail path to the app; repeatable")
+    return p
+
+
+def main(argv=None, client=None, console=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    app_args = []
+    if "--" in argv:  # everything after -- belongs to the app
+        i = argv.index("--")
+        argv, app_args = argv[:i], argv[i + 1:]
+    args = build_parser().parse_args(argv)
+    console = console or Console()
+    try:
+        if args.command == "add":
+            if not manifest.SOURCE_RE.fullmatch(args.source):
+                raise Abort("source must be a GitHub owner/repo")
+            cmd_add(args, client or github.Client(), console)
+        elif args.command == "index":
+            if args.index_command == "update":
+                cmd_index_update(args, console)
+            elif args.index_command == "rollback":
+                cmd_index_rollback(console)
+            else:
+                cmd_index_status(console)
+        elif args.command == "search":
+            cmd_search(args, console)
+        elif args.command == "update":
+            return cmd_update(args, client or github.Client(), console)
+        elif args.command == "list":
+            cmd_list(console)
+        elif args.command == "tools":
+            cmd_tools(args, console)
+        elif args.command == "history":
+            cmd_history(args, console)
+        elif args.command == "remove":
+            cmd_remove(args, console)
+        elif args.command == "perms":
+            cmd_perms(args, console)
+        elif args.command == "run":
+            extra_dirs = dirs_from_args(args.dir)
+            extra_files = files_from_args(args.file)
+            return runner.launch(args.name, app_args, say=console.out, extra_dirs=extra_dirs, extra_files=extra_files)
+    except Abort as e:
+        console.out(str(e))
+        return 1
+    except (github.GitHubError, jail.JailError, jail.RunError, manifest.ManifestError, index.IndexProblem, indexsync.IndexRefused, OSError) as e:
+        console.out(f"error: {e}")
+        return 1
+    return 0