boxman 0.1.0__py3-none-any.whl

boxman/cli.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Set up and manage a Linux development box."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def fail(message: str) -> None:
+    raise SystemExit(message)
+
+
+def run(*args: str) -> None:
+    result = subprocess.run(args, check=False)
+    if result.returncode:
+        raise SystemExit(result.returncode)
+
+
+def mounted(path: Path) -> bool:
+    return subprocess.run(
+        ("mountpoint", "-q", str(path)),
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        check=False,
+    ).returncode == 0
+
+
+def vault_paths() -> tuple[Path, Path]:
+    home = Path.home()
+    cipher, plain = home / ".private.cipher", home / "private"
+    if cipher.is_symlink() or plain.is_symlink():
+        fail("Private vault paths must not be symlinks")
+    return cipher, plain
+
+
+def private_dir(path: Path) -> None:
+    path.mkdir(mode=0o700, parents=True, exist_ok=True)
+    path.chmod(0o700)
+
+
+def vault(action: str) -> None:
+    if os.geteuid() == 0:
+        fail("Run vault commands as your login user, not root")
+    os.umask(0o077)
+    cipher, plain = vault_paths()
+
+    if action == "status":
+        print("Private vault is unlocked" if mounted(plain) else "Private vault is locked")
+    elif action == "init":
+        if mounted(plain):
+            fail("Private vault is already unlocked")
+        if (cipher / "gocryptfs.conf").exists():
+            fail("Private vault is already initialized")
+        private_dir(cipher)
+        private_dir(plain)
+        if any(cipher.iterdir()):
+            fail("Encrypted backing directory is not empty")
+        if any(plain.iterdir()):
+            fail("Plaintext mount directory is not empty")
+        run("gocryptfs", "-init", str(cipher))
+        print("Keep the password and recovery key outside this host.")
+    elif action == "unlock":
+        if not (cipher / "gocryptfs.conf").is_file():
+            fail("Private vault is not initialized; run boxman vault init")
+        private_dir(cipher)
+        private_dir(plain)
+        if mounted(plain):
+            print("Private vault is already unlocked")
+            return
+        if any(plain.iterdir()):
+            fail("Plaintext mount directory is not empty; refusing to hide its files")
+        run("gocryptfs", str(cipher), str(plain))
+    elif action == "lock":
+        if not mounted(plain):
+            print("Private vault is already locked")
+            return
+        run("fusermount3", "-u", str(plain))
+    else:
+        fail("Usage: boxman vault {init|unlock|lock|status}")
+
+
+def claude(args: list[str]) -> None:
+    if os.geteuid() == 0:
+        fail("Run Claude as your login user, not root")
+    _, plain = vault_paths()
+    if not mounted(plain):
+        fail("Private vault is locked; run boxman vault unlock first")
+    config = plain / "claude"
+    if config.is_symlink():
+        fail("Claude config directory must not be a symlink")
+    os.umask(0o077)
+    private_dir(config)
+    os.environ["CLAUDE_CONFIG_DIR"] = str(config)
+    os.execvp("claude", ["claude", *args])
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        fail("Usage: boxman {system|user|vault|claude|verify|ec2} ...")
+    command, *args = sys.argv[1:]
+    if command == "system":
+        from boxman import system
+
+        system.main(args)
+    elif command == "user":
+        if args:
+            fail("Usage: boxman user")
+        from boxman import user
+
+        user.main()
+    elif command == "vault":
+        if len(args) != 1:
+            fail("Usage: boxman vault {init|unlock|lock|status}")
+        vault(args[0])
+    elif command == "claude":
+        claude(args)
+    elif command == "ec2":
+        from boxman import ec2
+
+        ec2.main(args)
+    elif command == "verify":
+        if args:
+            fail("Usage: boxman verify")
+        from boxman import verify
+
+        verify.main()
+    else:
+        fail("Usage: boxman {system|user|vault|claude|verify|ec2} ...")
+
+
+if __name__ == "__main__":
+    main()

boxman/data/ec2-template.yaml

@@ -0,0 +1,126 @@
+AWSTemplateFormatVersion: "2010-09-09"
+Description: >
+  EC2 development box:
+  one instance, no inbound security-group rules, SSM-only access.
+
+Parameters:
+  VpcId:
+    Type: AWS::EC2::VPC::Id
+  SubnetId:
+    Type: AWS::EC2::Subnet::Id
+  InstanceType:
+    Type: String
+  VolumeSizeGb:
+    Type: Number
+  InstanceName:
+    Type: String
+  LatestAmiId:
+    Type: AWS::SSM::Parameter::Value<AWS::EC2::Image::Id>
+
+Resources:
+  SecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupName: !Sub "${AWS::StackName}-sg"
+      GroupDescription: Shared coding-agent dev box - no inbound rules, SSM only
+      VpcId: !Ref VpcId
+      Tags:
+        - Key: Name
+          Value: !Sub "${AWS::StackName}-sg"
+      # No SecurityGroupIngress here: no inbound rules from the internet, on
+      # purpose. The only inbound access is via SecurityGroupIngressFromEice
+      # below, scoped to the Instance Connect Endpoint's own security group.
+      # No SecurityGroupEgress: keeps CloudFormation's default allow-all outbound.
+
+  EiceSecurityGroup:
+    Type: AWS::EC2::SecurityGroup
+    Properties:
+      GroupName: !Sub "${AWS::StackName}-eice-sg"
+      GroupDescription: EC2 Instance Connect Endpoint - no inbound rules needed
+      VpcId: !Ref VpcId
+      Tags:
+        - Key: Name
+          Value: !Sub "${AWS::StackName}-eice-sg"
+
+  SecurityGroupIngressFromEice:
+    Type: AWS::EC2::SecurityGroupIngress
+    Properties:
+      GroupId: !Ref SecurityGroup
+      IpProtocol: tcp
+      FromPort: 22
+      ToPort: 22
+      SourceSecurityGroupId: !Ref EiceSecurityGroup
+      Description: SSH from the EC2 Instance Connect Endpoint only
+
+  InstanceConnectEndpoint:
+    Type: AWS::EC2::InstanceConnectEndpoint
+    Properties:
+      SubnetId: !Ref SubnetId
+      SecurityGroupIds:
+        - !Ref EiceSecurityGroup
+      PreserveClientIp: true
+      Tags:
+        - Key: Name
+          Value: !Sub "${AWS::StackName}-eice"
+
+  InstanceRole:
+    Type: AWS::IAM::Role
+    Properties:
+      RoleName: !Sub "${AWS::StackName}-ssm-role"
+      AssumeRolePolicyDocument:
+        Version: "2012-10-17"
+        Statement:
+          - Effect: Allow
+            Principal:
+              Service: ec2.amazonaws.com
+            Action: sts:AssumeRole
+      ManagedPolicyArns:
+        - arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
+      Tags:
+        - Key: Name
+          Value: !Sub "${AWS::StackName}-ssm-role"
+
+  InstanceProfile:
+    Type: AWS::IAM::InstanceProfile
+    Properties:
+      InstanceProfileName: !Sub "${AWS::StackName}-ssm-profile"
+      Roles:
+        - !Ref InstanceRole
+
+  Instance:
+    Type: AWS::EC2::Instance
+    Properties:
+      ImageId: !Ref LatestAmiId
+      InstanceType: !Ref InstanceType
+      SubnetId: !Ref SubnetId
+      SecurityGroupIds:
+        - !Ref SecurityGroup
+      IamInstanceProfile: !Ref InstanceProfile
+      BlockDeviceMappings:
+        - DeviceName: /dev/sda1
+          Ebs:
+            VolumeSize: !Ref VolumeSizeGb
+            VolumeType: gp3
+            DeleteOnTermination: true
+      MetadataOptions:
+        HttpTokens: required
+        HttpPutResponseHopLimit: 2
+      Tags:
+        - Key: Name
+          Value: !Ref InstanceName
+
+Outputs:
+  InstanceId:
+    Value: !Ref Instance
+  SecurityGroupId:
+    Value: !Ref SecurityGroup
+  InstanceRoleArn:
+    Value: !GetAtt InstanceRole.Arn
+  InstanceProfileArn:
+    Value: !GetAtt InstanceProfile.Arn
+  # No PublicIp output: !GetAtt Instance.PublicIp fails outright whenever the
+  # instance isn't running (stopped by uptime governance, mid-restart, etc.),
+  # breaking every subsequent stack operation. basbox.py status() already
+  # reads the live public IP via ec2:DescribeInstances instead.
+  InstanceConnectEndpointId:
+    Value: !Ref InstanceConnectEndpoint

boxman/data/linux-tools.toml

@@ -0,0 +1,80 @@
+# zipget recipe for boxman on Ubuntu 24.04
+
+[system_packages]
+apt = [
+  "acl", "build-essential", "ca-certificates", "curl", "dbus-user-session",
+  "direnv", "file", "fuse3", "fuse-overlayfs", "gh", "git", "git-lfs",
+  "gocryptfs", "jq",
+  "less", "lf", "libsecret-tools", "openssh-client", "podman", "python3",
+  "python3-venv", "python-is-python3", "rsync", "shellcheck",
+  "slirp4netns", "uidmap", "unzip", "xz-utils", "zip", "zstd",
+]
+
+[vars]
+bin_dir = "~/.local/bin"
+
+[herdr]
+# Agent multiplexer - https://herdr.dev
+github = { repo = "herdrdev/herdr", asset = "herdr-linux-x86_64" }
+save_as = "${bin_dir}/herdr"
+executable = true
+
+[cship]
+# Claude Code statusline - https://cship.dev
+github = { repo = "stephenleo/cship", asset = "cship-x86_64-unknown-linux-musl" }
+save_as = "${bin_dir}/cship"
+executable = true
+
+[microsoft-edit]
+# Terminal-based text editor - https://github.com/microsoft/edit
+# Note: only gnu builds available (no musl)
+github = { repo = "microsoft/edit", asset = "x86_64-linux-gnu.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "edit"
+
+[starship]
+# Cross-shell prompt - https://github.com/starship/starship
+github = { repo = "starship/starship", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "starship"
+
+[ripgrep]
+# Fast regex search tool - https://github.com/BurntSushi/ripgrep
+github = { repo = "BurntSushi/ripgrep", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "*/rg"
+
+[fd]
+# Fast find alternative - https://github.com/sharkdp/fd
+github = { repo = "sharkdp/fd", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "*/fd"
+
+[bat]
+# Cat with syntax highlighting - https://github.com/sharkdp/bat
+github = { repo = "sharkdp/bat", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "*/bat"
+
+[fzf]
+# Fuzzy finder - https://github.com/junegunn/fzf
+github = { repo = "junegunn/fzf", asset = "linux_amd64.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "fzf"
+
+[zoxide]
+# Smarter cd command - https://github.com/ajeetdsouza/zoxide
+github = { repo = "ajeetdsouza/zoxide", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "zoxide"
+
+[delta]
+# Git diff viewer - https://github.com/dandavison/delta
+github = { repo = "dandavison/delta", asset = "x86_64-unknown-linux-musl.tar.gz" }
+unzip_to = "${bin_dir}"
+files = "*/delta"
+
+[aws-cli]
+# AWS CLI v2 - official installer
+url = "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip"
+unzip_to = "./aws-cli-installer"

boxman/ec2.py

@@ -0,0 +1,297 @@
+"""Manage an EC2 development box through a CloudFormation stack."""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import contextlib
+import importlib.resources
+import json
+import os
+import re
+import shlex
+import subprocess
+import tomllib
+from pathlib import Path
+
+
+PARAMETERS = {
+    "vpc_id": "VpcId",
+    "subnet_id": "SubnetId",
+    "instance_type": "InstanceType",
+    "volume_size_gb": "VolumeSizeGb",
+    "instance_name": "InstanceName",
+    "ami_id": "LatestAmiId",
+}
+USERNAME = re.compile(r"[a-z_][a-z0-9_-]{0,31}\Z")
+ALIAS = re.compile(r"[A-Za-z0-9_.-]+\Z")
+
+
+def required(value: str | None, name: str) -> str:
+    if not value:
+        raise SystemExit(f"Missing {name}; provide it by option or --config")
+    return value
+
+
+def username(value: str) -> str:
+    if not USERNAME.fullmatch(value):
+        raise SystemExit(f"Invalid Unix username: {value!r}")
+    return value
+
+
+def config_dir() -> Path:
+    return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "boxman"
+
+
+def stack_template(name: str) -> Path:
+    if not re.fullmatch(r"[A-Za-z][A-Za-z0-9-]{0,127}", name):
+        raise SystemExit("Stack name must be a valid CloudFormation stack name")
+    return config_dir() / "stacks" / f"{name}.yaml"
+
+
+def init_stack(name: str, values: dict) -> Path:
+    target = stack_template(name)
+    target.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    body = importlib.resources.files("boxman").joinpath("data/ec2-template.yaml").read_text()
+    for key, parameter in PARAMETERS.items():
+        value = required(values.get(key), "--" + key.replace("_", "-"))
+        marker = f"  {parameter}:\n    Type: "
+        match = re.search(re.escape(marker) + r"[^\n]+\n", body)
+        if not match:
+            raise SystemExit(f"Template is missing parameter {parameter}")
+        body = body[:match.end()] + f"    Default: {json.dumps(str(value))}\n" + body[match.end():]
+    try:
+        with target.open("x") as output:
+            output.write(body)
+    except FileExistsError:
+        raise SystemExit(f"Stack template already exists: {target}") from None
+    return target
+
+
+def settings(args: argparse.Namespace) -> dict:
+    config = {}
+    config_path = args.config or config_dir() / "ec2.toml"
+    if config_path.is_file():
+        with config_path.open("rb") as source:
+            config = tomllib.load(source)
+    elif args.config:
+        raise SystemExit(f"Config file does not exist: {config_path}")
+    if config:
+        if set(config) - {"ec2"} or not isinstance(config.get("ec2"), dict):
+            raise SystemExit("Config must contain an [ec2] table")
+        config = config["ec2"]
+    keys = {"profile", "region", "stack_name", "tags"}
+    if set(config) - keys:
+        raise SystemExit(f"Unknown [ec2] settings: {', '.join(sorted(set(config) - keys))}")
+    result = {key: getattr(args, key, None) or config.get(key) for key in keys}
+    result["stack_name"] = required(result["stack_name"], "--stack-name")
+    stack_template(result["stack_name"])
+    if args.action != "init":
+        result["profile"] = required(result["profile"], "--profile")
+        result["region"] = required(result["region"], "--region")
+    tags = config.get("tags", {}).copy()
+    if not isinstance(tags, dict) or any(not isinstance(k, str) or not isinstance(v, str) for k, v in tags.items()):
+        raise SystemExit("[ec2.tags] must contain string keys and values")
+    for item in getattr(args, "tag", None) or []:
+        if "=" not in item or not item.split("=", 1)[0]:
+            raise SystemExit("--tag must be KEY=VALUE")
+        key, value = item.split("=", 1)
+        tags[key] = value
+    result["tags"] = tags
+    return result
+
+
+def stack(cfn, name: str):
+    try:
+        return cfn.describe_stacks(StackName=name)["Stacks"][0]
+    except Exception as exc:
+        if getattr(exc, "response", {}).get("Error", {}).get("Code") == "ValidationError" and "does not exist" in str(exc):
+            return None
+        raise
+
+
+def instance_id(cfn, name: str) -> str:
+    current = stack(cfn, name)
+    if current:
+        for item in current.get("Outputs", []):
+            if item["OutputKey"] == "InstanceId":
+                return item["OutputValue"]
+    raise SystemExit(f"Stack {name} has no InstanceId output; deploy it first")
+
+
+def execute(ssm, instance: str, command: str, user: str | None = None) -> None:
+    if user:
+        user = username(user)
+        payload = base64.b64encode(command.encode()).decode()
+        command = (f"BOXMAN_TMP=$(mktemp)\ntrap 'rm -f \"$BOXMAN_TMP\"' EXIT\n"
+                   f"echo {shlex.quote(payload)} | base64 -d > \"$BOXMAN_TMP\"\n"
+                   f"chmod 755 \"$BOXMAN_TMP\"\nsudo -iu {user} bash \"$BOXMAN_TMP\"")
+    response = ssm.send_command(InstanceIds=[instance], DocumentName="AWS-RunShellScript", Parameters={"commands": [command]})
+    command_id = response["Command"]["CommandId"]
+    with contextlib.suppress(Exception):
+        ssm.get_waiter("command_executed").wait(CommandId=command_id, InstanceId=instance)
+    result = ssm.get_command_invocation(CommandId=command_id, InstanceId=instance)
+    print(f"Status: {result['Status']}")
+    for key in ("StandardOutputContent", "StandardErrorContent"):
+        if result.get(key):
+            print(result[key], end="" if result[key].endswith("\n") else "\n")
+    if result["Status"] != "Success":
+        raise SystemExit(f"Remote command failed: {result['Status']}")
+
+
+def add_key(ssm, instance: str, user: str, key_path: Path) -> None:
+    user = username(user)
+    key = key_path.read_text().strip()
+    if "\n" in key or not key.startswith(("ssh-ed25519 ", "ssh-rsa ", "ecdsa-sha2-")):
+        raise SystemExit(f"Invalid public key: {key_path}")
+    payload = base64.b64encode(key.encode()).decode()
+    script = ("set -e\nmkdir -p ~/.ssh\nchmod 700 ~/.ssh\n"
+              "touch ~/.ssh/authorized_keys\nchmod 600 ~/.ssh/authorized_keys\n"
+              f"KEY=$(echo {shlex.quote(payload)} | base64 -d)\n"
+              "grep -qxF \"$KEY\" ~/.ssh/authorized_keys || printf '%s\\n' \"$KEY\" >> ~/.ssh/authorized_keys\n")
+    execute(ssm, instance, script, user)
+
+
+def keypair(path: Path) -> None:
+    if path.exists():
+        if not Path(str(path) + ".pub").is_file():
+            raise SystemExit(f"Missing public key for {path}")
+        return
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    subprocess.run(["ssh-keygen", "-t", "ed25519", "-N", "", "-f", str(path)], check=True)
+
+
+def proxy(settings_: dict) -> str:
+    return " ".join(shlex.quote(part) for part in ("aws", "ec2-instance-connect", "open-tunnel", "--profile", settings_["profile"], "--region", settings_["region"], "--instance-id")) + " %h"
+
+
+def write_ssh_config(alias: str, body: str) -> None:
+    if not ALIAS.fullmatch(alias):
+        raise SystemExit("Alias may contain letters, numbers, dot, underscore and hyphen")
+    path = Path.home() / ".ssh" / "config"
+    path.parent.mkdir(mode=0o700, exist_ok=True)
+    content = path.read_text() if path.exists() else ""
+    begin, end = f"# boxman:{alias} begin", f"# boxman:{alias} end"
+    block = f"{begin}\n{body}\n{end}\n"
+    pattern = re.compile(re.escape(begin) + r".*?" + re.escape(end) + r"\n?", re.DOTALL)
+    content = pattern.sub(lambda _: block, content) if pattern.search(content) else content.rstrip("\n") + ("\n\n" if content else "") + block
+    path.write_text(content)
+    path.chmod(0o600)
+
+
+def main(argv: list[str]) -> None:
+    parser = argparse.ArgumentParser(prog="boxman ec2")
+    parser.add_argument("--config", type=Path, help="TOML file (default: $XDG_CONFIG_HOME/boxman/ec2.toml)")
+    parser.add_argument("--profile")
+    parser.add_argument("--region")
+    parser.add_argument("--stack-name")
+    sub = parser.add_subparsers(dest="action", required=True)
+    sub.add_parser("init", help="create a local stack template under the boxman config directory")
+    init = sub.choices["init"]
+    for key in PARAMETERS:
+        init.add_argument("--" + key.replace("_", "-"), dest=key)
+    deploy = sub.add_parser("deploy")
+    deploy.add_argument("--tag", action="append", help="stack tag as KEY=VALUE; repeatable")
+    for action in ("status", "start", "stop"):
+        sub.add_parser(action)
+    connect = sub.add_parser("connect")
+    connect.add_argument("-u", "--user")
+    ssh = sub.add_parser("ssh")
+    ssh.add_argument("-u", "--user", required=True)
+    ssh.add_argument("--key-path", type=Path)
+    ssh.add_argument("-c", "--container")
+    ssh_config = sub.add_parser("ssh-config")
+    ssh_config.add_argument("-u", "--user", required=True)
+    ssh_config.add_argument("--alias", required=True)
+    ssh_config.add_argument("--key-path", type=Path)
+    run = sub.add_parser("run")
+    run.add_argument("command")
+    run.add_argument("-u", "--user")
+    args = parser.parse_args(argv)
+    conf = settings(args)
+    if args.action == "init":
+        values = {key: getattr(args, key) for key in PARAMETERS}
+        try:
+            if int(required(values["volume_size_gb"], "--volume-size-gb")) < 8:
+                raise SystemExit("--volume-size-gb must be at least 8")
+        except ValueError as exc:
+            raise SystemExit("--volume-size-gb must be an integer") from exc
+        print(f"Created {init_stack(conf['stack_name'], values)}")
+        return
+    try:
+        import boto3
+        import botocore.exceptions
+    except ImportError as exc:
+        raise SystemExit("EC2 commands require boto3; install boxman with the ec2 extra") from exc
+    try:
+        session = boto3.Session(profile_name=conf["profile"], region_name=conf["region"])
+        cfn = session.client("cloudformation")
+        name = conf["stack_name"]
+        if args.action == "deploy":
+            template = stack_template(name)
+            if not template.is_file():
+                raise SystemExit(f"Stack template missing: {template}; run boxman ec2 init first")
+            body = template.read_text()
+            params = []
+            for aws in PARAMETERS.values():
+                match = re.search(rf"^  {re.escape(aws)}:\n    Type: [^\n]+\n    Default: (.+)$", body, re.MULTILINE)
+                if not match:
+                    raise SystemExit(f"Stack template lacks a default for {aws}: {template}")
+                try:
+                    value = json.loads(match.group(1))
+                except json.JSONDecodeError as exc:
+                    raise SystemExit(f"Invalid default for {aws}: {exc}") from exc
+                params.append({"ParameterKey": aws, "ParameterValue": str(value)})
+            tags = [{"Key": key, "Value": value} for key, value in conf["tags"].items()]
+            current = stack(cfn, name)
+            method = cfn.update_stack if current else cfn.create_stack
+            try:
+                method(StackName=name, TemplateBody=body, Parameters=params, Capabilities=["CAPABILITY_NAMED_IAM"], Tags=tags)
+            except botocore.exceptions.ClientError as exc:
+                if current and "No updates are to be performed" in str(exc):
+                    print("No changes to apply.")
+                    return
+                raise
+            cfn.get_waiter("stack_update_complete" if current else "stack_create_complete").wait(StackName=name)
+            print(f"InstanceId: {instance_id(cfn, name)}")
+            return
+        instance = instance_id(cfn, name)
+        if args.action == "status":
+            ec2 = session.client("ec2")
+            info = ec2.describe_instances(InstanceIds=[instance])["Reservations"][0]["Instances"][0]
+            print(f"Instance {instance}: {info['State']['Name']}, {info.get('PublicIpAddress', 'no public IP')}")
+            ssm = session.client("ssm")
+            records = ssm.describe_instance_information(Filters=[{"Key": "InstanceIds", "Values": [instance]}])["InstanceInformationList"]
+            print(f"SSM: {records[0]['PingStatus'] if records else 'not registered'}")
+        elif args.action in ("start", "stop"):
+            ec2 = session.client("ec2")
+            getattr(ec2, args.action + "_instances")(InstanceIds=[instance])
+            ec2.get_waiter("instance_running" if args.action == "start" else "instance_stopped").wait(InstanceIds=[instance])
+            print(f"Instance {instance}: {'running' if args.action == 'start' else 'stopped'}")
+        elif args.action == "connect":
+            cmd = ["aws", "--profile", conf["profile"], "--region", conf["region"], "ssm", "start-session", "--target", instance]
+            if args.user:
+                cmd += ["--document-name", "AWS-StartInteractiveCommand", "--parameters", f"command=sudo -iu {username(args.user)}"]
+            subprocess.run(cmd, check=True)
+        elif args.action in ("ssh", "ssh-config"):
+            user = username(args.user)
+            key = args.key_path or Path.home() / ".ssh" / f"boxman-{name}-ed25519"
+            keypair(key)
+            add_key(session.client("ssm"), instance, user, Path(str(key) + ".pub"))
+            tunnel = proxy(conf)
+            if args.action == "ssh":
+                cmd = ["ssh", "-t", "-o", f"ProxyCommand={tunnel}", "-o", "StrictHostKeyChecking=accept-new", "-i", str(key), f"{user}@{instance}"]
+                if args.container:
+                    cmd.append(f"podman exec -it {shlex.quote(args.container)} bash")
+                subprocess.run(cmd, check=True)
+            else:
+                write_ssh_config(args.alias, f"Host {args.alias}\n    HostName {instance}\n    User {user}\n    IdentityFile {key}\n    ProxyCommand {tunnel}")
+                print(f"SSH host {args.alias} configured for {user}@{instance}")
+        elif args.action == "run":
+            execute(session.client("ssm"), instance, args.command, args.user)
+    except botocore.exceptions.BotoCoreError as exc:
+        raise SystemExit(f"AWS error: {exc}") from exc
+    except botocore.exceptions.ClientError as exc:
+        raise SystemExit(f"AWS error: {exc.response['Error'].get('Message', exc)}") from exc
+    except subprocess.CalledProcessError as exc:
+        raise SystemExit(f"Command failed ({exc.returncode}): {exc.cmd}") from exc

boxman/system.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Install shared Ubuntu packages and prepare users for rootless Podman."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import pwd
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+SUBID_START = 100_000
+SUBID_COUNT = 65_536
+USERNAME = re.compile(r"[a-z_][a-z0-9_-]{0,31}")
+
+RECIPE = Path(__file__).resolve().parent / "data" / "linux-tools.toml"
+ZIPGET_URL = (
+    "https://github.com/vivainio/zipget-rs/releases/latest/download/"
+    "zipget-linux-x64-musl"
+)
+
+
+def log(message: str) -> None:
+    print(f"[system-setup] {message}", flush=True)
+
+
+def run(*args: str, env: dict[str, str] | None = None) -> None:
+    log(f"running: {' '.join(args)}")
+    subprocess.run(args, check=True, env=env)
+
+
+def supports_system_packages(zipget: Path) -> bool:
+    result = subprocess.run(
+        (str(zipget), "recipe", "--help"),
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    return result.returncode == 0 and "--system-only" in result.stdout
+
+
+def install_zipget(temp: Path) -> Path:
+    installed = shutil.which("zipget")
+    if installed and supports_system_packages(Path(installed)):
+        return Path(installed)
+
+    zipget = temp / "zipget"
+    log(f"downloading {ZIPGET_URL}")
+    request = urllib.request.Request(ZIPGET_URL, headers={"User-Agent": "boxman"})
+    with urllib.request.urlopen(request, timeout=120) as response:  # noqa: S310
+        zipget.write_bytes(response.read())
+    zipget.chmod(0o755)
+    if not supports_system_packages(zipget):
+        sys.exit("zipget release does not support recipe --system-only yet")
+    return zipget
+
+
+def os_release() -> dict[str, str]:
+    values: dict[str, str] = {}
+    for line in Path("/etc/os-release").read_text().splitlines():
+        if "=" in line:
+            key, value = line.split("=", 1)
+            values[key] = value.strip('"')
+    return values
+
+
+def allocated_ranges(path: Path) -> list[tuple[int, int]]:
+    ranges = []
+    for line in path.read_text().splitlines():
+        try:
+            _, start, count = line.split(":")
+            ranges.append((int(start), int(count)))
+        except ValueError:
+            continue
+    return ranges
+
+
+def next_subid(path: Path) -> int:
+    next_id = max(
+        (start + count for start, count in allocated_ranges(path)),
+        default=SUBID_START,
+    )
+    next_id = max(next_id, SUBID_START)
+    remainder = (next_id - SUBID_START) % SUBID_COUNT
+    return next_id if remainder == 0 else next_id + SUBID_COUNT - remainder
+
+
+def has_subid(path: Path, username: str) -> bool:
+    return any(
+        line.partition(":")[0] == username for line in path.read_text().splitlines()
+    )
+
+
+def ensure_subid(username: str, path: Path, flag: str) -> None:
+    if has_subid(path, username):
+        return
+    start = next_subid(path)
+    end = start + SUBID_COUNT - 1
+    run("usermod", flag, f"{start}-{end}", username)
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--packages-only",
+        action="store_true",
+        help="install shared packages without configuring login users",
+    )
+    parser.add_argument("users", nargs="*", help="existing Unix users to configure")
+    return parser.parse_args(argv)
+
+
+def regular_users() -> list[str]:
+    """Return normal login users, excluding nobody and system accounts."""
+    return sorted(
+        entry.pw_name
+        for entry in pwd.getpwall()
+        if 1_000 <= entry.pw_uid < 65_534
+        and entry.pw_shell not in {"/usr/sbin/nologin", "/bin/false"}
+    )
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = parse_args(argv)
+    if os.geteuid() != 0:
+        sys.exit("boxman system must run as root")
+
+    release = os_release()
+    if release.get("ID") != "ubuntu" or release.get("VERSION_ID") != "24.04":
+        sys.exit(
+            "Ubuntu 24.04 is required "
+            f"(found {release.get('ID', 'unknown')} {release.get('VERSION_ID', 'unknown')})"
+        )
+
+    if args.packages_only and args.users:
+        sys.exit("--packages-only cannot be combined with usernames")
+
+    users = [] if args.packages_only else (args.users or regular_users())
+    if not args.packages_only and not args.users:
+        log(f"auto-detected login users: {', '.join(users) if users else '(none)'}")
+
+    for username in users:
+        if not USERNAME.fullmatch(username):
+            sys.exit(f"invalid Unix username: {username!r}")
+        try:
+            pwd.getpwnam(username)
+        except KeyError:
+            raise SystemExit(f"user does not exist: {username}") from None
+
+    if not RECIPE.is_file():
+        sys.exit(f"missing zipget recipe: {RECIPE}")
+    with tempfile.TemporaryDirectory(prefix="linux-system-") as temp_name:
+        zipget = install_zipget(Path(temp_name))
+        apt_env = {**os.environ, "DEBIAN_FRONTEND": "noninteractive"}
+        run(str(zipget), "recipe", str(RECIPE), "--system-only", env=apt_env)
+    run("git", "lfs", "install", "--system")
+
+    if args.packages_only:
+        log("package-only system setup complete")
+        return
+
+    for username in users:
+        log(f"configuring rootless Podman prerequisites for {username}")
+        ensure_subid(username, Path("/etc/subuid"), "--add-subuids")
+        ensure_subid(username, Path("/etc/subgid"), "--add-subgids")
+        run("loginctl", "enable-linger", username)
+
+    if not users:
+        log("no login users found; user Podman setup skipped")
+    log("system setup complete")
+
+
+if __name__ == "__main__":
+    main()

boxman/user.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""Install per-user AI development tools without storing credentials."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+NODE_MAJOR = 22
+HOME = Path.home()
+LOCAL_BIN = HOME / ".local" / "bin"
+NODE_ROOT = HOME / ".local" / "share" / f"node-v{NODE_MAJOR}"
+SCRIPT_DIR = Path(__file__).resolve().parent
+TOOLS_RECIPE = SCRIPT_DIR / "data" / "linux-tools.toml"
+ZIPGET_URL = (
+    "https://github.com/vivainio/zipget-rs/releases/latest/download/"
+    "zipget-linux-x64-musl"
+)
+CLAUDE_INSTALL_URL = "https://claude.ai/install.sh"
+COPILOT_INSTALL_URL = "https://gh.io/copilot-install"
+UV_INSTALL_URL = "https://astral.sh/uv/install.sh"
+
+
+def log(message: str) -> None:
+    print(f"[user-setup] {message}", flush=True)
+
+
+def run(
+    *args: str,
+    env: dict[str, str] | None = None,
+    cwd: Path | None = None,
+) -> None:
+    log(f"running: {' '.join(args)}")
+    subprocess.run(args, check=True, env=env, cwd=cwd)
+
+
+def download(url: str, destination: Path) -> None:
+    log(f"downloading {url}")
+    request = urllib.request.Request(url, headers={"User-Agent": "boxman"})
+    with urllib.request.urlopen(request, timeout=120) as response:  # noqa: S310
+        destination.write_bytes(response.read())
+
+
+def node_architecture() -> str:
+    machine = platform.machine().lower()
+    try:
+        return {"x86_64": "x64", "aarch64": "arm64", "arm64": "arm64"}[machine]
+    except KeyError:
+        sys.exit(f"unsupported CPU architecture: {machine}")
+
+
+def find_node_archive(checksums: str, architecture: str) -> tuple[str, str]:
+    suffix = f"-linux-{architecture}.tar.xz"
+    for line in checksums.splitlines():
+        digest, _, filename = line.partition("  ")
+        if filename.endswith(suffix):
+            return filename, digest
+    sys.exit(f"no Node.js {NODE_MAJOR} archive found for {architecture}")
+
+
+def install_node(temp: Path) -> None:
+    base_url = f"https://nodejs.org/dist/latest-v{NODE_MAJOR}.x"
+    checksums_path = temp / "SHASUMS256.txt"
+    download(f"{base_url}/SHASUMS256.txt", checksums_path)
+    filename, expected_digest = find_node_archive(
+        checksums_path.read_text(), node_architecture()
+    )
+
+    archive = temp / filename
+    download(f"{base_url}/{filename}", archive)
+    actual_digest = hashlib.sha256(archive.read_bytes()).hexdigest()
+    if actual_digest != expected_digest:
+        sys.exit("Node.js checksum verification failed")
+
+    shutil.rmtree(NODE_ROOT, ignore_errors=True)
+    NODE_ROOT.mkdir(parents=True)
+    with tarfile.open(archive, "r:xz") as bundle:
+        members = bundle.getmembers()
+        top_directory = Path(members[0].name).parts[0]
+        for member in members:
+            member.name = str(Path(member.name).relative_to(top_directory))
+            if member.name != ".":
+                bundle.extract(member, NODE_ROOT, filter="data")
+
+    for executable in ("node", "npm", "npx", "corepack"):
+        link = LOCAL_BIN / executable
+        link.unlink(missing_ok=True)
+        link.symlink_to(NODE_ROOT / "bin" / executable)
+
+
+def install_zipget() -> Path:
+    zipget = LOCAL_BIN / "zipget"
+    if not zipget.exists():
+        download(ZIPGET_URL, zipget)
+        zipget.chmod(0o755)
+    return zipget
+
+
+def install_recipe_tools(zipget: Path) -> None:
+    if not TOOLS_RECIPE.is_file():
+        sys.exit(f"missing zipget recipe: {TOOLS_RECIPE}")
+    with tempfile.TemporaryDirectory(prefix="linux-tools-") as stage_name:
+        stage = Path(stage_name)
+        # The root setup handles apt packages. Keep this step compatible with
+        # zipget releases predating [system_packages] support.
+        lines = TOOLS_RECIPE.read_text().splitlines(keepends=True)
+        user_lines = []
+        in_system_packages = False
+        for line in lines:
+            if line.strip() == "[system_packages]":
+                in_system_packages = True
+            elif in_system_packages and line.lstrip().startswith("["):
+                in_system_packages = False
+            if not in_system_packages:
+                user_lines.append(line)
+        user_recipe = stage / "user-tools.toml"
+        user_recipe.write_text("".join(user_lines))
+        run(str(zipget), "recipe", str(user_recipe), cwd=stage)
+
+        aws_installer = stage / "aws-cli-installer" / "aws" / "install"
+        if not aws_installer.is_file():
+            sys.exit(
+                f"zipget did not produce the AWS CLI installer at {aws_installer}"
+            )
+        args = [
+            str(aws_installer),
+            "--install-dir",
+            str(HOME / ".local" / "aws-cli"),
+            "--bin-dir",
+            str(LOCAL_BIN),
+        ]
+        if (HOME / ".local" / "aws-cli").exists():
+            args.append("--update")
+        run(*args)
+
+
+def install_claude_code(temp: Path) -> None:
+    installer = temp / "install-claude-code.sh"
+    download(CLAUDE_INSTALL_URL, installer)
+    run("bash", str(installer))
+
+
+def install_copilot(temp: Path) -> None:
+    installer = temp / "install-copilot.sh"
+    download(COPILOT_INSTALL_URL, installer)
+    env = {**os.environ, "PREFIX": str(HOME / ".local")}
+    run("bash", str(installer), env=env)
+
+
+def install_uv(temp: Path) -> None:
+    installer = temp / "install-uv.sh"
+    download(UV_INSTALL_URL, installer)
+    env = {
+        **os.environ,
+        "UV_INSTALL_DIR": str(LOCAL_BIN),
+        "UV_NO_MODIFY_PATH": "1",
+    }
+    run("sh", str(installer), env=env)
+
+
+def main() -> None:
+    if os.geteuid() == 0:
+        sys.exit("boxman user must run as the target user, not root")
+
+    LOCAL_BIN.mkdir(parents=True, exist_ok=True)
+    NODE_ROOT.parent.mkdir(parents=True, exist_ok=True)
+
+    zipget = install_zipget()
+    install_recipe_tools(zipget)
+
+    with tempfile.TemporaryDirectory(prefix="boxman-user-") as temp_name:
+        temp = Path(temp_name)
+        install_node(temp)
+        install_claude_code(temp)
+        install_copilot(temp)
+        install_uv(temp)
+
+    log("user setup complete; authenticate claude, copilot, and gh interactively")
+
+
+if __name__ == "__main__":
+    main()

boxman/verify.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""Verify a user's AI development tool installation."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+
+COMMANDS = {
+    "git": ("--version",),
+    "gocryptfs": ("-version",),
+    "gh": ("--version",),
+    "podman": ("--version",),
+    "node": ("--version",),
+    "npm": ("--version",),
+    "zipget": ("--version",),
+    "aws": ("--version",),
+    "herdr": ("--version",),
+    "cship": ("--version",),
+    "starship": ("--version",),
+    "fd": ("--version",),
+    "bat": ("--version",),
+    "zoxide": ("--version",),
+    "delta": ("--version",),
+    "uv": ("--version",),
+    "claude": ("--version",),
+    "copilot": ("version",),
+}
+
+
+def main() -> None:
+    failures = 0
+    for command, args in COMMANDS.items():
+        if not shutil.which(command):
+            print(f"MISSING  {command}")
+            failures += 1
+            continue
+        result = subprocess.run(
+            (command, *args), capture_output=True, text=True, timeout=20, check=False
+        )
+        output = (result.stdout or result.stderr).splitlines()
+        if result.returncode == 0:
+            print(f"OK       {command:<10} {output[0] if output else ''}")
+        else:
+            print(f"FAILED   {command:<10} {output[0] if output else ''}")
+            failures += 1
+
+    if shutil.which("podman"):
+        result = subprocess.run(
+            ("podman", "info", "--format", "{{.Host.Security.Rootless}}"),
+            capture_output=True,
+            text=True,
+            timeout=20,
+            check=False,
+        )
+        if result.returncode == 0 and result.stdout.strip() == "true":
+            print("OK       rootless Podman")
+        else:
+            print("FAILED   Podman is not running rootless")
+            failures += 1
+
+    raise SystemExit(failures)
+
+
+if __name__ == "__main__":
+    main()

boxman-0.1.0.dist-info/METADATA

@@ -0,0 +1,169 @@
+Metadata-Version: 2.4
+Name: boxman
+Version: 0.1.0
+Summary: Set up and manage an Ubuntu development box
+Project-URL: Homepage, https://github.com/vivainio/boxman
+Project-URL: Documentation, https://vivainio.github.io/boxman/
+Project-URL: Repository, https://github.com/vivainio/boxman
+Project-URL: Issues, https://github.com/vivainio/boxman/issues
+Keywords: ubuntu,development,ec2,cloudformation,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Provides-Extra: ec2
+Requires-Dist: boto3>=1.34; extra == "ec2"
+
+# boxman
+
+[Read the Boxman book](https://vivainio.github.io/boxman/) for the concepts, setup steps, and command reference.
+
+Set up and manage an Ubuntu 24.04 development box. `boxman` is a Python command
+with system, user, and vault operations.
+
+## Install a host
+
+From this checkout, run the system step as root, then the user step from each
+login account. The first command works with the Ubuntu system Python before
+`uv` is installed:
+
+```bash
+sudo python3 -m boxman.cli system
+python3 -m boxman.cli user
+```
+
+With `uv` available, run it without installing the package:
+
+```bash
+uvx --from . boxman vault status
+```
+
+After publishing the repository, `uvx --from
+git+https://github.com/vivainio/boxman boxman ...` can run the same console
+command. For a persistent command, use `uv tool install .` from this checkout.
+
+`boxman system` uses zipget to install the apt packages declared in
+`linux-tools.toml`, sets up Git LFS, and configures rootless Podman for normal
+login users. It accepts explicit usernames, or `--packages-only` for a
+container build. It downloads zipget if no version supporting
+`recipe --system-only` is on root's PATH. A fresh install needs a released
+zipget with that option.
+
+`boxman user` installs the tools in the recipe, Node.js 22, Claude Code,
+Copilot CLI, and uv. Run the user step for each account.
+Run `boxman verify` afterward to check the installed commands and rootless
+Podman.
+
+The same package set can be used in a dev container:
+
+```bash
+podman build -f container/Dockerfile -t boxman-dev .
+```
+
+The container build skips host login-user and systemd configuration. FUSE
+mounting may require additional container privileges, so the vault commands
+are intended for the native host.
+
+## Private directory
+
+The recipe installs `gocryptfs` and FUSE 3. Each user initializes their own
+vault once and unlocks it after a reboot or unmount:
+
+```bash
+uvx --from . boxman vault init
+uvx --from . boxman vault unlock
+uvx --from . boxman vault status
+uvx --from . boxman claude  # starts Claude with its config in the mounted vault
+uvx --from . boxman vault lock  # after stopping processes that use the mount
+```
+
+Encrypted files live in `~/.private.cipher`; the plaintext mount is
+`~/private`. Initialization and unlocking prompt for the password. Keep the
+password and gocryptfs recovery key outside the host. Back up the encrypted
+directory, including `gocryptfs.conf`, while keeping the plaintext mount out
+of backups.
+
+`boxman claude` refuses to run unless the vault is mounted. Use it before the
+first Claude login. It sets `CLAUDE_CONFIG_DIR` to `~/private/claude` and does
+not move existing credentials from `~/.claude`. Configure other tools'
+credential locations separately if they should use the vault. Persistent
+agents need the vault mounted while they use credentials. Locking fails while
+a process holds files in the mount open.
+
+The vault protects its backing files and snapshots while locked. It does not
+hide credentials from the user's running processes or a host administrator
+while unlocked. Keep home directory permissions private to each Unix owner.
+
+## EC2 host
+
+Install the optional AWS dependency, then create
+`${XDG_CONFIG_HOME:-~/.config}/boxman/ec2.toml`:
+
+```bash
+uv tool install '.[ec2]'
+mkdir -p "${XDG_CONFIG_HOME:-$HOME/.config}/boxman"
+```
+
+```toml
+[ec2]
+profile = "your-aws-profile"
+region = "your-region"
+stack_name = "your-stack-name"
+
+[ec2.tags]
+Owner = "your-owner"
+Environment = "your-environment"
+```
+
+The config contains no credentials; AWS uses the named profile. Supply the tags
+required by your account. The TOML file selects the AWS profile, region, stack,
+and tags. Command-line options override the file;
+`--tag KEY=VALUE` adds or overrides a tag. `--config PATH` selects another TOML
+file. Put global options before the action:
+
+```bash
+boxman ec2 init --vpc-id vpc-... --subnet-id subnet-... \
+  --instance-type t3.xlarge --volume-size-gb 100 \
+  --instance-name mybox \
+  --ami-id /aws/service/canonical/ubuntu/server/24.04/stable/current/amd64/hvm/ebs-gp3/ami-id
+boxman ec2 deploy
+boxman ec2 status
+boxman ec2 start
+boxman ec2 stop
+boxman ec2 connect -u myuser
+boxman ec2 ssh -u myuser
+boxman ec2 ssh-config -u myuser --alias mybox
+boxman ec2 run -u myuser 'uname -a'
+```
+
+`init` writes `${XDG_CONFIG_HOME:-~/.config}/boxman/stacks/<stack_name>.yaml`
+with the instance settings as parameter defaults and refuses to overwrite an
+existing file. Edit that YAML to customize the stack. `deploy` reads the YAML
+for the configured stack name and sends its defaults as CloudFormation
+parameters. Tags from `[ec2.tags]` and repeatable
+`--tag KEY=VALUE` options become CloudFormation stack tags. A single config
+file selects one stack; use `--config PATH` for another box.
+
+Deployment creates or updates a CloudFormation stack containing an Ubuntu EC2
+instance, an SSM role, and an EC2 Instance Connect Endpoint. SSH uses that
+endpoint and installs a generated public key through SSM. `ssh-config` writes a
+marked host entry to `~/.ssh/config`. The stack name selects the instance for
+all subsequent commands. Starting, stopping, and deploying incur AWS charges.
+
+## Release
+
+Build the Zensical book locally with `zensical build --clean`. The docs workflow
+publishes it to GitHub Pages when documentation changes on `main`.
+
+A published GitHub release triggers the PyPI workflow. Use a `vX.Y.Z` tag;
+the workflow sets the package version from the release tag, builds the wheel
+and source distribution, and publishes with PyPI trusted publishing. Configure
+a PyPI trusted publisher for repository `vivainio/boxman`, workflow
+`publish.yml`, environment `pypi` before the first release.

boxman-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+boxman/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boxman/cli.py,sha256=EZ35JcoM9o-FgCC1HFb594l8d9x0xSvKUm_YcE5XecA,4012
+boxman/ec2.py,sha256=Lsr17vnQvYNyzxb-yi6yb7VkqgUB5yn3xmmx8gjxFKY,14119
+boxman/system.py,sha256=LnD66M_3j3eJ4ThzUt1e149qOzN0u18EiDf-EbHIXls,5655
+boxman/user.py,sha256=HFnDuk3G-B1jEp3f3qmp5OM1e4Ka5aROZUuULNEgDLE,6179
+boxman/verify.py,sha256=TUDM90uAoDkVQhPVqmMDG3Mnh2aARPjC0Df36jGgJ5Q,1848
+boxman/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+boxman/data/ec2-template.yaml,sha256=1khSQuedLGlYKhYhcRkIMa6ms-43_RGjMw6SKCRnSmM,3753
+boxman/data/linux-tools.toml,sha256=dX43xzB7tT0_nSj0C5X8IGwxdW3bZ9n_-LfCbdRH57w,2511
+boxman-0.1.0.dist-info/METADATA,sha256=CXozDBpVsDCOEYKS_NDMgXm9INOW7ryqm_YLwBTG6wc,6608
+boxman-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+boxman-0.1.0.dist-info/entry_points.txt,sha256=NCnQD5BTI7cuNJaO7FM1NIR6xownHScvOvlLRWKwV0M,43
+boxman-0.1.0.dist-info/top_level.txt,sha256=l75VydLS2iSnvvs6j0TWg-QekP0OIhkTk-WIvKgQknI,7
+boxman-0.1.0.dist-info/RECORD,,

boxman-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

boxman-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+boxman = boxman.cli:main

boxman-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+boxman